Large language model architectures — สถาปัตยกรรมของโมเดลภาษาขนาดใหญ่
สถาปัตยกรรมของโมเดลภาษาขนาดใหญ่ (LLM) — คือหลักการและโครงสร้างพื้นฐานที่กำหนดวิธีการสร้าง การฝึก และการทำงานของโมเดลภาษาขนาดใหญ่ LLM สมัยใหม่ที่สามารถเข้าใจและสร้างภาษามนุษย์ได้นั้น เกือบทั้งหมดอิงบนสถาปัตยกรรม Transformer[1] แต่รวมถึงการปรับปรุงและแนวทางต่าง ๆ มากมายที่มุ่งเพิ่มประสิทธิภาพ ความสามารถในการปรับขนาด และขีดความสามารถ
ตระกูลสถาปัตยกรรม LLM (transformer)
โมเดลภาษาขนาดใหญ่สมัยใหม่อิงบนสถาปัตยกรรม transformer[1] แต่ใช้งานในรูปแบบที่แตกต่างกันตามวัตถุประสงค์ ไม่ว่าจะเป็นการทำความเข้าใจข้อความ การสร้างข้อความต่อเนื่อง หรือการแปลงข้อความหนึ่งเป็นอีกข้อความหนึ่ง ในทางปฏิบัติมีการแบ่งออกเป็นสามตระกูลโดยยังคงหลักการพื้นฐานของ transformer[2][3][4]
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) [5][6][7][8][9][10]
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)[11][12][13][14][15]
ข้อดี:
- การสร้างข้อความแบบธรรมชาติ (CLM): ความสามารถ zero‑shot และ few‑shot ที่แข็งแกร่ง ปรับขนาดได้ดี[16]
- ความเอนกประสงค์: โมเดลเดียวแก้ปัญหาหลายอย่างด้วยคำสั่งและตัวอย่างใน prompt รวมเข้ากับ RAG และการเรียกใช้เครื่องมือ (tool use) ได้อย่างเป็นธรรมชาติ
- ระบบนิเวศที่เติบโตเต็มที่: แนวปฏิบัติของ fine-tuning เชิงคำสั่งและการปรับพฤติกรรม (RLHF, DPO) มีการใช้งานทั้งแบบเปิดและเชิงพาณิชย์[17][18]
- ชุดการเพิ่มประสิทธิภาพ inference ที่สมบูรณ์: MQA/GQA ลดขนาด KV‑cache และเพิ่มปริมาณงาน; speculative decoding เร่งการ inference โดยไม่เปลี่ยนการกระจาย; PagedAttention/vLLM พร้อม continuous batching และ chunked prefill เพิ่มการใช้งาน GPU แบบ end-to-end[19][20][21][22][23]
- รองรับการสร้างโครงสร้างสำหรับรูปแบบคำตอบที่เข้มงวด (JSON/SQL/DSL) ซึ่งช่วยให้การผสานรวมกับระบบสารสนเทศและ API ง่ายขึ้น[24][25]
ข้อเสีย:
- Latency การสร้างที่สูงขึ้น: การ inference แบบลำดับ; ต้นทุนของ token ใหม่เติบโตตามความยาวของบริบทที่ "อ่านไปแล้ว" (KV‑cache)
- ประสิทธิภาพน้อยกว่าในโปรไฟล์ "input ยาว – output สั้น" (การสรุป การแปล) เมื่อเทียบกับ encoder–decoder ที่เข้ารหัส input เพียงครั้งเดียว
- ข้อจำกัดของบริบททิศทางเดียว: ในงานด้านความเข้าใจบางครั้งด้อยกว่าโมเดลที่มีการแสดงผลสองทิศทาง (encoder‑only / encoder–decoder)
- หน่วยความจำสำหรับ KV‑cache อาจเป็น "คอขวด" เมื่อมี prompt ยาวและ batch ขนาดใหญ่[26]
- การ quantize activation/KV (INT8/FP8) เร่ง inference แต่อาจลดคุณภาพในบริบทยาว/โค้ด จำเป็นต้องมีการตรวจสอบความถูกต้องอย่างละเอียด (โดยเฉพาะเมื่อมี SLA ที่เข้มงวด)
โมเดลตัวอย่าง: GPT‑3, GPT‑4 (รายละเอียดสถาปัตยกรรมและชุดข้อมูลไม่เปิดเผยต่อสาธารณะ), LLaMA และ Llama 3 (8B/70B, 2024)[27][28][29][30]
3. Encoder–decoder (ตัวเข้ารหัส–ตัวถอดรหัส)
สถาปัตยกรรมนี้รวมส่วนประกอบทั้งสองไว้ด้วยกัน Encoder ทำงานในโหมดสองทิศทาง ส่วน decoder — แบบ causal Encoder วิเคราะห์ input ครั้งเดียวและสร้างการแทนค่า; decoder สร้าง output โดยอ้างอิงการแทนค่านั้นผ่าน cross‑attention แนวทางแยกส่วนนี้มีประโยชน์อย่างยิ่งในกรณีที่ต้องแปลง input ข้อความยาวให้เป็น output สั้น: การแปลด้วยเครื่อง การสรุป และการตอบคำถามโดยอิงเอกสาร แม้วิธีนี้ต้องการต้นทุนการคำนวณรวมที่สูงกว่า (สองกลุ่มและ cross‑attention) แต่ข้อได้เปรียบคือการสร้างที่ควบคุมได้บนพื้นฐานการวิเคราะห์ข้อความต้นฉบับอย่างสมบูรณ์ โดยการเข้ารหัสทำเพียงครั้งเดียวและนำมาใช้ซ้ำตลอดกระบวนการ inference
ข้อดี:
- การสร้างแบบมีเงื่อนไข: decoder ใช้ cross‑attention กับการแทนค่าของ input[31]
- มีประสิทธิภาพในสถานการณ์ "input ยาว → output สั้น": input ถูกเข้ารหัสเพียงครั้งเดียว
- เหมาะสำหรับรูปแบบ "text‑to‑text" และการสร้าง output แบบควบคุม (prefix ของงาน คำสั่งพิเศษ)[32]
- ความเสถียรและประสิทธิภาพเมื่อมีแหล่งที่มายาว: ในระยะถอดรหัส 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[33][34][35]
Dense Transformer - Transformer แบบหนาแน่น
สถาปัตยกรรม LLM แบบคลาสสิกและแพร่หลายที่สุด: ในการประมวลผล token แต่ละตัวจะมีพารามิเตอร์ของโมเดลเกือบทั้งหมดเข้าร่วม ต่างจากแนวทาง sparse (เช่น Mixture‑of‑Experts) ตรงที่ไม่มีการเปิดใช้งาน subnetwork แบบเลือกสรร — แต่ละบล็อกทำงานสำหรับ token ทุกตัว[1]
หลักการทำงานและสถาปัตยกรรม
โครงสร้างพื้นฐาน. โมเดลคือกลุ่มของบล็อก transformer N บล็อกที่มีรูปแบบเหมือนกัน แต่ละบล็อกประกอบด้วย:
- Multi‑Head Self‑Attention (การใส่ใจตนเองหลายหัว). สำหรับ token แต่ละตัวจะคำนวณเวกเตอร์สามตัว: Q (query), K (key), V (value); attention ถูกกำหนดเป็น โดยที่ คือ mask (causal และ/หรือ padding mask) ที่ยกเว้นตำแหน่งที่ไม่อนุญาต "หัว" attention หลายหัวพิจารณาด้านต่าง ๆ ของบริบทแบบขนาน (H หัว มักเป็น ) จำนวนหัวเพิ่มขึ้นตามขนาดของโมเดล[1]
- Feed‑Forward Network (FFN หรือเครือข่ายไปข้างหน้าแบบเชื่อมต่อเต็มรูปแบบ). สองเลเยอร์เชิงเส้นที่มี nonlinearity ระหว่างกัน (มักเป็น GELU/SiLU; ในโมเดลสมัยใหม่บางรุ่น — SwiGLU) มิติตรงกลางมักเป็น ; เมื่อใช้ SwiGLU มักใช้ เพื่อรักษาจำนวนพารามิเตอร์ที่ใกล้เคียงกัน FFN มีพารามิเตอร์เป็นสัดส่วนที่มีนัยสำคัญ[1][36]
ส่วนประกอบเพิ่มเติม. ใช้ 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 ล้านพารามิเตอร์[37]
- GPT‑3 (175B): 96 เลเยอร์, มิติ 12288, 96 หัว attention, ≈175 พันล้านพารามิเตอร์[38]
- LLaMA‑65B: 80 เลเยอร์, มิติ 8192, 64 หัว attention, ≈65 พันล้านพารามิเตอร์[39]
- PaLM‑540B: 118 เลเยอร์, มิติประมาณ 18432, ≈540 พันล้านพารามิเตอร์[40]
ข้อดี
- บล็อกที่สม่ำเสมอ โหมดการฝึกที่ศึกษาดีแล้ว และพฤติกรรมที่คาดเดาได้เมื่อปรับขนาด
- คุณภาพดีขึ้นตามกฎกำลังเมื่อพารามิเตอร์และข้อมูลเพิ่มขึ้น; โหมด compute‑optimal ต้องการการเพิ่มขนาดโมเดลและจำนวน token สำหรับการฝึกพร้อมกัน[41][42]
- สถาปัตยกรรมเดียวกันหลัง fine-tuning ครอบคลุมงานหลากหลายโดยไม่ต้องเปลี่ยนแปลงระดับเลเยอร์
ข้อเสีย
- Self‑attention แบบเต็มรูปแบบมีความซับซ้อน quadratic ตามความยาวลำดับ () ซึ่งจำกัดหน้าต่างบริบท[1]
- การเปิดใช้งานพารามิเตอร์เต็มรูปแบบในขั้นตอนการสร้าง: ใน decoder ที่ไม่มี MoE ต้นทุนการ inference ต่อ token เพิ่มขึ้นตามสัดส่วนของจำนวนพารามิเตอร์โดยประมาณ
- คอขวดคือ bandwidth ของหน่วยความจำ (memory‑bound): การโหลด weight จาก HBM มักจำกัดความเร็ว inference
ข้อจำกัดของการปรับขนาดและบริบท
- หน่วยความจำสำหรับพารามิเตอร์เพิ่มขึ้นเชิงเส้นตามขนาดโมเดล; หน่วยความจำสำหรับการฝึกเพิ่มขึ้นเนื่องจาก gradient และสถานะ optimizer
- การกำหนดค่าพื้นฐานในอดีตมักจำกัดอยู่ที่ 2–4 พัน token รูปแบบตำแหน่งสมัยใหม่ (RoPE) และเทคนิคการขยาย (Position Interpolation, YaRN และอื่น ๆ) ช่วยให้ขยายหน้าต่างได้อีกหลายเท่า แต่แลกกับภาระการคำนวณ/หน่วยความจำเพิ่มเติม[43][44]
การเพิ่มประสิทธิภาพสมัยใหม่
- FlashAttention. Attention แบบแม่นยำที่คำนึงถึงลำดับชั้นหน่วยความจำ GPU; ลดการใช้หน่วยความจำและเร่งการฝึก/inference สำหรับลำดับยาว[45]
- การลดและจัดการ KV‑cache. Multi‑Query Attention และ Grouped‑Query Attention ลดขนาด cache และ traffic หน่วยความจำ; ในระดับเซิร์ฟเวอร์ PagedAttention (vLLM) เพิ่ม throughput ด้วยการจัดการ cache แบบ paging[46][47][48]
- Speculative Decoding. โมเดล draft เสนอข้อความต่อ แล้วโมเดลหลักตรวจสอบอย่างรวดเร็ว ได้ความเร็วเพิ่มขึ้นโดยไม่เปลี่ยนการกระจายของ output[49]
Sparse Models และ Mixture‑of‑Experts (MoE)
MoE คือวิธีเพิ่มความจุของโมเดลโดยไม่ต้องเพิ่มการคำนวณต่อ token แบบสัดส่วน แทนที่จะใช้บล็อก FFN ขนาดใหญ่บล็อกเดียวในเลเยอร์ จะใช้กลุ่ม "experts" แบบขนาน (FFN อิสระหลายตัว) และ gating network ที่ฝึกได้จะเลือก expert ที่เกี่ยวข้องที่สุด top‑k สำหรับแต่ละ token (มักเป็น k=1–2; ในบางโมเดลเป็น k=4) เฉพาะ expert ที่เลือกเท่านั้นที่ถูกเปิดใช้งาน; output ของพวกมันถูกถ่วงน้ำหนักและรวมกัน ดังนั้นพารามิเตอร์ทั้งหมดอาจมีหลายร้อยพันล้านหรือแม้แต่ล้านล้าน แต่ในแต่ละขั้นตอนมีเพียงส่วนน้อยเท่านั้นที่ถูกใช้งาน[50][51]
ตัวอย่างโมเดลและขนาด
- Switch Transformer (Google): ถึง ~1.6T พารามิเตอร์; การ routing แบบ top‑1 (หนึ่ง expert ต่อหนึ่ง token) แสดงให้เห็นว่า MoE ช่วยเพิ่มความจุได้อย่างมากด้วยต้นทุนต่อ token ที่ใกล้เคียงกัน[50]
- GLaM (Google): 1.2T พารามิเตอร์, 64 expert ต่อเลเยอร์, top‑2; สำหรับแต่ละ token มีการเปิดใช้งาน ≈96.6B พารามิเตอร์ (≈8%)[51]
- Mixtral 8×7B (Mistral AI): ~46.7B พารามิเตอร์ทั้งหมด, ≈12.9B ที่ active ต่อ token, top‑2[52][53]
- Mixtral 8×22B: ~141B พารามิเตอร์ทั้งหมด, ≈39B ที่ active ต่อ token, top‑2[54]
- DBRX (Databricks): 132B พารามิเตอร์ทั้งหมด, ≈36B ที่ active ต่อ token; 16 expert และการ routing แบบ top‑4 (fine‑grained MoE)[55]
ข้อดี
- ต้นทุนการคำนวณถูกกำหนดโดยจำนวน expert ที่ active k ไม่ใช่จำนวนพารามิเตอร์รวม: สามารถฝึกและใช้โมเดลขนาดล้านล้านพารามิเตอร์ด้วยต้นทุนที่เทียบได้กับโมเดล dense ขนาดเล็กกว่าอย่างเห็นได้ชัด[51]
- การเชี่ยวชาญเฉพาะด้าน: expert ปรับตัวโดยอัตโนมัติตามภาษา/โดเมน/รูปแบบ ช่วยเพิ่มคุณภาพในงานหลายโดเมน
- การ deploy ที่ยืดหยุ่น: สามารถเก็บ expert ที่ใช้บ่อยไว้ในหน่วยความจำและโหลด expert ที่ใช้น้อยตามต้องการ (พร้อม infrastructure ที่เหมาะสม)
ข้อจำกัด
- การ balance load: หากไม่มี regularization router อาจ "ติด" กับ expert บางส่วน (router collapse) จำเป็นต้องมี auxiliary losses (load‑balancing) และรูปแบบ routing ที่ปรับปรุงแล้ว[50]
- ความซับซ้อนของการคำนวณแบบกระจาย: ต้องการ expert parallelism และการแลกเปลี่ยน all‑to‑all; ค่าใช้จ่ายด้านการสื่อสารและการจัดการหน่วยความจำกลายเป็นคอขวด[56]
- เสถียรภาพการฝึก: การตั้งค่า router และข้อจำกัด capacity สำคัญมาก มิฉะนั้นอาจเกิดการลดลงของคุณภาพ/การ convergence
การปรับปรุงสมัยใหม่
- Expert‑Choice routing: expert "เลือก" token ซึ่งช่วยปรับปรุงการ balance และ convergence ด้วยต้นทุนที่ใกล้เคียงกัน[57]
- Fine‑grained MoE: จำนวน expert ที่มากขึ้นและขนาดเล็กลง (เช่นใน DBRX) ให้ความเชี่ยวชาญเฉพาะที่ละเอียดขึ้น[55]
- Sparse Upcycling: การแปลงโมเดล dense เป็น MoE จาก checkpoint ช่วยเพิ่มคุณภาพได้อย่างมีนัยสำคัญด้วยต้นทุนปานกลาง[58]
ความเหมาะสมของการใช้ MoE
- ผู้ช่วยหลายโดเมนขนาดใหญ่ที่มีงบประมาณ compute จำกัด
- การฝึกบน corpus ขนาดใหญ่ที่การเชี่ยวชาญเฉพาะด้านให้ประโยชน์
- สถานการณ์ที่มี infrastructure แบบกระจายขั้นสูง (GPU/TPU จำนวนมากและเครือข่ายความเร็วสูง)
เมื่อใดที่โมเดล dense ดีกว่า: infrastructure จำกัด (1–2 GPU), ข้อกำหนด latency ที่คาดเดาได้อย่างเข้มงวด และความเรียบง่ายในการ deploy
Retrieval‑Augmented Generation (RAG)
RAG คือ pattern ของระบบ รอบ LLM ไม่ใช่สถาปัตยกรรมภายในของโมเดลเอง มันรวม LLM (ส่วนประกอบเชิงสร้างสรรค์) กับฐานความรู้ภายนอก (ส่วนประกอบการดึงข้อมูล) ซึ่งช่วยชดเชยข้อจำกัดของ "parametric memory" ของโมเดล
กลไก Attention และการทำงานกับบริบท
Self‑attention พื้นฐานมีความซับซ้อน quadratic ตามความยาวลำดับ () ดังนั้นจึงมีการเพิ่มประสิทธิภาพต่าง ๆ เกิดขึ้น
- Sparse Attention (การใส่ใจแบบกระจัดกระจาย): การจำกัด attention ด้วยหน้าต่างท้องถิ่น/รูปแบบ ตัวอย่าง: Longformer[61], BigBird[62]
- FlashAttention: การจัดลำดับการคำนวณใหม่โดยคำนึงถึงลำดับชั้นหน่วยความจำ GPU; ให้ประโยชน์ด้านเวลาและหน่วยความจำอย่างมีนัยสำคัญ และกลายเป็น de facto standard ในการฝึก LLM ที่มีบริบทยาว[63][64][65]
- MQA/GQA (การเร่งการถอดรหัส): Multi‑Query Attention (key/value ที่ใช้ร่วมกันสำหรับทุกหัว) ลด traffic ของ KV‑cache[66] Grouped‑Query Attention สร้างสมดุลระหว่างคุณภาพ/ความเร็ว[67]
- การแสดงตำแหน่งที่ปรับปรุงแล้ว:
- ALiBi (Attention with Linear Biases): การเลื่อนเชิงเส้นในคะแนน attention ช่วยปรับปรุงการ generalize บนความยาวที่มากขึ้น[68]
- RoPE (Rotary Position Embeddings): ข้อมูลตำแหน่งสัมพัทธ์ผ่านการหมุน Q/K; ใช้กันอย่างแพร่หลายในโมเดลสมัยใหม่ (เช่น LLaMA)[69][70]
- การขยายบริบทสำหรับโมเดล RoPE: Position Interpolation[71], YaRN[72] รวมถึงการปรับเปลี่ยนแบบ NTK‑aware ช่วยให้ขยายหน้าต่างบริบทได้อย่างมีประสิทธิภาพโดยไม่ต้องเปลี่ยนสถาปัตยกรรม
- แนวทางอื่น ๆ สำหรับลำดับยาว:
- Transformer‑XL: หน่วยความจำ recurrent ระหว่าง segment สำหรับการสร้างแบบจำลอง long-range dependency[73]
- Reformer: LSH‑attention และ reversible residual block เพื่อประหยัดหน่วยความจำ[74]
- Performer: การประมาณเชิงเส้นของ softmax‑attention (FAVOR+)[75]
- Linformer: การประมาณ low-rank ของ matrix attention[76]
การเพิ่มประสิทธิภาพโมเดลและ Infrastructure สำหรับการฝึก
สำหรับการฝึกและ deploy LLM ใช้เทคนิคและ framework เฉพาะทาง
- Quantization (การลดบิต): การลดจำนวนบิตของ weight ลดหน่วยความจำและเร่ง inference QLoRA ช่วยให้ fine-tune โมเดล 4‑bit (รวมถึง 65B) ได้อย่างมีประสิทธิภาพด้วยคุณภาพใกล้เคียงกับความแม่นยำเต็ม[77]
- Knowledge Distillation (การกลั่นความรู้): การฝึกแบบ Teacher→Student สำหรับโมเดลขนาดกะทัดรัด[78]; ตัวอย่าง — DistilBERT[79]
- การฝึกแบบกระจาย:
- ระบบนิเวศและเครื่องมือ: Hugging Face Transformers และ Accelerate ให้การ implement โมเดลมาตรฐานและการผสานรวมกับ DeepSpeed/FSDP สำหรับการฝึกและ inference[82][83]
Scaling Laws และ Compute‑Optimal Training
กฎการปรับขนาด เชิงประจักษ์แสดงให้เห็นว่า cross-entropy error ลดลงตามกฎกำลังเมื่อพารามิเตอร์ ข้อมูล และการคำนวณเพิ่มขึ้น[84] งาน Chinchilla ได้ระบุโหมด compute‑optimal ให้ชัดเจนขึ้น: เพื่อประสิทธิภาพที่ดีที่สุด ขนาดโมเดลและจำนวน token สำหรับการฝึกควรปรับขนาดร่วมกัน (ตัวอย่าง — โมเดล 70B ที่ฝึกบน ~1.4T token แสดงประสิทธิภาพเหนือกว่าโมเดลขนาดใหญ่กว่าที่ฝึกไม่เพียงพอ)[85]
State Space Models (SSM) - โมเดลกับปริภูมิสถานะ
State Space Models (SSM) คือสถาปัตยกรรมทางเลือกแทน transformer สำหรับการทำงานกับลำดับยาว มันยืมแนวคิดจากทฤษฎีการควบคุมและการประมวลผลสัญญาณดิจิทัล และแก้ปัญหาหลักของ self‑attention: การเติบโต quadratic ของการคำนวณตามความยาวข้อความที่เพิ่มขึ้น
ปัญหาหลักและแนวทางแก้ไข
ปัญหาของ transformer. ปัญหาหลักของ transformer แบบดั้งเดิมคือความซับซ้อน quadratic ของ attention: ข้อความที่ยาวขึ้น 10 เท่าต้องการการคำนวณมากขึ้นประมาณ 100 เท่า
แนวทาง SSM. แทนที่จะ "ใส่ใจทุกคำพร้อมกัน" โมเดลผ่านข้อความตามลำดับและรักษา สถานะหน่วยความจำ ภายในที่กะทัดรัดซึ่งอัปเดตในแต่ละขั้นตอน ผลลัพธ์คือเวลาและการใช้หน่วยความจำเติบโตแบบเชิงเส้นโดยประมาณตามความยาวข้อความ ในขณะเดียวกัน การฝึกสามารถทำแบบขนาน — ผ่านการแสดงผลแบบ convolution ของ kernel (throughput สูงบนลำดับยาว)[86]
หลักการทำงาน
SSM แบบ discrete อธิบายด้วยสมการสถานะและผลลัพธ์:
โดยที่ คือสถานะหน่วยความจำ, คือ input (token), คือ output ใน SSM แบบลึก matrix ถูก parameterize เพื่อให้มีเสถียรภาพและการคำนวณที่มีประสิทธิภาพบนลำดับยาว เลเยอร์เดียวกันสามารถมองได้ว่าเป็น:
- recurrent (การสแกนทีละขั้นตอน) — inference ที่ประหยัดหน่วยความจำโดยไม่มี KV‑cache;
- convolution — การฝึกแบบขนานด้วย kernel ที่คำนวณล่วงหน้า[86]
สถาปัตยกรรมหลักและ hybrid
- S4 (Structured State Spaces). Baseline ของ SSM พร้อม parameterization ที่มั่นคงของ matrix สถานะ; แสดงให้เห็นประสิทธิภาพบนลำดับที่ยาวมาก[86]
- Mamba. SSM แบบ selective: กฎการอัปเดตหน่วยความจำขึ้นอยู่กับ input ปัจจุบัน (โมเดลตัดสินใจเองว่าจะ "เก็บไว้ในหน่วยความจำ" หรือ "ลืม") การ implement มุ่งเน้นที่ลำดับชั้นหน่วยความจำ GPU; ตามข้อมูลของผู้เขียน บรรลุการเพิ่ม throughput inference หลายเท่าด้วยความซับซ้อนเชิงเส้นตามความยาว[87]
- RetNet. กลไก retention สามโหมด: การฝึกแบบขนาน, การ inference แบบ recurrent และ block‑recurrent ด้วยวัตถุประสงค์เพื่อรวมการฝึกที่รวดเร็ว (เช่น transformer) กับ throughput ที่ประหยัดในการ inference (O(1) หน่วยความจำต่อ token)[88]
- Hybrid Attention+SSM. ตัวอย่าง — Jamba (การสลับเลเยอร์ Transformer และ Mamba บวก MoE): รายงานการรองรับบริบทประมาณ ~256K token ด้วยความต้องการหน่วยความจำที่น้อยกว่าอย่างมีนัยสำคัญเมื่อเทียบกับโมเดลที่เป็น transformer ล้วน ๆ ในคลาสที่ใกล้เคียงกัน[89]
ข้อดี
- ความซับซ้อนเชิงเส้นและการประหยัดหน่วยความจำในการ inference ไม่มี global self‑attention และ KV‑cache; เก็บเพียงสถานะที่กะทัดรัด[87][88]
- การฝึกแบบขนานบนลำดับยาว โหมด convolution เพิ่ม throughput การฝึก[86]
- ประสิทธิภาพด้านฮาร์ดแวร์ การ implement มุ่งเน้นที่ลำดับชั้นหน่วยความจำสมัยใหม่ (HBM/SRAM)[87]
- บริบทยาวและการ streaming Hybrid SSM+Attention ใช้งานได้จริงสำหรับหลายแสน token ด้วยทรัพยากรปานกลาง[89]
ข้อจำกัดและการปฏิบัติในปัจจุบัน
- ความเติบโตของระบบนิเวศ เครื่องมือและ "สูตร" การปรับขนาด (คำสั่ง, RLHF/DPO) ยังด้อยกว่า transformer stack[87]
- คุณภาพและความเสถียร ในบางงาน hybrid (Attention+SSM) แสดงการประนีประนอม "คุณภาพ/ความเร็ว/หน่วยความจำ" ที่เสถียรกว่า SSM "บริสุทธิ์"[89]
การเปรียบเทียบแนวทาง (โดยสรุป)
| ลักษณะ | 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)[86][87][88][89]
วิวัฒนาการของสถาปัตยกรรม
- 2017 — ตีพิมพ์บทความ \"Attention Is All You Need\" เสนอสถาปัตยกรรม transformer: multi-head self-attention และ positional encoding ช่วยให้ฝึกโมเดลได้โดยไม่ใช้ recurrence และ convolution; ในขณะเดียวกัน attention มีความซับซ้อน quadratic ตามความยาวบริบท[1]
- 2018 — เสนอ GPT‑1 และ BERT GPT‑1 ใช้กลุ่ม decoder เท่านั้นที่มี causal attention สำหรับการสร้างและ fine-tuning ต่อมา; BERT นำเสนอ encoder สองทิศทางและการฝึกเบื้องต้น MLM สำหรับงานด้านความเข้าใจข้อความ[90][91]
- 2019 — เสนอวิธีทำงานกับลำดับยาวและปรับขนาด decoder‑only Transformer‑XL เพิ่ม "หน่วยความจำ" และตำแหน่งสัมพัทธ์เพื่อขยายออกไปจากหน้าต่างคงที่; GPT‑2 แสดงการเพิ่มขึ้นของความสามารถ zero‑shot เมื่อปรับขนาด; BART แสดงประสิทธิภาพของการฝึก denoising สำหรับ seq2seq[92][93][94]
- 2020 — ทำให้รูปแบบ "text‑to‑text" เป็นมาตรฐานและแสดงวิธีการสำหรับเอกสารยาว T5 กำหนดแนวทาง encoder–decoder แบบรวมสำหรับงานต่าง ๆ; Longformer และ BigBird ใช้ attention แบบ sparse/structured สำหรับข้อความยาว; GPT‑3 ยืนยันประสิทธิภาพของการปรับขนาด dense decoder‑only[95][96][97][98]
- 2021 — ปรับปรุงการแสดงตำแหน่งและแสดง sparsity ของพารามิเตอร์ (MoE) RoPE และ ALiBi ปรับปรุงการ generalize บนความยาวที่มากขึ้น; Switch Transformer และ GLaM เปิดใช้งานเฉพาะ expert บางส่วนต่อ token เพิ่มความจุโดยไม่เพิ่มราคา inference แบบสัดส่วน[99][100][101][102]
- 2022 — ระบุโหมด compute‑optimal และเร่ง inference บน prompt ยาว Chinchilla แสดงประโยชน์ของ token การฝึกที่มากขึ้นด้วยขนาดโมเดลปานกลาง; PaLM ด้วย Multi‑Query Attention ลดขนาด KV‑cache; FlashAttention เร่ง attention บน GPU[103][104][105][106]
- 2023 — ขยายหน้าต่างบริบทโดยไม่เปลี่ยนเลเยอร์และปรับปรุงการให้บริการ LLaMA ยืนยันแนวปฏิบัติ (RMSNorm, SwiGLU, RoPE); Position Interpolation และ YaRN ขยายบริบท; vLLM/PagedAttention จัดการ KV‑cache ได้อย่างมีประสิทธิภาพมากขึ้น[107][108][109][110][111][112]
ลิงก์
- 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
หมายเหตุ
- ↑ 1.0 1.1 1.2 1.3 1.4 1.5 1.6 Vaswani, A. et al. (2017). Attention Is All You Need. https://arxiv.org/abs/1706.03762
- ↑ Devlin, J. et al. (2019). BERT. https://arxiv.org/abs/1810.04805
- ↑ Brown, T. et al. (2020). Language Models are Few‑Shot Learners. https://arxiv.org/abs/2005.14165
- ↑ Raffel, C. et al. (2020). T5. https://jmlr.org/papers/volume21/20-074/20-074.pdf
- ↑ Devlin, J. et al. (2019). BERT: Pre‑training of Deep Bidirectional Transformers for Language Understanding. https://arxiv.org/abs/1810.04805
- ↑ Liu, Y. et al. (2019). RoBERTa: A Robustly Optimized BERT Pretraining Approach. https://arxiv.org/abs/1907.11692
- ↑ He, P. et al. (2021). DeBERTa: Decoding‑enhanced BERT with Disentangled Attention. https://arxiv.org/abs/2006.03654
- ↑ Clark, K. et al. (2020). ELECTRA: Pre‑training Text Encoders as Discriminators Rather Than Generators. https://arxiv.org/abs/2003.10555
- ↑ Zaheer, M. et al. (2020). Big Bird: Transformers for Longer Sequences. https://arxiv.org/abs/2007.14062
- ↑ Beltagy, I. et al. (2020). Longformer: The Long‑Document Transformer. https://arxiv.org/abs/2004.05150
- ↑ Shazeer, N. (2019). Fast Transformer Decoding: One Write‑Head is All You Need (Multi‑Query Attention). https://arxiv.org/abs/1911.02150
- ↑ Ainslie, J. et al. (2023). GQA: Training Generalized Multi‑Query Transformer Models from Multi‑Head Checkpoints. https://arxiv.org/abs/2305.13245
- ↑ Leviathan, Y. et al. (2023). Fast Inference from Transformers via Speculative Decoding. https://arxiv.org/abs/2211.17192
- ↑ Kwon, W. et al. (2023). Efficient Memory Management for LLM Serving with PagedAttention (vLLM). https://arxiv.org/abs/2309.06180
- ↑ vLLM Docs (2024–2025). Continuous batching, Chunked prefill, Structured outputs. https://docs.vllm.ai/
- ↑ Brown, T. et al. (2020). Language Models are Few‑Shot Learners. https://arxiv.org/abs/2005.14165
- ↑ Ouyang, L. et al. (2022). InstructGPT (RLHF). https://arxiv.org/abs/2203.02155
- ↑ Rafailov, R. et al. (2023). Direct Preference Optimization. https://arxiv.org/abs/2305.18290
- ↑ Shazeer, 2019. https://arxiv.org/abs/1911.02150
- ↑ Ainslie, 2023. https://arxiv.org/abs/2305.13245
- ↑ Leviathan, 2023. https://arxiv.org/abs/2211.17192
- ↑ Kwon, 2023. https://arxiv.org/abs/2309.06180
- ↑ vLLM Docs. https://docs.vllm.ai/
- ↑ OpenAI (2024). Structured Outputs. https://openai.com/index/introducing-structured-outputs-in-the-api/
- ↑ vLLM Docs — Structured outputs. https://docs.vllm.ai/en/v0.9.2/features/structured_outputs.html
- ↑ Kwon, 2023. https://arxiv.org/abs/2309.06180
- ↑ Brown, T. et al. (2020). Language Models are Few‑Shot Learners. https://arxiv.org/abs/2005.14165
- ↑ Touvron, H. et al. (2023). LLaMA: Open and Efficient Foundation Language Models. https://arxiv.org/abs/2302.13971
- ↑ Achiam, J. et al. (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
- ↑ Meta AI (2024). Introducing Meta Llama 3. https://ai.meta.com/blog/meta-llama-3/
- ↑ 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
- ↑ Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text‑to‑Text Transformer. JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
- ↑ Lewis, M. et al. (2019). BART: Denoising Sequence‑to‑Sequence Pre‑training for NLG, Translation, and Comprehension. https://arxiv.org/abs/1910.13461
- ↑ Chung, H. W. et al. (2022). Scaling Instruction‑Finetuned Language Models (FLAN‑T5). https://arxiv.org/abs/2210.11416
- ↑ Shazeer, N. (2020). GLU Variants Improve Transformer. https://arxiv.org/abs/2002.05202
- ↑ Devlin, J. et al. (2019). BERT: Pre‑training of Deep Bidirectional Transformers for Language Understanding. https://arxiv.org/abs/1810.04805
- ↑ Brown, T. et al. (2020). Language Models are Few‑Shot Learners. https://arxiv.org/abs/2005.14165
- ↑ Touvron, H. et al. (2023). LLaMA: Open and Efficient Foundation Language Models. https://arxiv.org/abs/2302.13971
- ↑ Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
- ↑ Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. https://arxiv.org/abs/2001.08361
- ↑ Hoffmann, J. et al. (2022). Training Compute‑Optimal Large Language Models. https://arxiv.org/abs/2203.15556
- ↑ Chen, S. et al. (2023). Extending Context Window via Positional Interpolation. https://arxiv.org/abs/2306.15595
- ↑ Peng, B. et al. (2023). YaRN: Efficient Context Window Extension of LLMs. https://arxiv.org/abs/2309.00071
- ↑ 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). Fast Transformer Decoding: One Write‑Head is All You Need. https://arxiv.org/abs/1911.02150
- ↑ Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
- ↑ Kwon, W. et al. (2023). Efficient Memory Management for LLM Serving with PagedAttention. https://arxiv.org/abs/2309.06180
- ↑ Leviathan, Y. et al. (2023). Fast Inference from Transformers via Speculative Decoding. https://arxiv.org/abs/2211.17192
- ↑ 50.0 50.1 50.2 Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
- ↑ 51.0 51.1 51.2 Du, N. et al. (2021). GLaM: Efficient Scaling of Language Models with Mixture‑of‑Experts. https://arxiv.org/pdf/2112.06905.pdf
- ↑ Mistral AI (2023). Mixtral of Experts. https://mistral.ai/news/mixtral-of-experts/
- ↑ Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
- ↑ Mistral AI (2024). Mixtral 8x22B. https://mistral.ai/news/mixtral-8x22b
- ↑ 55.0 55.1 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). Mixture‑of‑Experts with Expert Choice Routing. https://arxiv.org/abs/2202.09368
- ↑ Komatsuzaki, A. et al. (2022). Sparse Upcycling: Training Mixture‑of‑Experts from Dense Checkpoints. https://arxiv.org/abs/2212.05055
- ↑ 59.0 59.1 59.2 59.3 Lewis, P. et al. (2020). Retrieval‑Augmented Generation for Knowledge‑Intensive NLP Tasks. https://arxiv.org/abs/2005.11401
- ↑ NVIDIA Blog (2025). What is Retrieval‑Augmented Generation (RAG). https://blogs.nvidia.com/blog/what-is-retrieval-augmented-generation/
- ↑ Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
- ↑ Zaheer, M. et al. (2020). Big Bird. https://arxiv.org/abs/2007.14062
- ↑ Dao, T. et al. (2022). FlashAttention. https://arxiv.org/abs/2205.14135
- ↑ Dao, T. et al. (2023). FlashAttention‑2. https://arxiv.org/abs/2307.08691
- ↑ Shah, M. et al. (2024). FlashAttention‑3. https://arxiv.org/abs/2407.08608
- ↑ Shazeer, N. (2019). Fast Transformer Decoding: One Write‑Head is All You Need. https://arxiv.org/abs/1911.02150
- ↑ Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
- ↑ Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
- ↑ Su, J. et al. (2021). RoFormer: Rotary Position Embedding. https://arxiv.org/abs/2104.09864
- ↑ Touvron, H. et al. (2023). LLaMA: Open and Efficient Foundation Language Models. https://arxiv.org/abs/2302.13971
- ↑ Chen, S. et al. (2023). Extending Context Window via Positional Interpolation. https://arxiv.org/abs/2306.15595
- ↑ Peng, B. et al. (2023). YaRN: Efficient Context Window Extension of LLMs. https://arxiv.org/abs/2309.00071
- ↑ Dai, Z. et al. (2019). Transformer‑XL: Attentive Language Models Beyond a Fixed‑Length Context. https://arxiv.org/abs/1901.02860
- ↑ Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer: The Efficient Transformer. https://arxiv.org/abs/2001.04451
- ↑ Choromanski, K. et al. (2021). Rethinking Attention with Performers. https://arxiv.org/abs/2009.14794
- ↑ Wang, S. et al. (2020). Linformer: Self‑Attention with Linear Complexity. https://arxiv.org/abs/2006.04768
- ↑ Dettmers, T. et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. https://arxiv.org/abs/2305.14314
- ↑ Hinton, G. et al. (2015). Distilling the Knowledge in a Neural Network. https://arxiv.org/abs/1503.02531
- ↑ Sanh, V. et al. (2019). DistilBERT. https://arxiv.org/abs/1910.01108
- ↑ Rajbhandari, S. et al. (2020). ZeRO: Memory Optimizations Toward Training Trillion‑Parameter Models. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
- ↑ Shoeybi, M. et al. (2019). Megatron‑LM: Training Multi‑Billion Parameter Language Models Using Model Parallelism. https://arxiv.org/abs/1909.08053
- ↑ Hugging Face. Transformers Documentation. https://huggingface.co/docs/transformers
- ↑ Hugging Face. Accelerate Documentation. https://huggingface.co/docs/accelerate
- ↑ Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. https://arxiv.org/abs/2001.08361
- ↑ Hoffmann, J. et al. (2022). Training Compute‑Optimal Large Language Models. https://arxiv.org/abs/2203.15556
- ↑ 86.0 86.1 86.2 86.3 86.4 Gu, A.; Goel, K.; Ré, C. (2021). Efficiently Modeling Long Sequences with Structured State Spaces (S4). https://arxiv.org/abs/2111.00396
- ↑ 87.0 87.1 87.2 87.3 87.4 Gu, A.; Dao, T. (2023/2024). Mamba: Linear‑Time Sequence Modeling with Selective State Spaces. https://arxiv.org/abs/2312.00752
- ↑ 88.0 88.1 88.2 Sun, Y. et al. (2023). Retentive Network: A Successor to Transformer for Large Language Models. https://arxiv.org/abs/2307.08621
- ↑ 89.0 89.1 89.2 89.3 Lieber, O. et al. (2024). Jamba: A Hybrid Transformer‑Mamba Language Model. https://arxiv.org/abs/2403.19887
- ↑ Radford, A. et al. (2018). Improving Language Understanding by Generative Pre‑Training. https://cdn.openai.com/research-covers/language-unsupervised/language_understanding_paper.pdf
- ↑ Devlin, J. et al. (2019). BERT: Pre‑training of Deep Bidirectional Transformers for Language Understanding. https://arxiv.org/abs/1810.04805
- ↑ Dai, Z. et al. (2019). Transformer‑XL. https://arxiv.org/abs/1901.02860
- ↑ Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf
- ↑ Lewis, M. et al. (2019). BART. https://arxiv.org/abs/1910.13461
- ↑ Raffel, C. et al. (2020). T5. https://jmlr.org/papers/volume21/20-074/20-074.pdf
- ↑ Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
- ↑ Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
- ↑ Brown, T. et al. (2020). Language Models are Few‑Shot Learners. https://arxiv.org/abs/2005.14165
- ↑ Su, J. et al. (2021). RoPE. https://arxiv.org/abs/2104.09864
- ↑ Press, O. et al. (2021/2022). ALiBi. https://arxiv.org/abs/2108.12409
- ↑ Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
- ↑ Du, N. et al. (2021). GLaM. https://arxiv.org/pdf/2112.06905.pdf
- ↑ Hoffmann, J. et al. (2022). Chinchilla. https://arxiv.org/abs/2203.15556
- ↑ Chowdhery, A. et al. (2022). PaLM. https://arxiv.org/abs/2204.02311
- ↑ Shazeer, N. (2019). Fast Transformer Decoding. https://arxiv.org/abs/1911.02150
- ↑ Dao, T. et al. (2022). FlashAttention. https://arxiv.org/abs/2205.14135
- ↑ Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
- ↑ Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
- ↑ Shazeer, N. (2020). GLU Variants. https://arxiv.org/abs/2002.05202
- ↑ 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
- ↑ Kwon, W. et al. (2023). vLLM/PagedAttention. https://arxiv.org/abs/2309.06180
- ↑ OpenAI (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
- ↑ Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
- ↑ Gu, A.; Dao, T. (2023). Mamba. https://arxiv.org/abs/2312.00752
- ↑ Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
- ↑ Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
- ↑ Mistral AI (2024). Mixtral 8x22B. https://mistral.ai/news/mixtral-8x22b
- ↑ Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
- ↑ Lieber, O. et al. (2024). Jamba. https://arxiv.org/abs/2403.19887
- ↑ Shah, M. et al. (2024). FlashAttention‑3. https://arxiv.org/abs/2407.08608