# From GPT-2 to Kimi K3: 22580x Is Not Just Scale

By [nanobro](https://blog.nanobro.co) · 2026-07-28

ai, kimi k3, llm, transformer

---

![ภาพสรุปวิวัฒนาการจาก GPT-2 สู่ Kimi K3](https://storage.googleapis.com/papyrus_images/a1805c37e4a6f62c5879f72fb11255c3b57e3f03acdf9f07cd3126237bffebfa.jpg)

ภาพสรุปวิวัฒนาการจาก GPT-2 สู่ Kimi K3

จาก GPT-2 สู่ Kimi K3: โมเดลใหญ่ขึ้น 22,580 เท่า แต่เรื่องสำคัญไม่ใช่แค่ขนาด
============================================================================

> บทความนี้เรียบเรียงและอธิบายเป็นภาษาไทยจากบทความต้นฉบับ **“22580: From GPT2 to Kimi3, Explained”** โดย **Ali (@waterloo\_intern)** นักวิจัยด้าน Machine Learning และวิศวกรที่ Baseten  
> อ่านต้นฉบับ: [https://x.com/waterloo\_intern/status/2081762065392541951](https://x.com/waterloo_intern/status/2081762065392541951)

หนึ่งโมเดล Kimi K3 มีพารามิเตอร์ 2.8 ล้านล้านตัว หรือมากพอๆ กับการนำ GPT-2 ขนาด 124 ล้านพารามิเตอร์มารวมกันประมาณ 22,580 โมเดล

ตัวเลขนี้สะท้อนว่าภายในเวลาเจ็ดปี AI ขยายขนาดไปไกลแค่ไหน แต่ถ้ามอง Kimi K3 ว่าเป็นเพียง GPT-2 ที่ใหญ่ขึ้น เราจะพลาดความเปลี่ยนแปลงที่สำคัญกว่า นั่นคือวิธีที่โมเดลเก็บ อัปเดต ลืม และเรียกคืนข้อมูล

เส้นทางจาก GPT-2 ไปสู่ Kimi K3 จึงไม่ใช่เรื่องของการเติมพารามิเตอร์อย่างเดียว แต่เป็นการแก้คอขวดของหน่วยความจำทีละจุด

จุดเริ่มต้น: GPT-2 และต้นทุนของ Attention
-----------------------------------------

GPT-2 เป็นโมเดลแบบ decoder-only Transformer แต่ละชั้นประกอบด้วย attention และ MLP พร้อม residual connection

ตอนสร้างข้อความ โมเดลต้องใช้ข้อมูลจากโทเคนก่อนหน้าเพื่อทำนายโทเคนถัดไป หากคำนวณใหม่ทั้งหมดทุกครั้ง งานจำนวนมากจะถูกทำซ้ำ จึงเกิดเทคนิค KV cache ที่เก็บเวกเตอร์ Key และ Value ของโทเคนก่อนหน้าไว้

KV cache ช่วยให้การสร้างข้อความเร็วขึ้นมาก แต่มีข้อจำกัดสำคัญ ขนาดของมันโตตามความยาวบริบท เมื่อบริบทยาวขึ้น โมเดลต้องอ่านข้อมูลจากหน่วยความจำมากขึ้น จน memory bandwidth กลายเป็นคอขวด

กล่าวง่ายๆ คือ Transformer จำอดีตได้ดี เพราะเก็บรายละเอียดของอดีตไว้เยอะ แต่ยิ่งจำมากก็ยิ่งกินหน่วยความจำ

Linear Attention: บีบอดีตให้เหลือ state ขนาดคงที่
-------------------------------------------------

Softmax attention แบบดั้งเดิมเปรียบเทียบ Query กับ Key จำนวนมากโดยตรง ส่วน Linear Attention เปลี่ยนลำดับการคำนวณ เพื่อรวมข้อมูลจาก Key และ Value เข้าไปใน state ขนาดคงที่แบบ D×D

ข้อดีคือ state ไม่ต้องโตตามจำนวนโทเคน การ decode จึงไม่ต้องลาก KV cache ที่ใหญ่ขึ้นเรื่อยๆ ไปตลอดทาง

แต่การบีบประวัติทั้งหมดลงใน state ขนาดจำกัดย่อมมีราคา ข้อมูลใหม่ถูกบวกทับลงพื้นที่เดิม เมื่อบริบทยาวเกินความจุ ความสัมพันธ์ระหว่างข้อมูลจะเริ่มรบกวนกัน โมเดลอาจจำได้ว่ามีบางอย่างอยู่ แต่เรียกคืนรายละเอียดได้ไม่แม่นเหมือน attention แบบเต็ม

นี่คือโจทย์หลักของสถาปัตยกรรมรุ่นถัดมา: ถ้าหน่วยความจำมีขนาดจำกัด โมเดลต้องรู้ว่าอะไรควรเขียน อะไรควรแทนที่ และอะไรควรถูกลืม

DeltaNet: ไม่ใช่แค่เขียนเพิ่ม แต่แก้ข้อมูลเดิมได้
-------------------------------------------------

DeltaNet ใช้แนวคิดคล้าย fast-weight memory ก่อนเขียนข้อมูลใหม่ โมเดลจะอ่านสิ่งที่มีอยู่ในตำแหน่งความหมายนั้นก่อน จากนั้นคำนวณส่วนต่างระหว่างข้อมูลเดิมกับข้อมูลใหม่ แล้วเขียนเฉพาะส่วนต่างกลับเข้าไป

แทนที่จะทำเพียง:

`state ใหม่ = state เดิม + ข้อมูลใหม่`

DeltaNet ทำสิ่งที่ใกล้เคียงกับ:

`state ใหม่ = state เดิม + สิ่งที่ต้องแก้ไขจริงๆ`

กลไกนี้ช่วยลดการชนกันของข้อมูลและทำให้โมเดลแทนที่ความสัมพันธ์เดิมได้แม่นขึ้น

ปัญหาต่อมาคือการคำนวณแบบลำดับทีละโทเคนไม่เหมาะกับ GPU นักวิจัยจึงจัดการคำนวณเป็น chunk และแปลงสมการใหม่ เพื่อให้หลายตำแหน่งทำงานพร้อมกันบนฮาร์ดแวร์แบบ matrix multiplication ได้ดีขึ้น

นี่เป็นตัวอย่างสำคัญว่า FLOPs น้อยที่สุดไม่ได้แปลว่าเร็วที่สุดเสมอ งานที่มากกว่าเล็กน้อยแต่ออกแบบให้เข้ากับ Tensor Core อาจเสร็จเร็วกว่าในโลกจริง

Gated DeltaNet: โมเดลต้องมีสิทธิ์ลืม
------------------------------------

แม้ DeltaNet จะอัปเดตข้อมูลเดิมได้ดีขึ้น แต่มันยังลืมได้เฉพาะจุดที่มีข้อมูลใหม่มาแทน หากบริบทเปลี่ยนฉับพลัน โมเดลไม่มีวิธีเคลียร์ความทรงจำเก่าหลายส่วนอย่างมีประสิทธิภาพ

Gated DeltaNet จึงเพิ่มค่า decay ที่เรียนรู้จากข้อมูลเข้ามา ค่านี้ควบคุมว่า state เดิมควรถูกเก็บไว้มากแค่ไหนก่อนเพิ่มข้อมูลใหม่

เมื่อโมเดลเห็นข้อมูลต่อเนื่อง มันอาจรักษาความทรงจำเดิมไว้ แต่เมื่อหัวข้อหรือบริบทเปลี่ยน มันสามารถลดน้ำหนักข้อมูลเก่าเพื่อเปิดพื้นที่ให้สิ่งใหม่

จุดเปลี่ยนสำคัญคือหน่วยความจำไม่ได้เป็นเพียงพื้นที่รับข้อมูลอีกต่อไป แต่กลายเป็นระบบที่มีนโยบายการจัดการความจำของตัวเอง

Kimi Linear และ KDA: ลืมแบบละเอียดระดับช่องสัญญาณ
-------------------------------------------------

Kimi Linear พัฒนาแนวคิดนี้ต่อด้วย Kimi Delta Attention หรือ KDA

แทนที่จะใช้ค่า decay เพียงค่าเดียวควบคุม state ทั้งก้อน KDA เรียนรู้ค่า decay แยกในแต่ละ channel ทำให้โมเดลรักษาข้อมูลบางประเภทไว้ได้นาน ขณะเดียวกันก็ลืมข้อมูลอีกประเภทได้เร็วกว่า

งาน Kimi Linear รายงานว่า ภายใต้การเปรียบเทียบที่ควบคุมเงื่อนไข สถาปัตยกรรมนี้ทำคุณภาพได้ดีกว่า full attention และมี decode throughput สูงขึ้นได้ถึง 6 เท่า

ใจความสำคัญไม่ใช่การเพิ่ม capacity แบบสุ่ม แต่เป็นการเพิ่มความสามารถในตำแหน่งที่มีหน้าที่ชัดเจน ในกรณีนี้คือเพิ่มความละเอียดให้ระบบควบคุมการเสื่อมของหน่วยความจำ

Kimi K3: สถาปัตยกรรมแบบผสม แทนการเลือกวิธีเดียว
-----------------------------------------------

Kimi K3 ไม่ได้ทิ้ง softmax attention ทั้งหมด แต่ใช้สถาปัตยกรรมแบบ hybrid

แกนหลักประกอบด้วย 23 macrocycles โดยแต่ละรอบมี 4 ชั้น:

*   3 ชั้นใช้ Kimi Delta Attention เพื่อรักษา state ขนาดคงที่และ decode อย่างมีประสิทธิภาพ
    
*   ชั้นที่ 4 ใช้ Multi-head Latent Attention หรือ MLA เพื่อกลับไปเรียกข้อมูลจากบริบทระดับโทเคน
    
*   ชั้นแรกใช้ dense feed-forward network
    
*   ชั้นที่เหลือใช้ latent Mixture-of-Experts หรือ MoE เพื่อเพิ่มความจุโดยไม่ต้องเรียกผู้เชี่ยวชาญทุกตัวพร้อมกัน
    

การออกแบบนี้ยอมรับตรงๆ ว่าไม่มีหน่วยความจำชนิดเดียวที่เก่งทุกอย่าง

KDA เร็วและใช้ state คงที่ แต่ต้องทิ้งข้อมูลบางส่วน MLA จึงทำหน้าที่เป็นจุดเรียกคืนรายละเอียดจากบริบท ส่วน MoE เพิ่ม capacity แบบ sparse โดยใช้พลังประมวลผลกับเส้นทางที่เกี่ยวข้องเท่านั้น

AttnRes: เลือกอ่านจากความลึกของโมเดล
------------------------------------

ใน Transformer ทั่วไป residual stream จะสะสมผลลัพธ์จากหลายชั้นเข้าด้วยกัน เมื่อโมเดลลึกมาก ข้อมูลที่สำคัญจากชั้นก่อนหน้าอาจถูกเจือจาง และแต่ละชั้นไม่สามารถเลือกได้ว่าควรให้น้ำหนักกับ representation ใดมากเป็นพิเศษ

Attention Residuals หรือ AttnRes แก้ปัญหานี้ด้วยการให้แต่ละชั้นเลือกอ่าน representation จากชั้นก่อนหน้าด้วยกลไกคล้าย attention

แทนที่จะรับผลรวมของอดีตทุกชั้นอย่างเท่าเทียม โมเดลสามารถถามว่า ณ จุดนี้ representation จากความลึกระดับใดมีประโยชน์ที่สุด แล้วผสมข้อมูลเหล่านั้นตามน้ำหนักที่เรียนรู้

Kimi K3 ใช้ AttnRes แบบ blockwise ทุก 12 ชั้น เพื่อลดต้นทุน โดยบทความต้นฉบับระบุว่าเพิ่ม latency ในการ inference ราว 2% แต่ช่วยลด residual dilution และทำให้การใช้ compute มีประสิทธิภาพขึ้น

MLA กับ AttnRes จึงแก้ข้อจำกัดเดียวกันจากคนละทิศทาง:

*   MLA เรียกคืนข้อมูลจากมิติของลำดับโทเคน
    
*   AttnRes เรียกคืนข้อมูลจากมิติความลึกของเครือข่าย
    

บทเรียนจริงจาก GPT-2 ถึง Kimi K3
--------------------------------

Kimi K3 ใหญ่กว่า GPT-2 ประมาณ 22,580 เท่าในแง่จำนวนพารามิเตอร์ แต่ความก้าวหน้าที่น่าสนใจกว่าคือวิวัฒนาการของระบบความจำ

*   GPT-2 เก็บอดีตไว้ใน KV cache ที่โตตามบริบท
    
*   Linear Attention บีบอดีตเป็น state ขนาดคงที่
    
*   DeltaNet เรียนรู้การแก้ข้อมูลเดิมแทนการบวกทับอย่างเดียว
    
*   Gated DeltaNet เพิ่มความสามารถในการลืม
    
*   KDA ควบคุมการลืมอย่างละเอียดในแต่ละ channel
    
*   MLA ช่วยเรียกคืนรายละเอียดระดับโทเคน
    
*   MoE เพิ่มความจุแบบเลือกใช้
    
*   AttnRes เลือกเรียก representation จากชั้นก่อนหน้า
    

ดังนั้นหัวใจของ Kimi K3 ไม่ใช่คำว่า “ใหญ่กว่า” แต่คือการใช้ capacity แต่ละส่วนอย่างมีหน้าที่

เมื่อหน่วยความจำมีขนาดจำกัด โมเดลต้องมี eviction policy ต้องเลือกได้ว่าอะไรควรอยู่ อะไรควรถูกเขียนทับ และเมื่อใดควรกลับไปค้นข้อมูลต้นฉบับอีกครั้ง

นี่อาจเป็นทิศทางสำคัญของโมเดลยุคต่อไป ไม่ใช่เพียงการขยายจำนวนพารามิเตอร์ แต่เป็นการออกแบบระบบความจำที่รู้จักเลือก

* * *

**เครดิตและแหล่งที่มา**

บทความนี้เรียบเรียงจากงานอธิบายต้นฉบับของ **Ali (@waterloo\_intern)** ซึ่งลงรายละเอียดเชิงคณิตศาสตร์ โค้ด และภาพประกอบไว้ครบถ้วนกว่าบทความฉบับนี้ ขอขอบคุณผู้เขียนต้นฉบับสำหรับการรวบรวมและอธิบายพัฒนาการทางสถาปัตยกรรมอย่างเป็นระบบ

*   บทความต้นฉบับ: [https://x.com/waterloo\_intern/status/2081762065392541951](https://x.com/waterloo_intern/status/2081762065392541951)
    
*   ผู้เขียน: [https://x.com/waterloo\_intern](https://x.com/waterloo_intern)
    
*   GitHub: [https://github.com/AliesTaha](https://github.com/AliesTaha)

---

*Originally published on [nanobro](https://blog.nanobro.co/from-gpt-2-to-kimi-k3-22580x-is-not-just-scale)*