การแสดงภาพ Attention: หัวใจของ Transformer [วิดีโอ]

 (3blue1brown.com)
1 คะแนน โดย GN⁺ 2024-04-15 | 1 ความคิดเห็น | แชร์ทาง WhatsApp
  • Attention ของ Transformer คือกลไกที่อัปเดต embedding ของ token ให้สอดคล้องกับบริบท ทำให้แม้เป็นคำเดียวกัน เวกเตอร์ก็เคลื่อนไปสู่ความหมายที่ต่างกันตามคำรอบข้าง
  • attention head หนึ่งตัวสร้างเวกเตอร์ query/key/value จากแต่ละ token แล้วคำนวณ attention pattern ซึ่งเป็นน้ำหนักความเกี่ยวข้องระหว่างคำ ด้วย dot product ของ key-query และ softmax
  • โมเดล autoregressive แบบ GPT ใช้ masking เพื่อไม่ให้ token ด้านหลังส่งผลต่อ token ด้านหน้า และเนื่องจากขนาดของ attention pattern เป็นกำลังสองของความยาวบริบท การขยาย context window ขนาดใหญ่จึงเป็นภาระมาก
  • ในตัวอย่าง GPT-3 เมทริกซ์ key/query มีพารามิเตอร์อย่างละ 1,572,864 ตัว และ value map ถูกแบ่งเป็นการแปลงแบบ low-rank ทำให้ต่อหนึ่ง head มีพารามิเตอร์ประมาณ 6.3 ล้านตัว
  • Transformer ที่ทำ attention head และ block หลายชุดซ้ำ ๆ จะเรียนรู้วิธีอัปเดตบริบทได้หลากหลาย และแกนสำคัญของความสำเร็จอยู่ที่ ความสามารถในการทำ parallelization เพื่อประมวลผลการคำนวณจำนวนมากบน GPU ได้อย่างรวดเร็ว

บทบาทของ attention ใน Transformer

  • Transformer ใช้ข้อความอินพุตเพื่อทำนาย token ถัดไป โดยอินพุตจะถูก tokenize ก่อน เพื่อแบ่งเป็นคำหรือชิ้นส่วนของคำ
  • แต่ละ token จะถูกแปลงเป็น embedding ซึ่งเป็นเวกเตอร์มิติสูง
    • ทิศทางใน embedding space นี้สามารถสอดคล้องกับความหมายได้
    • ตัวอย่างเช่น การเลื่อนไปในทิศทางหนึ่งอาจย้าย embedding ของคำนามเพศชายไปยัง embedding ของคำนามเพศหญิงที่สอดคล้องกันได้
  • เป้าหมายของ attention คือค่อย ๆ ปรับ embedding เริ่มต้น เพื่อให้ไม่เพียงมีข้อมูลของคำเดี่ยว ๆ แต่ยังบรรจุ ความหมายเชิงบริบท ที่สมบูรณ์ยิ่งขึ้นด้วย

เหตุผลที่คำเดียวกันเปลี่ยนไปตามบริบท

  • ใน “American shrew mole”, “One mole of carbon dioxide”, “Take a biopsy of the mole” คำว่า mole มีความหมายต่างกัน
  • ในขั้น embedding แรก เวกเตอร์ของ mole ใกล้เคียงกับ lookup table ที่ไม่ดูบริบท จึงเหมือนกันทั้งสามกรณี
  • ในขั้นถัดไปคือ attention block embedding รอบข้างสามารถส่งข้อมูลไปยัง embedding ของ mole เพื่ออัปเดตค่าได้
  • โมเดลที่เรียนรู้มาอย่างดีจะเชื่อมโยงความหมายหลายแบบของ mole กับทิศทางต่าง ๆ ใน embedding space และคำนวณว่าจะเติมอะไรเข้าไปใน embedding ทั่วไปตามบริบท
  • เช่น “Eiffel tower” และ “miniature Eiffel tower” embedding ของคำหนึ่งสามารถถูกอัปเดตได้ไม่เพียงจากคำใกล้ ๆ แต่ยังจากข้อมูลที่มาจาก token ที่อยู่ไกลออกไปด้วย
  • ในการทำนายคำถัดไป จะใช้เฉพาะเวกเตอร์สุดท้ายเท่านั้น ดังนั้น embedding ของคำสุดท้ายในอินพุตยาว ๆ จึงต้องบรรจุข้อมูลบริบททั้งหมดที่จำเป็นต่อการทำนายไว้ในระดับหนึ่ง

ลำดับการคำนวณของ attention head เดี่ยว

  • คำอธิบายพื้นฐานจะอิงกับ single head of attention
  • ในประโยคตัวอย่าง “A fluffy blue creature roamed the verdant forest.” สมมติสถานการณ์ที่คำคุณศัพท์อัปเดต embedding เริ่มต้นของคำนามที่สอดคล้องกัน
    • ตัวอย่างนี้มีไว้เพื่อแสดงสิ่งที่ attention head สามารถทำได้
    • พฤติกรรมจริงของ head ตีความได้ยาก เพราะเป็นผลจากการที่พารามิเตอร์จำนวนมากถูกปรับเพื่อลด cost function
  • embedding เริ่มต้นมีทั้งข้อมูลคำและข้อมูลตำแหน่ง และแสดงเป็น \vec{E}
  • เป้าหมายคือสร้าง embedding ใหม่ \vec{E}' ที่สะท้อนบริบทจาก embedding เดิม

  • Query

    • ขั้นแรก คูณ embedding ของแต่ละ token ด้วย query matrix W_Q เพื่อสร้างเวกเตอร์ query \vec{Q}
    • อาจคิดได้ว่าคำนามตั้งคำถามทำนองว่า “มีคำคุณศัพท์อยู่ข้างหน้าหรือไม่?”
    • องค์ประกอบของ W_Q เป็นพารามิเตอร์ของโมเดลที่เรียนรู้ได้ และตีความได้ยากว่า head ใด head หนึ่งทำอะไรจริง ๆ
    • ในเชิงตัวอย่าง อาจมองว่าเป็นการ map embedding ของคำนามไปยังทิศทางที่ “มองหาคำคุณศัพท์ในตำแหน่งก่อนหน้า”

  • Key

    • พร้อมกันนั้น คูณ embedding แต่ละตัวด้วย key matrix W_k เพื่อสร้างเวกเตอร์ key \vec{K}
    • key มองได้ว่าเป็นคำตอบที่เป็นไปได้ต่อ query และอยู่ใน space มิติเล็กกว่าชุดเดียวกับ query
    • ระดับการเรียงแนวกันของ key และ query วัดด้วย dot product
    • ยิ่ง dot product ใหญ่ เวกเตอร์ทั้งสองก็ยิ่งเรียงแนวกันมากขึ้น
    • หาก key ของ fluffy และ blue เข้ากันได้ดีกับ query ของ creature ก็จะได้ค่าบวกขนาดใหญ่
    • เมื่อคำนวณ dot product ของ key-query ทุกคู่ จะได้ตารางคะแนนที่บอกว่าคำใดเกี่ยวข้องกับการอัปเดตความหมายของคำอื่นมากเพียงใด

Attention pattern และ softmax

  • คะแนน dot product อาจมีค่าตั้งแต่ -\infty ถึง \infty จึงใช้ softmax กับแต่ละคอลัมน์เพื่อ normalize ให้เป็นค่าระหว่าง 0 ถึง 1
  • ตารางที่ normalize แล้วเรียกว่า attention pattern
    • แต่ละคอลัมน์มองได้ว่าเป็นน้ำหนักว่าคำทางซ้ายเกี่ยวข้องกับการอัปเดตคำด้านบนมากเพียงใด
  • บทความ Transformer ต้นฉบับเขียนสิ่งนี้ในรูปแบบที่กระชับกว่า
    • Q และ K คืออาร์เรย์ทั้งหมดของเวกเตอร์ query และ key
    • K^TQ แทนตาราง dot product ของ key-query ที่เป็นไปได้ทั้งหมด
    • ในสัญกรณ์ของบทความ query และ key อยู่ตามแถวและเขียนในรูป QK^T ทำให้เป็นรูปที่พลิกตามแนวทแยงจากภาพที่อธิบายที่นี่
  • เพื่อเสถียรภาพเชิงตัวเลข จะมีพจน์หารด้วย \sqrt{d_k} ซึ่งเป็นรากที่สองของมิติใน key-query space
  • softmax ครอบทั้งสมการ แต่ในเชิงความหมายจะถูกใช้แยกทีละคอลัมน์

Masking และข้อจำกัดของขนาด context

  • ระหว่างการฝึก โมเดลไม่ได้ทำนายแค่ token ถัดไปตัวเดียวจากข้อความที่ให้มา แต่ยังทำนาย token ถัดไปที่เป็นไปได้หลังแต่ละ subsequence ไปพร้อมกันด้วย
    • ตัวอย่างข้อความหนึ่งจึงทำงานเหมือนตัวอย่างฝึกหลายตัว ทำให้มีประสิทธิภาพสูงขึ้น
  • ในตัวอย่าง GPT หาก token ด้านหลังส่งผลต่อ token ด้านหน้า อาจทำให้คำตอบของ token ถัดไปรั่วไหลได้ จึงใช้ masking
    • ตั้งค่าตำแหน่งนั้นเป็นลบอนันต์ก่อน softmax
    • หลัง softmax ตำแหน่งนั้นจะเป็น 0 และคอลัมน์ยังคงอยู่ในสภาพที่ normalize แล้ว
  • ไม่ใช่ว่าจะมีเฉพาะ attention ที่ใช้ masking เสมอ แต่ในตัวอย่าง GPT จะใช้ตลอดเพื่อไม่ให้ token ด้านหลังส่งผลต่อ token ด้านหน้า
  • ขนาดของ attention pattern เท่ากับ กำลังสองของ context size
    • ด้วยเหตุนี้ context size จึงอาจเป็นข้อจำกัดสำคัญของโมเดลภาษาขนาดใหญ่
    • มีรูปแบบดัดแปลงที่ทำให้กลไก attention ขยายขนาดได้มากขึ้นสำหรับ context window ที่ใหญ่กว่า แต่ที่นี่จะกล่าวถึงเฉพาะรูปแบบพื้นฐานเท่านั้น

วิธีที่ value ใช้อัปเดต embedding จริง

  • attention pattern ให้น้ำหนักว่าคำใดจะอัปเดตคำใด และขั้นถัดไปคือการสร้างปริมาณการเปลี่ยนแปลงจริงของ embedding
  • คูณ embedding แต่ละตัวด้วย value matrix W_V เพื่อสร้างเวกเตอร์ value
    • เวกเตอร์ value อยู่ใน space มิติสูงเดียวกับ embedding
    • มันบอกว่าเมื่อคำที่เกี่ยวข้องปรับความหมายของคำอื่น ควรเพิ่มการเปลี่ยนแปลงที่เป็นรูปธรรมแบบใด
  • ในแต่ละคอลัมน์ เมื่อนำเวกเตอร์ value มาคูณด้วยน้ำหนักที่สอดคล้องกันใน attention pattern แล้วรวมทั้งหมด จะได้ปริมาณการเปลี่ยนแปลง \Delta \vec{E}
  • เมื่อเพิ่มการเปลี่ยนแปลงนี้เข้าไปใน embedding เดิม จะได้ embedding ใหม่ \vec{E}' ที่สะท้อนบริบท
    • ในตัวอย่าง creature ดูดซับข้อมูลของ fluffy และ blue จึงมีความหมายใกล้กับ “fluffy blue creature” มากขึ้น
  • เมื่อนำกระบวนการเดียวกันไปใช้กับทุกคอลัมน์ จะได้ embedding ที่ปรับแต่งแล้วสำหรับลำดับ token ทั้งหมดออกมาจาก attention block
  • attention head เดี่ยวถูกกำหนดพารามิเตอร์ด้วยเมทริกซ์พารามิเตอร์ที่เรียนรู้ได้สามประเภท ได้แก่ key matrix, query matrix, value matrix

การคำนวณพารามิเตอร์ตาม GPT-3

  • ในตัวอย่าง GPT-3 เมทริกซ์ key และ query มีคอลัมน์ 12,288 คอลัมน์ ซึ่งสอดคล้องกับมิติ embedding และมีแถว 128 แถว ซึ่งสอดคล้องกับมิติของ key-query space
    • แต่ละเมทริกซ์มี พารามิเตอร์ 1,572,864 ตัว
  • หากกำหนด value matrix เป็นเมทริกซ์จัตุรัส 12,288×12,288 จะเพิ่ม พารามิเตอร์ 150,994,944 ตัว ซึ่งใหญ่กว่า key/query มาก
  • ในทางปฏิบัติ การแยก value map ออกเป็นเมทริกซ์เล็กสองตัวเพื่อทำให้จำนวนพารามิเตอร์ใกล้เคียงกับ key/query จะมีประสิทธิภาพกว่า
    • เมทริกซ์ตัวแรกลด embedding space ขนาดใหญ่ลงเป็น space เล็ก เช่น 128 มิติ
    • เมทริกซ์ตัวที่สองยกจาก space เล็กกลับขึ้นไปเป็น embedding space
    • จากมุมมองพีชคณิตเชิงเส้น นี่คือการจำกัด value map ทั้งหมดให้เป็น การแปลงแบบ low-rank
  • ในคำอธิบายนี้เรียกเมทริกซ์ทั้งสองว่า Value_\downarrow, Value_\uparrow แต่ไม่ใช่ชื่อที่ใช้กันตามธรรมเนียม
  • เมื่อรวมเมทริกซ์ทั้งสี่แล้ว attention head หนึ่งตัวมีพารามิเตอร์ประมาณ 6.3 ล้านตัว

Self-attention และ cross-attention

  • โครงสร้างถึงตรงนี้ หากกล่าวให้แม่นยำยิ่งขึ้นคือ self-attention head
  • cross-attention head ปรากฏในโมเดลที่ประมวลผลชุดข้อมูลสองชุดที่ต่างกัน
    • ตัวอย่างเช่น ในโมเดลแปลภาษา key อาจมาจากภาษาหนึ่ง และ query มาจากอีกภาษาหนึ่ง
    • attention pattern สามารถแสดงว่าคำในภาษาหนึ่งสอดคล้องกับคำในอีกภาษาอย่างไร
  • ใน cross-attention จุดที่ต่างจาก self-attention คือ key map และ query map ทำงานกับ dataset ที่ต่างกัน
  • ในการตั้งค่าอย่างการแปลภาษา มักไม่มี masking เพราะดูเหมือนไม่มีแนวคิดที่ token ด้านหลังส่งผลต่อ token ด้านหน้า

Multi-headed attention และ block ที่ทำซ้ำ

  • attention block จริงประกอบด้วย multi-headed attention ที่รันหลาย head แบบขนาน
  • GPT-3 ใช้ attention head 96 ตัว ในแต่ละ block
    • เมทริกซ์ key/query ที่แตกต่างกัน 96 ชุดสร้าง attention pattern ที่แตกต่างกัน 96 แบบ
    • แต่ละ head สร้างลำดับเวกเตอร์ value ด้วยเมทริกซ์ value ของตัวเอง
    • ที่แต่ละตำแหน่งของ token จะรวมปริมาณการเปลี่ยนแปลง \Delta \vec{E} ที่ทุก head เสนอ แล้วบวกเข้ากับ embedding เดิม
  • การรันหลาย head แบบขนานทำให้โมเดลมีความจุในการเรียนรู้หลายวิธีที่บริบทเปลี่ยนความหมาย
  • ใน GPT-3 block ของ multi-headed attention หนึ่ง block ที่มี 96 head มีพารามิเตอร์ประมาณ 600 ล้านตัว
  • ในบทความและการใช้งานจริง เมทริกซ์ที่สอดคล้องกับ Value_\uparrow ของแต่ละ head จะถูกรวมเป็น output matrix ขนาดใหญ่ตัวเดียวและเชื่อมกับ multi-headed attention block ทั้งหมด
    • โดยทั่วไปเมื่อพูดถึง value matrix ของ head ใด head หนึ่ง จะหมายถึงขั้น projection แรกที่เรียกว่า Value_\downarrow ในที่นี้

วิธีที่ความหมายสะสมใน Transformer ที่ลึกขึ้น

  • ข้อมูลภายใน Transformer ไม่ได้ผ่าน attention block เพียงตัวเดียว แต่ผ่าน attention block หลายตัวและ multi-layer perceptron
  • แม้ embedding ของคำหนึ่งจะดูดซับบริบทบางส่วนไปแล้ว ก็ยังมีโอกาสได้รับอิทธิพลจาก embedding รอบข้างที่ประณีตขึ้นต่อไป
  • ยิ่งเครือข่ายลึกขึ้น embedding แต่ละตัวก็ยิ่งรับความหมายจาก embedding อื่นมากขึ้น และมีความจุในการ encode คุณลักษณะเชิงนามธรรมระดับสูงขึ้น เช่น อารมณ์ โทน หรือเป็นบทกวีหรือไม่
  • GPT-3 มี 96 layer และพารามิเตอร์ที่เกี่ยวข้องกับ key/query/value ถูกอธิบายว่ามีรวม น้อยกว่า 58,000 ล้านตัว
  • นี่คิดเป็นประมาณหนึ่งในสามของพารามิเตอร์ทั้งเครือข่าย และส่วนที่เหลือจำนวนมากมาจาก block ที่อยู่ระหว่าง attention
  • ความสำเร็จส่วนใหญ่ของกลไก attention ไม่ได้อยู่ที่พฤติกรรมเฉพาะอย่างใดอย่างหนึ่ง แต่อยู่ที่ ความสามารถในการทำ parallelization สูง ซึ่งทำให้ใช้ GPU คำนวณจำนวนมากได้ในเวลาสั้น
  • เพราะบทเรียนจาก deep learning คือการขยายขนาดสามารถนำไปสู่การปรับปรุงเชิงคุณภาพครั้งใหญ่ในความสามารถของโมเดล สถาปัตยกรรมที่ parallelize ได้และเอื้อต่อการขยายจึงมีข้อได้เปรียบมาก

บทความที่เกี่ยวข้อง

1 ความคิดเห็น

 
GN⁺ 2024-04-15
ความคิดเห็นจาก Hacker News

  • จากมุมมองของคนที่ทำเคมีควอนตัมและแมชชีนเลิร์นนิงมาบ้าง พอดูวิดีโอนี้แล้ว ความคล้ายคลึงระหว่าง โมเดล Transformer กับ กลศาสตร์ควอนตัม ค่อนข้างสะดุดตา
    ในกลศาสตร์ควอนตัม สถานะของระบบทางกายภาพทั้งหมดถูกเข้ารหัสเป็นเวกเตอร์ที่ถูกทำให้เป็นปกติในมิติสูงมาก หรือก็คือครึ่งเส้นตรงในปริภูมิ Hilbert และการเปลี่ยนแปลงตามเวลารับผิดชอบโดยตัวดำเนินการเลื่อนเวลา ซึ่งมองคร่าว ๆ ได้ว่าเป็นเมทริกซ์ unitary U = exp(-iHt)
    ในวิดีโอบอกว่าการทำนายโทเคนถัดไปถูกกำหนดโดยการคำนวณเวกเตอร์ embedding ที่รับรู้บริบทถัดไปจากเวกเตอร์ embedding ที่รับรู้บริบทตัวสุดท้ายเท่านั้น จึงดูเหมือนผลลัพธ์จากการใช้ฟังก์ชันสถานะเชิงเส้นกับเวกเตอร์มิติสูง
    ให้ความรู้สึกคล้ายกับการสร้าง Hamiltonian ของทั้งระบบแบบออฟไลน์จากข้อมูลฝึก จากนั้นทำ reparameterization หน้าต่างบริบทซึ่งเป็นระบบย่อยเฉพาะ ไปยัง basis ที่เข้ากับ Hamiltonian นั้น ใช้การเลื่อนเวลาไปหนึ่งขั้น แล้วแปลงกลับมาเป็น basis เดิม
    แต่สำหรับคนที่ทำวิจัยด้านหนึ่งมานาน ทุกปัญหาก็มักดูเหมือนตะปูที่พอดีกับค้อนของสาขานั้น เลยสงสัยว่าคนอื่นก็มองเห็นความคล้ายนี้ไหม หรือมันฝืนเกินไป

    • ผมคิดว่าอุปมานี้ไม่ค่อยตรงนัก ต่อให้ลืม ขั้นตอนเชิงไม่เชิงเส้น ก่อนหน้าทั้งหมดไป สิ่งที่เหลือก็เป็นแค่ระบบพลวัตเชิงเส้น และไม่มีคุณสมบัติสำคัญของกลศาสตร์ควอนตัมอย่าง ความเป็นจำนวนเชิงซ้อน หรือคุณสมบัติ unitary
    • รู้สึกเหมือนกำลังอธิบาย state machine มากกว่า การเข้ารหัสสถานะเป็นเวกเตอร์แล้วใช้เมทริกซ์ดำเนินขั้นต่อไป น่าจะเป็นรายละเอียดการใช้งานมากกว่า
    • ช่วงหลังผมก็คิดเรื่องนี้อยู่บ้าง ถ้าเวลาไม่ต่อเนื่อง อาจเป็นไปได้ไหมที่จะจำลองการเปลี่ยนแปลงตามเวลาของเอกภพด้วยการนำตัวดำเนินการบางตัวไปใช้ซ้ำ ๆ กับสถานะควอนตัมของเอกภพ
      ถ้าการใช้ตัวดำเนินการหนึ่งครั้งทำให้สถานะของเอกภพเดินหน้าไปหนึ่งช่วงเวลา Planck ก็สงสัยว่าเราจะสังเกตเห็นความแตกต่างระหว่างเอกภพแบบนั้นกับเอกภพที่เวลาต่อเนื่องได้หรือไม่
    • เมื่อก่อนเคยมีนักศึกษาฝึกงานปริญญาเอกสาขาคณิตศาสตร์คนหนึ่ง เขาบอกว่าพีชคณิตเชิงเส้นมิติสูงถือเป็นสาขาที่ล้ำมากแล้วแม้เทียบกับมาตรฐานยุค 1900 และยังมีพื้นที่ให้ค้นพบใหม่อีกมากในวิทยาการคอมพิวเตอร์
      เพิ่งนึกถึงความเชื่อมโยงกับสิ่งที่เกิดขึ้นในฟิสิกส์ยุคนั้นได้ตอนนี้เอง
    • สุดท้ายแล้วนี่หมายความว่าโมเดลคอมพิวเตอร์ที่ซับซ้อนที่สุดที่เราสร้างขึ้น กำลังเริ่มเข้าใกล้อัลกอริทึมที่กำหนดเอกภพที่เราอาศัยอยู่หรือเปล่า พูดอีกอย่างคือ simulation กำลังเผยโฉมออกมาอีกครั้งหรือไม่

  • วิดีโอ YouTube ของ CodeEmporium ตามได้ง่ายกว่า: https://www.youtube.com/watch?v=Nw_PJdmydZY
    Transformer อธิบายด้วยอุปมาได้ยาก และจริง ๆ ก็ยังไม่มีคำอธิบายดี ๆ ว่าทำไมมันถึงทำงานได้ ดังนั้นอาจจะดีกว่าที่จะแสดงกลไกให้เห็นเฉย ๆ แล้วปล่อยให้ผู้ชมตีความเอง
    นอกจากนี้ dot product อธิบายว่าเป็นการฉายเวกเตอร์เข้าหากันจะง่ายกว่า

    • คำอธิบายก็คือ โครงข่ายประสาทเป็นอัลกอริทึมการฟิตเชิงสถิติที่เรียนรู้ การแจกแจงความน่าจะเป็นแบบมีเงื่อนไข P(next_word|previous_words) น้ำหนักคือโมเดลของการแจกแจงนั้น และ LLM ใกล้เคียงกับ นวัตกรรมฮาร์ดแวร์ ที่ทำให้ GPU คำนวณสิ่งนี้ในสเกลใหญ่จากข้อมูลระดับเทราไบต์ได้
      เหตุผลที่หลัง “the cat sat on the ...” มีคำว่า “mat” ตามมา ก็เพราะเป็นคำที่ปรากฏบ่อยที่สุดในชุดข้อมูล และโครงข่ายประสาทก็เป็นโมเดลของความถี่แบบนั้น
      เหตุผลที่มันดูเหมือนรู้จัก “London in UK” แต่ไม่รู้จัก “London in France” ก็เพราะในชุดข้อมูล “UK” ปรากฏบ่อยกว่ามาก
      ตัวอัลกอริทึมเองไม่ได้ทำอะไรที่น่าสนใจเป็นพิเศษ นอกเหนือจากการจัดรูปการคำนวณให้เข้ากับฮาร์ดแวร์ คุณค่ามาจากโครงสร้างความน่าจะเป็นแบบมีเงื่อนไขในข้อมูล และโครงสร้างนั้นเป็นผลจากการที่ผู้คนจัดเรียงคำอย่างมีประโยชน์เพื่อส่งต่อข้อมูลให้กัน
    • ในมุมของนักวิทยาการคอมพิวเตอร์ การตีความว่าเป็น hash table ที่ดิฟเฟอเรนเชียตได้ นั้นเข้าท่ามาก บทความ AIAYN ก็ใช้ชื่อ query/key/value และสื่อไปทางนั้น แต่ไม่ได้พูดคำว่า “hash table” อย่างชัดเจน บางทีอาจมีบทความอื่นเป็นผู้แนะนำไว้ก็ได้
    • ความเข้าใจส่วนตัวเกี่ยวกับ attention คือ เอาต์พุตของ Transformer เป็นลำดับของเวกเตอร์โทเคนใหม่ ๆ และเวกเตอร์โทเคนเอาต์พุตแต่ละตัวมี ข้อมูลบริบท ของเวกเตอร์โทเคนอินพุตรอบ ๆ อยู่
      รู้ว่าเป็นคำอธิบายที่ไม่สมบูรณ์ แต่ก็คิดว่าดีกว่าไม่มีอะไรเลย

  • มีภาพแสดงผลที่น่าเชื่อถือว่า LLM ทำงานอย่างไรเมื่อจัดการคำของ่าย ๆ: https://bbycroft.net/llm
    ช่วยเสริมคำอธิบายละเอียดของ 3blue1brown ได้ดี

    • พอลองทำภาพให้เห็นแบบนี้ ก็รู้สึกได้ว่า ขนาดของ GPT-3 ใหญ่เกินจริงแค่ไหน นึกไม่ออกเลยว่า GPT-4 จะดูเป็นอย่างไรจากตรงนี้

  • เป็นวิดีโอที่ยอดเยี่ยม แสดงให้เห็นได้ดีว่าทำไม การคูณเมทริกซ์ Q*K ถึงเป็นคอขวด เพราะถ้าความยาวของลำดับ หรือหน้าต่างบริบทคือ S ก็ต้องเก็บเมทริกซ์ขนาด SxS ซึ่งเป็นผลลัพธ์ของ query ทุกตัวกับ key ทุกตัวไว้ในหน่วยความจำ
    ไอเดียค่อนข้างใหม่ในการปรับปรุงคอขวดนี้คือ Ring Attention และบทความนี้อธิบายได้ดี: https://learnandburn.ai/p/how-to-build-a-10m-token-context
    บทความดังกล่าวผมเป็นคนแก้ไข

    • ถ้าใช้ Flash Attention ก็ไม่จำเป็นต้องสร้างเมทริกซ์ (S, S) เลย เพราะสูตรอยู่ในรูป softmax(Q @ K^T / sqrt(d)) @ V จึงสร้างเอาต์พุตสุดท้ายเป็น tile ได้
      ใน Unsloth นั้น Flash Attention ทำให้การใช้หน่วยความจำเพิ่มขึ้นแบบเชิงเส้น ไม่ใช่กำลังสอง, การ fine-tuning เร็วขึ้น 2 เท่า, ใช้ VRAM ลดลง 80% และ inference ก็เร็วขึ้น 2 เท่าเช่นกัน อย่างไรก็ตามปริมาณการคำนวณยังเป็น O(N^2) อยู่
      สำหรับบริบทยาว ๆ รุ่นล่าสุดของ Unsloth ใส่บริบทได้ยาวกว่า HF+FA2 ถึง 4 เท่า ด้วย overhead เพิ่มเพียง +1.9% ทำให้รองรับ บริบท 228K บน H100 ได้
    • ในวิดีโอก็ไล่ชื่อ Ring Attention และเทคนิคอื่น ๆ หลายอย่างไว้เหมือนกัน แต่บอกว่าอยู่นอกขอบเขตของวิดีโอนี้: https://youtu.be/eMlx5fFNoYc?t=784

  • บทความก่อนหน้า “But what is a GPT?” ก็ดีมากเช่นกัน: https://www.3blue1brown.com/lessons/gpt

  • วิดีโอนี้ทำให้ผมเข้าใจว่า กลไก Attention ไม่ได้เป็นฟังก์ชันเฉพาะอย่างใดอย่างหนึ่ง แต่ใกล้เคียงกับฟังก์ชันเมตาประเภทหนึ่งมากกว่า
    ถ้าผมเข้าใจถูก Attention + น้ำหนักที่เรียนรู้มา ทำให้ Transformer เรียนรู้ฟังก์ชันที่ค่อนข้างเป็นไปตามอำเภอใจได้ในระดับหนึ่ง และในฟังก์ชันนั้นก็มีกลไกการจับคู่อย่าง scaled dot-product รวมอยู่ด้วย

    • ใช่ พลังของ Attention อยู่ที่การสำรวจพื้นที่ของฟังก์ชัน และนึกหาฟังก์ชันที่ดีที่สุดภายใต้เงื่อนไขจำกัด
      ดังนั้นผมคิดว่า linear attention คงยากมากที่จะเข้าใกล้ความสามารถของ Attention มาตรฐานได้ เพราะ พจน์กำลังสอง ที่สำรวจคู่ input-output ทุกคู่เป็นคุณสมบัติที่ขาดไม่ได้

  • เหตุผลใหญ่ที่วิดีโอนี้เข้าใจง่ายคือ แอนิเมชัน วิธีที่มันขยาย·หดตัวและคลี่ออกให้ตรงกับจังหวะการพูดทำออกมาได้ดีมาก

    • อันนั้นเป็นส่วนที่เขาทำได้ดีกว่าคนส่วนใหญ่จริง ๆ เขายังมีไลบรารีแอนิเมชันแบบกำหนดเองที่สร้างขึ้นเองสำหรับแอนิเมชันคณิตศาสตร์ด้วย: https://github.com/3b1b/manim

  • ผมทำงานในสาขาที่เกี่ยวข้องใกล้ชิด และวิดีโอนี้ถูกใส่เข้าไปใน เอกสาร onboarding ของทีมเราทันที
    อีกจุดสำคัญคือโค้ดสำหรับการทำ visualization จำนวนมากถูกอัปไว้บน GitHub: https://github.com/3b1b/videos/tree/master/_2024/transformers

    • น่าสนใจนะ อยากรู้ว่าในเอกสาร onboarding นั้นมีอะไรอีกบ้าง

  • ในที่สุดก็เข้าใจแล้ว ไม่รู้เหมือนกันว่าวิดีโออื่น ๆ ทำไมถึงทำให้สับสนขนาดนั้น

    • ตัวหัวข้อนี้มันสับสนอยู่แล้ว และ 3b1b ก็เก่งขนาดนั้นจริง ๆ
    • จากประสบการณ์ ยกเว้นกรณีหายากมาก ๆ แบบ Feynmann นักวิจัยมักเป็นคนที่อธิบายงานของตัวเองให้คนอื่นเข้าใจอย่างชัดเจนได้แย่ที่สุด
      เลยทำให้คิดว่าความสามารถด้านการสอนกับความสามารถด้านการวิจัยโดยทั่วไปอาจเป็นทักษะที่แทบจะไม่คาบเกี่ยวกัน
    • ในฐานะคนที่อยากทำวิดีโอหรือคอนเทนต์เพื่อการศึกษาให้ดีขึ้น เลยสงสัยว่าเมื่อเทียบกับ 3b1b แล้ว วิดีโออื่น ๆ ทำได้แย่กว่าตรงไหนบ้าง
    • Grant มีพรสวรรค์ในการอธิบายเรื่องซับซ้อนให้ชัดเจนมาก ช่องของเขาได้รับความนิยมก็มีเหตุผลอยู่
    • ไม่แน่ใจว่านี่เป็นคำถามเชิงวาทศิลป์หรือเปล่า แต่เป็นคำถามที่น่าสนใจ ผมคิดว่ามีอย่างน้อยสามเหตุผลที่คนส่วนใหญ่สับสนกับ Transformer
      ข้อแรก ศัพท์มาตรฐานไม่ค่อยดี “attention” ยังพอมีสัญชาตญาณให้เข้าใจได้แบบเฉียด ๆ แต่ “self-attention” แย่กว่า และ “key” กับ “value” ก็ไม่ต้องพูดถึง
      ข้อสอง เปเปอร์หลัก ๆ อย่าง Attention is All You Need, เปเปอร์ BERT ฯลฯ เขียนอธิบายได้ไม่ดี ไม่ได้จะลดทอนผลงานนะ แต่เปเปอร์ที่ทรงอิทธิพลและมีความก้าวหน้าครั้งใหญ่ก็อธิบายได้ไม่ดีได้ และผมคิดว่ากรณีนี้ก็เป็นแบบนั้นจริง ๆ
      ข้อสาม โดยรวมแล้วสถาปัตยกรรมเหล่านี้ถูกค้นพบด้วยวิธีลองโยนสารพัดอย่างเข้าไปแล้วดูว่าอะไรเข้ากันได้ดี ไม่ได้มีขั้นตอนคิดเชิงลึกก่อนว่าทำไมโครงสร้างแบบนี้น่าจะทำงานได้ดีแล้วค่อยทดลองยืนยัน แต่เป็นเชิงประจักษ์ตั้งแต่ต้นจนจบ
      ดังนั้นเราจึงยังไม่เข้าใจอย่างสมบูรณ์ว่าทำไมมันถึงทำงานได้ดีขนาดนี้ คำอธิบายทั้งหมดจึงค่อนข้างเป็นการหาเหตุผลย้อนหลัง และช่วงหลังยังมีงานที่บอกเป็นนัยว่า ถ้าปรับแต่งมากพอ โครงสร้างอื่น ๆ ก็อาจทำงานได้ดีใกล้เคียงกัน การอธิบายสิ่งที่เราเองยังไม่เข้าใจอย่างสมบูรณ์นั้นเป็นเรื่องยาก

  • อยากรู้ว่ามีแหล่งอ้างอิงที่อธิบายว่าสถาปัตยกรรมปัจจุบันวิวัฒนาการมาอย่างไรไหม อยากเห็นเส้นทางจากไอเดียแกนกลางที่เรียบง่ายมาก ๆ ไปจนถึงเปเปอร์ “all you need” อันโด่งดัง
    ไม่อย่างนั้นอุปกรณ์หลายอย่างดูเหมือนโผล่มาอย่างกะทันหัน มีการคำนวณเยอะ แต่มีสัญชาตญาณน้อย
    Jeremy Howard เคยบอกบน Twitter ว่าเขาเห็นไอเดียนี้หลายเวอร์ชันมาหลายครั้ง ซึ่งฟังดูเหมือนเป็นไอเดียที่เป็นธรรมชาติ ถ้าได้เห็นตัวอย่างว่าไอเดียนี้ปรากฏขึ้นที่อื่นอย่างไร ก็น่าจะช่วยสร้างสัญชาตญาณได้

    • คร่าว ๆ เป็นลำดับแบบนี้ แนวทาง seq-2-seq ช่วงแรกใช้ LSTM โดยตัวหนึ่งเข้ารหัสลำดับอินพุต และอีกตัวหนึ่งถอดรหัสลำดับเอาต์พุต แค่การที่วิธีเข้ารหัสประโยคความยาวแปรผันให้เป็นเวกเตอร์ขนาดคงที่ แล้วถอดรหัสกลับเป็นอีกลำดับที่มักมีความยาวต่างกันนั้นทำงานได้ ก็ถือว่าน่าทึ่งแล้ว
      แนวทาง RNN/LSTM นี้มีจุดอ่อนคือ representation ขนาดคงที่ และความยากในการตัดสินใจว่าควรใช้ส่วนใดของลำดับอินพุตเมื่อต้องสร้างส่วนหนึ่ง ๆ ของเอาต์พุต Bahdanau และคณะจัดการปัญหานี้ด้วยโครงสร้างที่รวมกลไก Attention เข้ากับ encoder-decoder RNN ทำให้มองเห็นสถานะในอดีตทั้งหมดของ RNN ไม่ใช่แค่สถานะสุดท้าย
      RNN ฝึกได้ไม่มีประสิทธิภาพ Jakob Uszkoreit จึงต้องการหาวิธีใช้ประโยชน์จากฮาร์ดแวร์ขนานขนาดใหญ่ได้ดีขึ้น และสังเกตว่าภาษาไม่ได้เป็นเพียงลำดับต่อเนื่อง แต่ยังมีลำดับชั้นด้วย เขาเสนอ layer structure ที่ประมวลผลโทเค็นของลำดับย่อยแบบขนานในแต่ละชั้น ขณะเดียวกันยังคง Attention แบบ Bahdanau ไว้ เพื่อให้โทเค็นอ้างอิงถึงกันผ่าน self-attention ในการทำนายชั้นถัดไป
      อิมพลีเมนต์ช่วงแรกทำงานได้ แต่ไม่ได้ดีกว่าวิธีอื่นในเวลานั้นอย่าง convolution และต่อมา Noam Shazeer ก็พัฒนาไอเดียนั้นต่อจนได้โครงสร้างที่ทำงานได้ดีกว่ามาก ผ่านการทดลองตัดองค์ประกอบที่ไม่จำเป็นออก จนกลายเป็น Transformer ดั้งเดิม เท่าที่รู้ผมไม่แน่ใจว่าใครเป็นคนคิดรูปแบบ Attention แบบอิง key ในโครงสร้างสุดท้าย
      Transformer ดั้งเดิมในเปเปอร์ Attention is All You Need มี encoder และ decoder แยกกัน ตามแนวทางที่อิง RNN มาก่อน และถูกใช้ในโมเดลยุคแรกอย่าง BERT ของ Google ด้วย แต่สำหรับ language model สิ่งนี้ไม่จำเป็น ดังนั้น GPT ของ OpenAI จึงใช้เฉพาะส่วน decoder และตอนนี้โดยรวมทุกคนก็ใช้แนวทางนี้กัน ใน Transformer แบบ decoder-only ประโยคอินพุตจะเข้าสู่ชั้นล่างสุด จากนั้นถูกแปลงทีละขั้นเมื่อผ่านแต่ละชั้น แล้วออกมาจากด้านบน ที่ท้ายลำดับอินพุตจะมีโทเค็นสิ้นสุดต่อท้าย และมันจะถูกแปลงเป็นโทเค็นถัดไปของลำดับเอาต์พุต กล่าวคือโทเค็นสุดท้าย
    • Karpathy สรุป ประวัติของสถาปัตยกรรม Transformer ไว้ดีในเลกเชอร์ Stanford: https://youtu.be/XfpMkf4rD6E?si=MDICNzZ_Mq9uzRo9&t=618