Large language model architectures — สถาปัตยกรรมของโมเดลภาษาขนาดใหญ่

สถาปัตยกรรมของโมเดลภาษาขนาดใหญ่ (LLM) — คือหลักการและโครงสร้างพื้นฐานที่กำหนดวิธีการสร้าง การฝึก และการทำงานของโมเดลภาษาขนาดใหญ่ LLM สมัยใหม่ที่สามารถเข้าใจและสร้างภาษามนุษย์ได้นั้น เกือบทั้งหมดอิงบนสถาปัตยกรรม Transformer แต่รวมถึงการปรับปรุงและแนวทางต่าง ๆ มากมายที่มุ่งเพิ่มประสิทธิภาพ ความสามารถในการปรับขนาด และขีดความสามารถ

ตระกูลสถาปัตยกรรม LLM (transformer)

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

1. Encoder‑only (เฉพาะตัวเข้ารหัส)

โมเดลใช้เฉพาะกลุ่ม encoder และพิจารณาข้อความขาเข้าทั้งหมดในแบบสองทิศทาง การฝึกเบื้องต้นมักสร้างบน masked‑language modeling (MLM หรือการสร้างแบบจำลองภาษาด้วยการซ่อน) โดยซ่อน token บางส่วนแล้วให้โมเดลเรียนรู้การกู้คืนจากบริบทโดยรอบ ด้วยบริบทสองทิศทาง โมเดลเหล่านี้จึงเก่งในงานด้านความเข้าใจและการให้คะแนน ได้แก่ การจำแนกประเภท การระบุเอนทิตี การจัดอันดับเอกสาร และ extractive QA อย่างไรก็ตาม โมเดลเหล่านี้ไม่ได้ออกแบบมาสำหรับการสร้างข้อความแบบ autoregressive ตั้งแต่ต้น

นอกจากนี้ในทางปฏิบัติยังใช้วัตถุประสงค์การฝึกเบื้องต้นทางเลือกสำหรับตระกูล encoder‑only อีกด้วย ได้แก่ replaced token detection (RTD) ใน ELECTRA (โมเดล discriminator ตรวจจับ token ที่ถูกแทนที่) และ การเรียนรู้เชิงเปรียบเทียบ ของ bi-encoder สำหรับการค้นหาเชิงความหมาย/retriever (InfoNCE/softmax‑loss บนคู่ "คำถาม-เอกสาร" เช่นใน Dense Passage Retrieval) เมื่อใช้ใน RAG encoder‑only ทำหน้าที่เป็น bi‑encoder (เข้ารหัสคำถามและเอกสารแยกกันสำหรับการค้นหา ANN ที่รวดเร็ว) หรือเป็น cross‑encoder (เข้ารหัสคู่ร่วมกันเพื่อการจัดอันดับใหม่อย่างแม่นยำ)

ข้อดี:

• คุณภาพสูงในการทำความเข้าใจข้อความด้วยบริบทสองทิศทาง ได้แก่ การจำแนกประเภท NER การดึงข้อเท็จจริง การจัดอันดับใหม่ และ extractive QA
• การประมวลผลแบบขนานและปริมาณงานสูง: ผ่านเดียวโดยไม่มี auto‑regression เหมาะสำหรับการ batch การให้คะแนนขนาดใหญ่
• การผสานรวมกับการค้นหาและ RAG ได้อย่างเป็นธรรมชาติ: ในบทบาท bi‑encoder — การค้นหาเชิงความหมายที่รวดเร็ว; ในบทบาท cross‑encoder — การจัดอันดับใหม่อย่างแม่นยำ
• การปรับตัวที่มีประสิทธิภาพ: รูปแบบที่ค่อนข้างกะทัดรัด (≈100–300 ล้านพารามิเตอร์; BERT‑base ≈110 ล้าน) ให้คุณภาพสูงหลังจาก fine-tuning ตามเป้าหมาย
• Latency ที่มั่นคงไม่ขึ้นอยู่กับความยาวของคำตอบที่สร้าง (ไม่มีการถอดรหัสทีละขั้นตอน) เหมาะสำหรับการให้คะแนนแบบออฟไลน์ของชุดเอกสารขนาดใหญ่
• ความสามารถในการขยายหน้าต่างบริบทของ encoder ด้วยตำแหน่งสัมพัทธ์/เชิงหมุนและ/หรือ attention แบบกระจัดกระจายในพื้นที่ (เช่น Longformer/BigBird) ซึ่งมีประโยชน์สำหรับเอกสารยาว

ข้อเสีย:

• ไม่มีความสามารถในการสร้างข้อความในตัว: สำหรับบทสนทนาและคำตอบโดยละเอียดจำเป็นต้องมี decoder หรือโมดูลสร้างภายนอก
• ข้อจำกัดในสถานการณ์แบบโต้ตอบ: ไม่มีการสร้างทีละขั้นตอนพร้อมการรักษาสถานะ
• ความไม่สอดคล้องของวัตถุประสงค์การฝึกเบื้องต้นกับงานการสร้างแบบอิสระ: MLM สอดคล้องกับการสร้างได้น้อยกว่าเมื่อเทียบกับ causal modeling
• หน้าต่างบริบทที่จำกัดในอดีต (มักเป็น 512 token ในการกำหนดค่าพื้นฐานของตำแหน่งสัมบูรณ์) การขยายต้องใช้รูปแบบตำแหน่ง/attention พิเศษและ/หรือ fine-tuning
• สำหรับงาน retrieval จำเป็นต้องมี fine-tuning เชิงเปรียบเทียบแยกต่างหากของ bi‑encoder และ/หรือ cross‑encoder หากไม่มีสิ่งนี้ คุณภาพการค้นหา/การจัดอันดับใหม่มักจะต่ำกว่าโมเดลที่ฝึกมาโดยเฉพาะ

โมเดลตัวอย่าง: BERT และรูปแบบที่ได้รับการพัฒนา รวมถึง RoBERTa และ DeBERTa (รูปแบบ encoder‑only ขั้นสูง) สำหรับวัตถุประสงค์การฝึกทางเลือก — ELECTRA (RTD)

2. Decoder‑only (เฉพาะตัวถอดรหัส)

ใช้เฉพาะกลุ่ม decoder ที่มี attention แบบ causal (ซ้ายไปขวา): โมเดลทำนาย token ถัดไปจาก prefix ที่กำหนดไว้แล้ว โหมดการฝึกนี้ — causal language modeling (CLM) — ทำให้โมเดลเหล่านี้เป็นตัวเลือกที่เป็นธรรมชาติสำหรับการสร้างข้อความ ได้แก่ บทสนทนา คำตอบโดยละเอียด ข้อความสร้างสรรค์ และโค้ดโปรแกรม ข้อแลกเปลี่ยนคือความล่าช้าที่เพิ่มขึ้นและขนาด KV‑cache ที่ใหญ่ขึ้นเมื่อมี prompt ยาว ในทางปฏิบัติสำหรับ decoder‑only มีการใช้เทคนิควิศวกรรมอย่างแพร่หลาย ได้แก่ การลด KV‑cache ด้วย MQA และ GQA การเร่งการ inference ผ่าน speculative decoding และการเพิ่มประสิทธิภาพฝั่งเซิร์ฟเวอร์ (PagedAttention/vLLM, continuous batching, chunked prefill)

ข้อดี:

• การสร้างข้อความแบบธรรมชาติ (CLM): ความสามารถ zero‑shot และ few‑shot ที่แข็งแกร่ง ปรับขนาดได้ดี
• ความเอนกประสงค์: โมเดลเดียวแก้ปัญหาหลายอย่างด้วยคำสั่งและตัวอย่างใน prompt รวมเข้ากับ RAG และการเรียกใช้เครื่องมือ (tool use) ได้อย่างเป็นธรรมชาติ
• ระบบนิเวศที่เติบโตเต็มที่: แนวปฏิบัติของ fine-tuning เชิงคำสั่งและการปรับพฤติกรรม (RLHF, DPO) มีการใช้งานทั้งแบบเปิดและเชิงพาณิชย์
• ชุดการเพิ่มประสิทธิภาพ inference ที่สมบูรณ์: MQA/GQA ลดขนาด KV‑cache และเพิ่มปริมาณงาน; speculative decoding เร่งการ inference โดยไม่เปลี่ยนการกระจาย; PagedAttention/vLLM พร้อม continuous batching และ chunked prefill เพิ่มการใช้งาน GPU แบบ end-to-end
• รองรับการสร้างโครงสร้างสำหรับรูปแบบคำตอบที่เข้มงวด (JSON/SQL/DSL) ซึ่งช่วยให้การผสานรวมกับระบบสารสนเทศและ API ง่ายขึ้น

ข้อเสีย:

• Latency การสร้างที่สูงขึ้น: การ inference แบบลำดับ; ต้นทุนของ token ใหม่เติบโตตามความยาวของบริบทที่ "อ่านไปแล้ว" (KV‑cache)
• ประสิทธิภาพน้อยกว่าในโปรไฟล์ "input ยาว – output สั้น" (การสรุป การแปล) เมื่อเทียบกับ encoder–decoder ที่เข้ารหัส input เพียงครั้งเดียว
• ข้อจำกัดของบริบททิศทางเดียว: ในงานด้านความเข้าใจบางครั้งด้อยกว่าโมเดลที่มีการแสดงผลสองทิศทาง (encoder‑only / encoder–decoder)
• หน่วยความจำสำหรับ KV‑cache อาจเป็น "คอขวด" เมื่อมี prompt ยาวและ batch ขนาดใหญ่
• การ quantize activation/KV (INT8/FP8) เร่ง inference แต่อาจลดคุณภาพในบริบทยาว/โค้ด จำเป็นต้องมีการตรวจสอบความถูกต้องอย่างละเอียด (โดยเฉพาะเมื่อมี SLA ที่เข้มงวด)

โมเดลตัวอย่าง: GPT‑3, GPT‑4 (รายละเอียดสถาปัตยกรรมและชุดข้อมูลไม่เปิดเผยต่อสาธารณะ), LLaMA และ Llama 3 (8B/70B, 2024)

3. Encoder–decoder (ตัวเข้ารหัส–ตัวถอดรหัส)

สถาปัตยกรรมนี้รวมส่วนประกอบทั้งสองไว้ด้วยกัน Encoder ทำงานในโหมดสองทิศทาง ส่วน decoder — แบบ causal Encoder วิเคราะห์ input ครั้งเดียวและสร้างการแทนค่า; decoder สร้าง output โดยอ้างอิงการแทนค่านั้นผ่าน cross‑attention แนวทางแยกส่วนนี้มีประโยชน์อย่างยิ่งในกรณีที่ต้องแปลง input ข้อความยาวให้เป็น output สั้น: การแปลด้วยเครื่อง การสรุป และการตอบคำถามโดยอิงเอกสาร แม้วิธีนี้ต้องการต้นทุนการคำนวณรวมที่สูงกว่า (สองกลุ่มและ cross‑attention) แต่ข้อได้เปรียบคือการสร้างที่ควบคุมได้บนพื้นฐานการวิเคราะห์ข้อความต้นฉบับอย่างสมบูรณ์ โดยการเข้ารหัสทำเพียงครั้งเดียวและนำมาใช้ซ้ำตลอดกระบวนการ inference

ข้อดี:

• การสร้างแบบมีเงื่อนไข: decoder ใช้ cross‑attention กับการแทนค่าของ input
• มีประสิทธิภาพในสถานการณ์ "input ยาว → output สั้น": input ถูกเข้ารหัสเพียงครั้งเดียว
• เหมาะสำหรับรูปแบบ "text‑to‑text" และการสร้าง output แบบควบคุม (prefix ของงาน คำสั่งพิเศษ)
• ความเสถียรและประสิทธิภาพเมื่อมีแหล่งที่มายาว: ในระยะถอดรหัส self‑attention ของ output เติบโต แต่ cross‑attention นำ key/value ที่คงที่จาก encoder มาใช้ซ้ำ (input ไม่ถูก "อ่านใหม่" ในทุกขั้นตอน)

ข้อเสีย:

• สองกลุ่มเพิ่มความต้องการหน่วยความจำและการคำนวณในระหว่างการฝึกและการใช้งาน
• สำหรับลำดับที่ยาวมาก latency รวมเทียบได้กับ decoder‑only; auto‑regression ยังคงเป็นคอขวด
• โมเดลแชทแบบเอนกประสงค์มีน้อยกว่าในกลุ่ม decoder‑only; มักใช้เป็น seq2seq engine คุณภาพสูงสำหรับงานเฉพาะ
• เมื่อ input ยาวมาก หน่วยความจำสำหรับ key/value ของ cross‑attention ในแต่ละเลเยอร์ของ decoder (ตลอดแหล่งที่มา) จะเพิ่มขึ้น ต้องวางแผนการให้บริการอย่างระมัดระวัง

โมเดลตัวอย่าง: T5 (รวมถึง T5 v1.1 และแนวปฏิบัติ fine-tuning เชิงคำสั่งใน FLAN‑T5) และ BART

Dense Transformer - Transformer แบบหนาแน่น

สถาปัตยกรรม LLM แบบคลาสสิกและแพร่หลายที่สุด: ในการประมวลผล token แต่ละตัวจะมีพารามิเตอร์ของโมเดลเกือบทั้งหมดเข้าร่วม ต่างจากแนวทาง sparse (เช่น Mixture‑of‑Experts) ตรงที่ไม่มีการเปิดใช้งาน subnetwork แบบเลือกสรร — แต่ละบล็อกทำงานสำหรับ token ทุกตัว

หลักการทำงานและสถาปัตยกรรม

โครงสร้างพื้นฐาน. โมเดลคือกลุ่มของบล็อก transformer N บล็อกที่มีรูปแบบเหมือนกัน แต่ละบล็อกประกอบด้วย:

1. Multi‑Head Self‑Attention (การใส่ใจตนเองหลายหัว). สำหรับ token แต่ละตัวจะคำนวณเวกเตอร์สามตัว: Q (query), K (key), V (value); attention ถูกกำหนดเป็น $\mathrm{softmax}\left(\frac{Q{K}^{o}p+M}{\sqrt{d_k}}\right)\cdot V$ โดยที่ $M$ คือ mask (causal และ/หรือ padding mask) ที่ยกเว้นตำแหน่งที่ไม่อนุญาต "หัว" attention หลายหัวพิจารณาด้านต่าง ๆ ของบริบทแบบขนาน (H หัว มักเป็น $d_{\mathrm{h}\mathrm{e}\mathrm{a}\mathrm{d}}=\frac{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}{H}$) จำนวนหัวเพิ่มขึ้นตามขนาดของโมเดล
2. Feed‑Forward Network (FFN หรือเครือข่ายไปข้างหน้าแบบเชื่อมต่อเต็มรูปแบบ). สองเลเยอร์เชิงเส้นที่มี nonlinearity ระหว่างกัน (มักเป็น GELU/SiLU; ในโมเดลสมัยใหม่บางรุ่น — SwiGLU) มิติตรงกลางมักเป็น $\approx 4d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$; เมื่อใช้ SwiGLU มักใช้ $\approx frac83d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ เพื่อรักษาจำนวนพารามิเตอร์ที่ใกล้เคียงกัน FFN มีพารามิเตอร์เป็นสัดส่วนที่มีนัยสำคัญ

ส่วนประกอบเพิ่มเติม. ใช้ residual connection และการ normalize เลเยอร์; ใน LLM สมัยใหม่มักใช้ Pre‑LN (การ normalize ก่อน subblock) — ซึ่งช่วยเพิ่มเสถียรภาพการฝึกที่ความลึกมาก นอกจาก LayerNorm แบบคลาสสิก ยังใช้ RMSNorm อย่างแพร่หลายมากขึ้น (ลดต้นทุนการคำนวณและทำงานได้ดีในโมเดลขนาดใหญ่) นอกจากนี้ในบางตระกูลยังใช้การ normalize ในพื้นที่ attention (เช่น การ normalize Q/K ก่อน softmax) การแสดงตำแหน่งอาจเป็นแบบสัมบูรณ์หรือสัมพัทธ์; สำหรับบริบทยาว RoPE ได้กลายเป็น de facto standard

ตัวอย่างโมเดลและขนาด

• BERT‑Large: 24 เลเยอร์, มิติ 1024, 16 หัว attention, ≈340 ล้านพารามิเตอร์
• GPT‑3 (175B): 96 เลเยอร์, มิติ 12288, 96 หัว attention, ≈175 พันล้านพารามิเตอร์
• LLaMA‑65B: 80 เลเยอร์, มิติ 8192, 64 หัว attention, ≈65 พันล้านพารามิเตอร์
• PaLM‑540B: 118 เลเยอร์, มิติประมาณ 18432, ≈540 พันล้านพารามิเตอร์

ข้อดี

• บล็อกที่สม่ำเสมอ โหมดการฝึกที่ศึกษาดีแล้ว และพฤติกรรมที่คาดเดาได้เมื่อปรับขนาด
• คุณภาพดีขึ้นตามกฎกำลังเมื่อพารามิเตอร์และข้อมูลเพิ่มขึ้น; โหมด compute‑optimal ต้องการการเพิ่มขนาดโมเดลและจำนวน token สำหรับการฝึกพร้อมกัน
• สถาปัตยกรรมเดียวกันหลัง fine-tuning ครอบคลุมงานหลากหลายโดยไม่ต้องเปลี่ยนแปลงระดับเลเยอร์

ข้อเสีย

• Self‑attention แบบเต็มรูปแบบมีความซับซ้อน quadratic ตามความยาวลำดับ ($O(n^2)$) ซึ่งจำกัดหน้าต่างบริบท
• การเปิดใช้งานพารามิเตอร์เต็มรูปแบบในขั้นตอนการสร้าง: ใน decoder ที่ไม่มี MoE ต้นทุนการ inference ต่อ token เพิ่มขึ้นตามสัดส่วนของจำนวนพารามิเตอร์โดยประมาณ
• คอขวดคือ bandwidth ของหน่วยความจำ (memory‑bound): การโหลด weight จาก HBM มักจำกัดความเร็ว inference

ข้อจำกัดของการปรับขนาดและบริบท

• หน่วยความจำสำหรับพารามิเตอร์เพิ่มขึ้นเชิงเส้นตามขนาดโมเดล; หน่วยความจำสำหรับการฝึกเพิ่มขึ้นเนื่องจาก gradient และสถานะ optimizer
• การกำหนดค่าพื้นฐานในอดีตมักจำกัดอยู่ที่ 2–4 พัน token รูปแบบตำแหน่งสมัยใหม่ (RoPE) และเทคนิคการขยาย (Position Interpolation, YaRN และอื่น ๆ) ช่วยให้ขยายหน้าต่างได้อีกหลายเท่า แต่แลกกับภาระการคำนวณ/หน่วยความจำเพิ่มเติม

การเพิ่มประสิทธิภาพสมัยใหม่

• FlashAttention. Attention แบบแม่นยำที่คำนึงถึงลำดับชั้นหน่วยความจำ GPU; ลดการใช้หน่วยความจำและเร่งการฝึก/inference สำหรับลำดับยาว
• การลดและจัดการ KV‑cache. Multi‑Query Attention และ Grouped‑Query Attention ลดขนาด cache และ traffic หน่วยความจำ; ในระดับเซิร์ฟเวอร์ PagedAttention (vLLM) เพิ่ม throughput ด้วยการจัดการ cache แบบ paging
• Speculative Decoding. โมเดล draft เสนอข้อความต่อ แล้วโมเดลหลักตรวจสอบอย่างรวดเร็ว ได้ความเร็วเพิ่มขึ้นโดยไม่เปลี่ยนการกระจายของ output

Sparse Models และ Mixture‑of‑Experts (MoE)

MoE คือวิธีเพิ่มความจุของโมเดลโดยไม่ต้องเพิ่มการคำนวณต่อ token แบบสัดส่วน แทนที่จะใช้บล็อก FFN ขนาดใหญ่บล็อกเดียวในเลเยอร์ จะใช้กลุ่ม "experts" แบบขนาน (FFN อิสระหลายตัว) และ gating network ที่ฝึกได้จะเลือก expert ที่เกี่ยวข้องที่สุด top‑k สำหรับแต่ละ token (มักเป็น k=1–2; ในบางโมเดลเป็น k=4) เฉพาะ expert ที่เลือกเท่านั้นที่ถูกเปิดใช้งาน; output ของพวกมันถูกถ่วงน้ำหนักและรวมกัน ดังนั้นพารามิเตอร์ทั้งหมดอาจมีหลายร้อยพันล้านหรือแม้แต่ล้านล้าน แต่ในแต่ละขั้นตอนมีเพียงส่วนน้อยเท่านั้นที่ถูกใช้งาน

ตัวอย่างโมเดลและขนาด

• Switch Transformer (Google): ถึง ~1.6T พารามิเตอร์; การ routing แบบ top‑1 (หนึ่ง expert ต่อหนึ่ง token) แสดงให้เห็นว่า MoE ช่วยเพิ่มความจุได้อย่างมากด้วยต้นทุนต่อ token ที่ใกล้เคียงกัน
• GLaM (Google): 1.2T พารามิเตอร์, 64 expert ต่อเลเยอร์, top‑2; สำหรับแต่ละ token มีการเปิดใช้งาน ≈96.6B พารามิเตอร์ (≈8%)
• Mixtral 8×7B (Mistral AI): ~46.7B พารามิเตอร์ทั้งหมด, ≈12.9B ที่ active ต่อ token, top‑2
• Mixtral 8×22B: ~141B พารามิเตอร์ทั้งหมด, ≈39B ที่ active ต่อ token, top‑2
• DBRX (Databricks): 132B พารามิเตอร์ทั้งหมด, ≈36B ที่ active ต่อ token; 16 expert และการ routing แบบ top‑4 (fine‑grained MoE)

ข้อดี

• ต้นทุนการคำนวณถูกกำหนดโดยจำนวน expert ที่ active k ไม่ใช่จำนวนพารามิเตอร์รวม: สามารถฝึกและใช้โมเดลขนาดล้านล้านพารามิเตอร์ด้วยต้นทุนที่เทียบได้กับโมเดล dense ขนาดเล็กกว่าอย่างเห็นได้ชัด
• การเชี่ยวชาญเฉพาะด้าน: expert ปรับตัวโดยอัตโนมัติตามภาษา/โดเมน/รูปแบบ ช่วยเพิ่มคุณภาพในงานหลายโดเมน
• การ deploy ที่ยืดหยุ่น: สามารถเก็บ expert ที่ใช้บ่อยไว้ในหน่วยความจำและโหลด expert ที่ใช้น้อยตามต้องการ (พร้อม infrastructure ที่เหมาะสม)

ข้อจำกัด

• การ balance load: หากไม่มี regularization router อาจ "ติด" กับ expert บางส่วน (router collapse) จำเป็นต้องมี auxiliary losses (load‑balancing) และรูปแบบ routing ที่ปรับปรุงแล้ว
• ความซับซ้อนของการคำนวณแบบกระจาย: ต้องการ expert parallelism และการแลกเปลี่ยน all‑to‑all; ค่าใช้จ่ายด้านการสื่อสารและการจัดการหน่วยความจำกลายเป็นคอขวด
• เสถียรภาพการฝึก: การตั้งค่า router และข้อจำกัด capacity สำคัญมาก มิฉะนั้นอาจเกิดการลดลงของคุณภาพ/การ convergence

การปรับปรุงสมัยใหม่

• Expert‑Choice routing: expert "เลือก" token ซึ่งช่วยปรับปรุงการ balance และ convergence ด้วยต้นทุนที่ใกล้เคียงกัน
• Fine‑grained MoE: จำนวน expert ที่มากขึ้นและขนาดเล็กลง (เช่นใน DBRX) ให้ความเชี่ยวชาญเฉพาะที่ละเอียดขึ้น
• Sparse Upcycling: การแปลงโมเดล dense เป็น MoE จาก checkpoint ช่วยเพิ่มคุณภาพได้อย่างมีนัยสำคัญด้วยต้นทุนปานกลาง

ความเหมาะสมของการใช้ MoE

• ผู้ช่วยหลายโดเมนขนาดใหญ่ที่มีงบประมาณ compute จำกัด
• การฝึกบน corpus ขนาดใหญ่ที่การเชี่ยวชาญเฉพาะด้านให้ประโยชน์
• สถานการณ์ที่มี infrastructure แบบกระจายขั้นสูง (GPU/TPU จำนวนมากและเครือข่ายความเร็วสูง)

เมื่อใดที่โมเดล dense ดีกว่า: infrastructure จำกัด (1–2 GPU), ข้อกำหนด latency ที่คาดเดาได้อย่างเข้มงวด และความเรียบง่ายในการ deploy

Retrieval‑Augmented Generation (RAG)

RAG คือ pattern ของระบบ รอบ LLM ไม่ใช่สถาปัตยกรรมภายในของโมเดลเอง มันรวม LLM (ส่วนประกอบเชิงสร้างสรรค์) กับฐานความรู้ภายนอก (ส่วนประกอบการดึงข้อมูล) ซึ่งช่วยชดเชยข้อจำกัดของ "parametric memory" ของโมเดล

• หลักการทำงาน: ก่อนการสร้าง LLM ดึงเอกสารที่เกี่ยวข้องจากแหล่งภายนอก (wiki, ฐานความรู้องค์กร, เว็บ) และอิงพวกมันในการสร้างคำตอบ
• ข้อดี:
  • การลดภาพหลอนและปรับปรุงความถูกต้องเชิงข้อเท็จจริง
  • ความทันสมัยโดยไม่ต้องฝึกโมเดลใหม่ทั้งหมด
  • การอ้างอิงได้และการติดตามคำตอบได้
• การประยุกต์ใช้: De facto standard สำหรับผู้ช่วยองค์กรและระบบที่ต้องการข้อเท็จจริงที่ตรวจสอบได้และการทำงานกับข้อมูลส่วนตัว/เฉพาะทาง

กลไก Attention และการทำงานกับบริบท

Self‑attention พื้นฐานมีความซับซ้อน quadratic ตามความยาวลำดับ ($O(n^2)$) ดังนั้นจึงมีการเพิ่มประสิทธิภาพต่าง ๆ เกิดขึ้น

• Sparse Attention (การใส่ใจแบบกระจัดกระจาย): การจำกัด attention ด้วยหน้าต่างท้องถิ่น/รูปแบบ ตัวอย่าง: Longformer, BigBird
• FlashAttention: การจัดลำดับการคำนวณใหม่โดยคำนึงถึงลำดับชั้นหน่วยความจำ GPU; ให้ประโยชน์ด้านเวลาและหน่วยความจำอย่างมีนัยสำคัญ และกลายเป็น de facto standard ในการฝึก LLM ที่มีบริบทยาว
• MQA/GQA (การเร่งการถอดรหัส): Multi‑Query Attention (key/value ที่ใช้ร่วมกันสำหรับทุกหัว) ลด traffic ของ KV‑cache Grouped‑Query Attention สร้างสมดุลระหว่างคุณภาพ/ความเร็ว
• การแสดงตำแหน่งที่ปรับปรุงแล้ว:
  • ALiBi (Attention with Linear Biases): การเลื่อนเชิงเส้นในคะแนน attention ช่วยปรับปรุงการ generalize บนความยาวที่มากขึ้น
  • RoPE (Rotary Position Embeddings): ข้อมูลตำแหน่งสัมพัทธ์ผ่านการหมุน Q/K; ใช้กันอย่างแพร่หลายในโมเดลสมัยใหม่ (เช่น LLaMA)
  • การขยายบริบทสำหรับโมเดล RoPE: Position Interpolation, YaRN รวมถึงการปรับเปลี่ยนแบบ NTK‑aware ช่วยให้ขยายหน้าต่างบริบทได้อย่างมีประสิทธิภาพโดยไม่ต้องเปลี่ยนสถาปัตยกรรม

• แนวทางอื่น ๆ สำหรับลำดับยาว:
  • Transformer‑XL: หน่วยความจำ recurrent ระหว่าง segment สำหรับการสร้างแบบจำลอง long-range dependency
  • Reformer: LSH‑attention และ reversible residual block เพื่อประหยัดหน่วยความจำ
  • Performer: การประมาณเชิงเส้นของ softmax‑attention (FAVOR+)
  • Linformer: การประมาณ low-rank ของ matrix attention

การเพิ่มประสิทธิภาพโมเดลและ Infrastructure สำหรับการฝึก

สำหรับการฝึกและ deploy LLM ใช้เทคนิคและ framework เฉพาะทาง

• Quantization (การลดบิต): การลดจำนวนบิตของ weight ลดหน่วยความจำและเร่ง inference QLoRA ช่วยให้ fine-tune โมเดล 4‑bit (รวมถึง 65B) ได้อย่างมีประสิทธิภาพด้วยคุณภาพใกล้เคียงกับความแม่นยำเต็ม
• Knowledge Distillation (การกลั่นความรู้): การฝึกแบบ Teacher→Student สำหรับโมเดลขนาดกะทัดรัด; ตัวอย่าง — DistilBERT
• การฝึกแบบกระจาย:
  • DeepSpeed และ ZeRO — การกระจายพารามิเตอร์/gradient/สถานะ optimizer สำหรับการฝึกโมเดลขนาดล้านล้านพารามิเตอร์
  • Megatron‑LM — tensor parallelism และ pipeline parallelism สำหรับ transformer ขนาดใหญ่มาก
• ระบบนิเวศและเครื่องมือ: Hugging Face Transformers และ Accelerate ให้การ implement โมเดลมาตรฐานและการผสานรวมกับ DeepSpeed/FSDP สำหรับการฝึกและ inference

Scaling Laws และ Compute‑Optimal Training

กฎการปรับขนาด เชิงประจักษ์แสดงให้เห็นว่า cross-entropy error ลดลงตามกฎกำลังเมื่อพารามิเตอร์ ข้อมูล และการคำนวณเพิ่มขึ้น งาน Chinchilla ได้ระบุโหมด compute‑optimal ให้ชัดเจนขึ้น: เพื่อประสิทธิภาพที่ดีที่สุด ขนาดโมเดลและจำนวน token สำหรับการฝึกควรปรับขนาดร่วมกัน (ตัวอย่าง — โมเดล 70B ที่ฝึกบน ~1.4T token แสดงประสิทธิภาพเหนือกว่าโมเดลขนาดใหญ่กว่าที่ฝึกไม่เพียงพอ)

State Space Models (SSM) - โมเดลกับปริภูมิสถานะ

State Space Models (SSM) คือสถาปัตยกรรมทางเลือกแทน transformer สำหรับการทำงานกับลำดับยาว มันยืมแนวคิดจากทฤษฎีการควบคุมและการประมวลผลสัญญาณดิจิทัล และแก้ปัญหาหลักของ self‑attention: การเติบโต quadratic ของการคำนวณตามความยาวข้อความที่เพิ่มขึ้น

ปัญหาหลักและแนวทางแก้ไข

ปัญหาของ transformer. ปัญหาหลักของ transformer แบบดั้งเดิมคือความซับซ้อน quadratic ของ attention: ข้อความที่ยาวขึ้น 10 เท่าต้องการการคำนวณมากขึ้นประมาณ 100 เท่า

แนวทาง SSM. แทนที่จะ "ใส่ใจทุกคำพร้อมกัน" โมเดลผ่านข้อความตามลำดับและรักษา สถานะหน่วยความจำ ภายในที่กะทัดรัดซึ่งอัปเดตในแต่ละขั้นตอน ผลลัพธ์คือเวลาและการใช้หน่วยความจำเติบโตแบบเชิงเส้นโดยประมาณตามความยาวข้อความ ในขณะเดียวกัน การฝึกสามารถทำแบบขนาน — ผ่านการแสดงผลแบบ convolution ของ kernel (throughput สูงบนลำดับยาว)

หลักการทำงาน

SSM แบบ discrete อธิบายด้วยสมการสถานะและผลลัพธ์:

$x_t=A{x}_{t-1}+B{u}_t,y_t=C{x}_t+D{u}_t$

โดยที่ $x_t$ คือสถานะหน่วยความจำ, $u_t$ คือ input (token), $y_t$ คือ output ใน SSM แบบลึก matrix $A,B,C,D$ ถูก parameterize เพื่อให้มีเสถียรภาพและการคำนวณที่มีประสิทธิภาพบนลำดับยาว เลเยอร์เดียวกันสามารถมองได้ว่าเป็น:

• recurrent (การสแกนทีละขั้นตอน) — inference ที่ประหยัดหน่วยความจำโดยไม่มี KV‑cache;
• convolution — การฝึกแบบขนานด้วย kernel ที่คำนวณล่วงหน้า

สถาปัตยกรรมหลักและ hybrid

• S4 (Structured State Spaces). Baseline ของ SSM พร้อม parameterization ที่มั่นคงของ matrix สถานะ; แสดงให้เห็นประสิทธิภาพบนลำดับที่ยาวมาก
• Mamba. SSM แบบ selective: กฎการอัปเดตหน่วยความจำขึ้นอยู่กับ input ปัจจุบัน (โมเดลตัดสินใจเองว่าจะ "เก็บไว้ในหน่วยความจำ" หรือ "ลืม") การ implement มุ่งเน้นที่ลำดับชั้นหน่วยความจำ GPU; ตามข้อมูลของผู้เขียน บรรลุการเพิ่ม throughput inference หลายเท่าด้วยความซับซ้อนเชิงเส้นตามความยาว
• RetNet. กลไก retention สามโหมด: การฝึกแบบขนาน, การ inference แบบ recurrent และ block‑recurrent ด้วยวัตถุประสงค์เพื่อรวมการฝึกที่รวดเร็ว (เช่น transformer) กับ throughput ที่ประหยัดในการ inference (O(1) หน่วยความจำต่อ token)
• Hybrid Attention+SSM. ตัวอย่าง — Jamba (การสลับเลเยอร์ Transformer และ Mamba บวก MoE): รายงานการรองรับบริบทประมาณ ~256K token ด้วยความต้องการหน่วยความจำที่น้อยกว่าอย่างมีนัยสำคัญเมื่อเทียบกับโมเดลที่เป็น transformer ล้วน ๆ ในคลาสที่ใกล้เคียงกัน

ข้อดี

• ความซับซ้อนเชิงเส้นและการประหยัดหน่วยความจำในการ inference ไม่มี global self‑attention และ KV‑cache; เก็บเพียงสถานะที่กะทัดรัด
• การฝึกแบบขนานบนลำดับยาว โหมด convolution เพิ่ม throughput การฝึก
• ประสิทธิภาพด้านฮาร์ดแวร์ การ implement มุ่งเน้นที่ลำดับชั้นหน่วยความจำสมัยใหม่ (HBM/SRAM)
• บริบทยาวและการ streaming Hybrid SSM+Attention ใช้งานได้จริงสำหรับหลายแสน token ด้วยทรัพยากรปานกลาง

ข้อจำกัดและการปฏิบัติในปัจจุบัน

• ความเติบโตของระบบนิเวศ เครื่องมือและ "สูตร" การปรับขนาด (คำสั่ง, RLHF/DPO) ยังด้อยกว่า transformer stack
• คุณภาพและความเสถียร ในบางงาน hybrid (Attention+SSM) แสดงการประนีประนอม "คุณภาพ/ความเร็ว/หน่วยความจำ" ที่เสถียรกว่า SSM "บริสุทธิ์"

การเปรียบเทียบแนวทาง (โดยสรุป)

ลักษณะ	Transformer	SSM	Hybrid (Attention+SSM)
ความซับซ้อนตามความยาว	Quadratic (self‑attention)	เชิงเส้น (สแกน/convolution)	ใกล้เคียงเชิงเส้น
หน่วยความจำต่อ token (inference)	KV‑cache เติบโตตามบริบท	สถานะ O(1)	การเติบโตปานกลาง
บริบทยาว	ต้องการการเพิ่มประสิทธิภาพพิเศษ	รองรับโดยธรรมชาติ	ใช้งานได้จริงถึง ~256K
ความเติบโตของระบบนิเวศ	สูง	กำลังพัฒนา	กำลังพัฒนา

การประยุกต์ใช้งานจริง

• การวิเคราะห์เอกสารยาวมาก (หนังสือ รายงาน บทวิจารณ์ทางวิทยาศาสตร์)
• การประมวลผลแบบ streaming และสถานการณ์แชทที่มีประวัติยาวโดยไม่เพิ่มต้นทุนหน่วยความจำ
• สภาพแวดล้อมที่มีทรัพยากรจำกัด (อุปกรณ์มือถือ/edge)
• อนุกรมเวลาและข้อมูลแบบลำดับอื่น ๆ

โมเดลตัวอย่าง: S4, Mamba, RetNet; Hybrid Attention+SSM (Jamba)

วิวัฒนาการของสถาปัตยกรรม

• 2017 — ตีพิมพ์บทความ \"Attention Is All You Need\" เสนอสถาปัตยกรรม transformer: multi-head self-attention และ positional encoding ช่วยให้ฝึกโมเดลได้โดยไม่ใช้ recurrence และ convolution; ในขณะเดียวกัน attention มีความซับซ้อน quadratic ตามความยาวบริบท

• 2018 — เสนอ GPT‑1 และ BERT GPT‑1 ใช้กลุ่ม decoder เท่านั้นที่มี causal attention สำหรับการสร้างและ fine-tuning ต่อมา; BERT นำเสนอ encoder สองทิศทางและการฝึกเบื้องต้น MLM สำหรับงานด้านความเข้าใจข้อความ

• 2019 — เสนอวิธีทำงานกับลำดับยาวและปรับขนาด decoder‑only Transformer‑XL เพิ่ม "หน่วยความจำ" และตำแหน่งสัมพัทธ์เพื่อขยายออกไปจากหน้าต่างคงที่; GPT‑2 แสดงการเพิ่มขึ้นของความสามารถ zero‑shot เมื่อปรับขนาด; BART แสดงประสิทธิภาพของการฝึก denoising สำหรับ seq2seq

• 2020 — ทำให้รูปแบบ "text‑to‑text" เป็นมาตรฐานและแสดงวิธีการสำหรับเอกสารยาว T5 กำหนดแนวทาง encoder–decoder แบบรวมสำหรับงานต่าง ๆ; Longformer และ BigBird ใช้ attention แบบ sparse/structured สำหรับข้อความยาว; GPT‑3 ยืนยันประสิทธิภาพของการปรับขนาด dense decoder‑only

• 2021 — ปรับปรุงการแสดงตำแหน่งและแสดง sparsity ของพารามิเตอร์ (MoE) RoPE และ ALiBi ปรับปรุงการ generalize บนความยาวที่มากขึ้น; Switch Transformer และ GLaM เปิดใช้งานเฉพาะ expert บางส่วนต่อ token เพิ่มความจุโดยไม่เพิ่มราคา inference แบบสัดส่วน

• 2022 — ระบุโหมด compute‑optimal และเร่ง inference บน prompt ยาว Chinchilla แสดงประโยชน์ของ token การฝึกที่มากขึ้นด้วยขนาดโมเดลปานกลาง; PaLM ด้วย Multi‑Query Attention ลดขนาด KV‑cache; FlashAttention เร่ง attention บน GPU

• 2023 — ขยายหน้าต่างบริบทโดยไม่เปลี่ยนเลเยอร์และปรับปรุงการให้บริการ LLaMA ยืนยันแนวปฏิบัติ (RMSNorm, SwiGLU, RoPE); Position Interpolation และ YaRN ขยายบริบท; vLLM/PagedAttention จัดการ KV‑cache ได้อย่างมีประสิทธิภาพมากขึ้น

• 2023 — GPT‑4 และ Gemini แสดงการประมวลผลและการสร้างในหลาย modality ภายในตระกูลโมเดลเดียว

• 2023 — เสนอโมเดลกับปริภูมิสถานะ (SSM) Mamba และ RetNet กลับมาใช้การประมวลผลตามลำดับด้วยสถานะที่กะทัดรัดแทน KV‑cache และวางรากฐานสำหรับสถาปัตยกรรม hybrid

• 2024 — ตีพิมพ์โมเดล MoE แบบเปิดและ hybrid Attention+SSM; เร่ง attention บน GPU ใหม่ Mixtral 8×7B/8×22B และ DBRX ยืนยันความใช้ได้จริงของ MoE; Jamba รวม Transformer และ Mamba สำหรับบริบทยาวมาก; FlashAttention‑3 เพิ่ม throughput

ลิงก์

• https://jalammar.github.io/illustrated-transformer/ The Illustrated Transformer — คำอธิบายเชิงภาพ

บรรณานุกรม

• Vaswani, A. et al. (2017). Attention Is All You Need. NIPS. https://arxiv.org/abs/1706.03762
• Devlin, J. et al. (2019). BERT. NAACL. https://arxiv.org/abs/1810.04805
• Brown, T. et al. (2020). Language Models are Few‑Shot Learners. NeurIPS. https://arxiv.org/abs/2005.14165
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text‑to‑Text Transformer (T5). JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
• Lewis, M. et al. (2019). BART: Denoising Sequence‑to‑Sequence Pre‑training. https://arxiv.org/abs/1910.13461
• Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
• Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
• Dao, T. et al. (2022–2024). FlashAttention (1/2/3). https://arxiv.org/abs/2205.14135 ; https://arxiv.org/abs/2307.08691 ; https://arxiv.org/abs/2407.08608
• Shazeer, N. (2019). MQA. https://arxiv.org/abs/1911.02150
• Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
• Kwon, W. et al. (2023). PagedAttention / vLLM. https://arxiv.org/abs/2309.06180
• Leviathan, Y. et al. (2023). Speculative Decoding. https://arxiv.org/abs/2211.17192
• Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
• Du, N. et al. (2022). GLaM. https://proceedings.mlr.press/v162/du22c/du22c.pdf
• Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
• Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
• NVIDIA (2024). Applying Mixture of Experts in LLM Architectures. https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/
• Zhou, Y. et al. (2022). Expert Choice Routing. https://arxiv.org/abs/2202.09368
• Komatsuzaki, A. et al. (2022). Sparse Upcycling. https://arxiv.org/abs/2212.05055
• Lewis, P. et al. (2020). RAG. https://arxiv.org/abs/2005.11401
• Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
• Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
• Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
• Su, J. et al. (2021). RoFormer (RoPE). https://arxiv.org/abs/2104.09864
• Chen, S. et al. (2023). Position Interpolation. https://arxiv.org/abs/2306.15595
• Peng, B. et al. (2023). YaRN. https://arxiv.org/abs/2309.00071
• Dettmers, T. et al. (2023). QLoRA. https://arxiv.org/abs/2305.14314
• Rajbhandari, S. et al. (2020). ZeRO. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
• Shoeybi, M. et al. (2019). Megatron‑LM. https://arxiv.org/abs/1909.08053
• Kaplan, J. et al. (2020). Scaling Laws. https://arxiv.org/abs/2001.08361
• Hoffmann, J. et al. (2022). Chinchilla / Compute‑Optimal. https://arxiv.org/abs/2203.15556
• Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
• Bai, Y. et al. (2022). Constitutional AI. https://arxiv.org/abs/2212.08073
• OpenAI (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
• OpenAI (2023). DevDay: GPT‑4 Turbo 128k. https://openai.com/index/new-models-and-developer-products-announced-at-devday/
• Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
• Shazeer, N. (2020). GLU Variants / SwiGLU. https://arxiv.org/abs/2002.05202
• Gu, A.; Goel, K.; Ré, C. (2021). S4: Structured State Spaces. https://arxiv.org/abs/2111.00396
• Gu, A.; Dao, T. (2023/2024). Mamba: Selective State Spaces. https://arxiv.org/abs/2312.00752
• Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
• Lieber, O. et al. (2024). Jamba: Hybrid Transformer‑Mamba. https://arxiv.org/abs/2403.19887
• Dai, Z. et al. (2019). Transformer‑XL. https://arxiv.org/abs/1901.02860
• Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer. https://arxiv.org/abs/2001.04451
• Choromanski, K. et al. (2021). Performer. https://arxiv.org/abs/2009.14794
• Wang, S. et al. (2020). Linformer. https://arxiv.org/abs/2006.04768