Membuat Inference Murah: KV cache, Batching, dan Kuantisasi

Untuk menghasilkan sebuah token, decoder-only transformer mengambil seluruh sequence sejauh ini, menjalankannya melalui setiap layer, lalu membaca distribusi probabilitas dari posisi terakhir. Kemudian ia menambahkan token yang dipilih dan melakukannya lagi. Deskripsi itu benar, dan itulah yang dilakukan run lambat.

Itu juga sangat boros, dan penyebabnya adalah causal mask dari Bab 9. Vektor key dan value posisi 7 dihitung dari input posisi 7 dan posisi-posisi sebelumnya. Saat posisi 8 datang, posisi 7 tidak bisa melihatnya — itulah arti causal — jadi key dan value posisi 7 adalah angka yang persis sama seperti sebelumnya. Run lambat tetap menghitung ulang semuanya, di setiap langkah.

Jadi simpan saja. Penyimpanan itu adalah key-value cache, optimisasi paling konsekuensial dalam serving model bahasa:

out = model(prompt_ids, use_cache=True)          # prefill: the whole prompt
past = out.past_key_values                        
nxt = out.logits[:, -1].argmax(-1, keepdim=True)

for _ in range(n - 1):
    out = model(nxt, past_key_values=past, use_cache=True)   
    past = out.past_key_values                                
    nxt = out.logits[:, -1].argmax(-1, keepdim=True)

Lihat apa yang diberikan ke model di dalam loop: nxt, satu token. Bukan sequence. Query token baru melakukan attention terhadap setiap key yang sudah di-cache, dan key yang di-cache itu memang tidak akan pernah berubah. Ini bukan aproksimasi — pemeriksaan output identik di atas adalah intinya. Cache tidak menukar kualitas dengan kecepatan; ia menghapus aritmetika redundan.

Untuk melihat scaling dengan bersih, singkirkan transformer dan ukur waktu satu attention head dengan $d = 64$, satu langkah generation dihitung dengan dua cara:

Kolom kanan adalah penyebabnya. Menghitung ulang membangun matriks attention $n \times n$ penuh di setiap langkah — $O(n^2)$ dari kotak notasi asimtotik Bab 9, dibayar sekali per token. Dengan cache kamu hanya membangun satu baris $1 \times n$: pada 4.096 token, 67 MB skor dibanding 16 KB.

Menghitung multiply-accumulates alih-alih milidetik mengeluarkan mesin dari argumen. Untuk menghasilkan $T$ token dari cold start:

Per langkah, versi dengan cache linear terhadap context dan versi tanpa cache kuadratik; dijumlahkan selama sebuah generation, $O(T^2)$ melawan $O(T^3)$, dengan rasio yang tumbuh tanpa batas. Selisih sembilan kali pada pembuka diukur atas 48 token — lebih pendek dari baris pertama tabel itu.

Cache juga mengubah apa yang harus ada di memori. Pada GPU laptop 8 GB yang menghasilkan 256 token dalam fp16, mengambil puncak allocator lalu mengurangkan bobot resident:

Memori 8,3 kali lebih besar, dihabiskan untuk menghasilkan token yang sama dengan lebih lambat. Inilah janji yang dibuat di Bab 5, datang dari arah yang tak terduga: di sana, reverse-mode autodiff harus mempertahankan setiap intermediate untuk backward pass, dan activation mendominasi memori training. Pada inference tidak ada backward pass dan tidak ada yang harus dipertahankan untuk itu — jadi yang mendominasi memori adalah cache, dan itu pilihan sengaja, bukan biaya yang tak terhindarkan.

Lihat lagi run cepat: token pertamanya berperilaku berbeda dari empat puluh tujuh token lainnya.

prefill, 40 prompt tokens : 1.0224 s   ->  25.6 ms per token
decode,  47 steps         : 0.1665 s mean per step

Prompt memakan biaya 25,6 ms per token dan setiap token yang dihasilkan memakan biaya 166 ms. Model yang sama, hardware yang sama, bobot yang sama, perbedaan enam kali per token — dan arahnya berlawanan dengan dugaan kebanyakan orang. Prompt adalah bagian yang murah. Generation terbagi menjadi dua fase dengan fisika yang benar-benar berbeda:

Kedua bagian bisa diukur. Prefill, satu pass atas $P$ token:

Decode, satu token terhadap cache sebesar $C$:

Baca tabel kedua dua kali. Berpindah dari context 16 token ke 1.024 — riwayat enam puluh empat kali lebih banyak untuk di-attend — tidak mengubah biaya satu langkah secara terukur. Attention terhadap cache adalah pekerjaan nyata, tetapi ia tertutup oleh biaya tetap menyeret setengah miliar bobot melalui bus memori untuk menghasilkan satu vektor. Biaya tetap itulah alasan semua hal di bagian berikutnya.

Dua fase ini adalah asal dari dua angka yang dilaporkan setiap sistem serving. Time to first token pada dasarnya adalah prefill, dan ia tumbuh bersama prompt, sehingga percakapan panjang terasa lambat untuk mulai. Tokens per second adalah $1/\text{decode step}$, dan kira-kira konstan, sehingga balasan kemudian mengalir merata. Chat yang mulai lambat lalu streaming mulus bukan trik rendering. Itu adalah dua tabel ini.

Cache menukar aritmetika dengan memori, dan memori yang ia minta tidak kecil. Untuk setiap token dalam context, setiap layer menyimpan satu vektor key dan satu vektor value per key-value head:

Angka 2 adalah untuk key dan value; sisanya adalah arsitektur. Untuk model yang diukur sepanjang bab ini — 24 layer, 14 query head, 2 key-value head, head dimension 64 — dalam fp16 itu adalah $2 \times 24 \times 2 \times 64 \times 2 = 12{,}288$ byte per token.

Formula di bidang ini punya kebiasaan meleset faktor dua, jadi cek terhadap allocator alih-alih mempercayainya:

KV cache tensors per layer: (1, 2, 295, 64) float16
measured: 3,624,960 bytes for 295 tokens = 12,288 bytes/token
formula : 2 * 24 * 2 * 64 * 2                = 12,288 bytes/token

Tepat, dan tetap tepat di setiap bentuk yang dicoba:

Tiga baris terakhir pantas dilihat lagi. Tiga puluh dua user dengan masing-masing 2.048 token, enam puluh empat dengan 1.024, seratus dua puluh delapan dengan 512 — cache-nya 768 MB di setiap kasus, karena ketiganya menahan 65.536 token. Cache hanya bergantung pada jumlah total token resident, bukan pada bagaimana token itu dibagi di antara user. Fakta itu adalah fondasi bagian batching.

Bab 9 memperkenalkan multi-query dan grouped-query attention lalu menunda alasannya ke bab ini. Alasannya adalah formula itu, khususnya $H_{kv}$ di dalamnya.

Standard multi-head attention memberi setiap query head key dan value head-nya sendiri. Model di sini punya 14 query head; dengan full multi-head attention, cache-nya akan menjadi $2 \times 24 \times 14 \times 64 \times 2 = 86{,}016$ byte per token — 84 KB alih-alih 12 KB, persis tujuh kali lebih besar, rasio query head terhadap key-value head.

Multi-query attention¹ membawa ini ke batasnya: semua query head berbagi satu key-value head. Grouped-query attention² adalah kompromi yang menang — beberapa key-value head, masing-masing dibagi oleh sekelompok query head — karena penurunan kualitas MQA nyata dan GQA tidak. Keduanya tidak membeli aritmetika apa pun. Mereka ada untuk membagi formula itu dengan bilangan bulat, dan menyebar ke seluruh industri begitu long context menjadikan cache sebagai kendala pengikat.

Dan itu terjadi cepat. Untuk model kelas 7B dengan 32 layer dan 8 key-value head berdimensi 128, cache-nya 128 KB per token dalam fp16:

Bobot model itu sendiri 13,0 GB dalam fp16, angka di tabel akhir bab ini. Jadi pada context 128.000 token, cache satu user lebih besar daripada model. Inilah aritmetika yang Bab 16 ubah menjadi uang, dan inilah mengapa percakapan panjang bukan sekadar lambat — ia menempati irisan tetap dari sebuah mesin selama request masih hidup.

Decode bersifat memory-bound: bobot diseret melalui bus untuk menghasilkan satu token, dan unit aritmetika menganggur. Jadi masukkan lebih banyak pekerjaan dalam langkah yang sama. Jalankan beberapa request sekaligus, dan bobot, yang dibaca sekali, melayani semuanya. Diukur pada model yang sama, tiap request menahan cache 64-token dan mendecode satu token:

Baca dua kolom kanan bersama-sama, karena itulah seluruh intinya. Berpindah dari satu request ke enam belas mengalikan throughput dengan 6,0 dan mengalikan waktu tunggu request individual mana pun dengan 2,67. Batch membuat server lebih baik dan setiap user lebih buruk.

Itu bukan bug yang bisa dituning hilang; itulah trade-off-nya sendiri, dan punya nama di masing-masing sisi. Latensi adalah yang dialami seseorang yang menunggu balasan. Throughput adalah pembagi invoice. Tidak ada setting yang memperbaiki keduanya.

Perhatikan juga di mana ia berhenti. Dari 16 ke 32, throughput naik 9 % sementara latensi hampir dua kali lipat: langkahnya berhenti memory-bound dan menjadi compute-bound, dan setelah titik lutut itu batch tidak membeli apa-apa. Setiap deployment punya lutut seperti itu; lokasinya harus diukur pada milikmu, tetapi keberadaannya tidak.

Cara naif untuk batching adalah mengumpulkan $B$ request, menjalankannya bersama, dan mengembalikan saat semuanya selesai. Tetapi mereka tidak selesai bersama: sebagian balasan dua puluh token dan sebagian lima ratus. Batch tetap berjalan sampai anggota terpanjangnya selesai, dan setiap request yang sudah selesai tetap menempati slotnya, menyumbang padding, sampai saat itu.

Ambil 64 request dengan skew panjang output yang realistis — median 18 token, terpanjang 231, total 1.874 — dan simulasikan kedua kebijakan pada biaya per langkah terukur untuk delapan slot:

Throughput meningkat 1,6x. Latensi rata-rata meningkat lebih dari sepuluh kali, karena dalam static batching request yang selesai dalam empat langkah tetap menunggu tetangga 231-token sebelum siapa pun mendengarnya.

Continuous batching³ adalah perbaikannya, dan sesederhana kedengarannya: batch bukan sebuah grup, melainkan sekumpulan slot, dan slot yang kosong menerima request antrean berikutnya pada langkah berikutnya juga. Scheduler bekerja pada granularitas satu token, bukan satu request. Setiap stack serving di production sekarang melakukan ini.

Ia punya separuh kedua, yaitu cache. Slot yang datang dan pergi meninggalkan memori cache terfragmentasi, dan mencadangkan setiap slot untuk context maksimum yang mungkin menyia-nyiakan sebagian besar reservasi. PagedAttention⁴ meminjam jawaban dari operating system: simpan cache dalam blok berukuran tetap dengan tabel blok per sequence, sehingga cache sebuah sequence bisa tersebar secara fisik sambil tetap kontigu secara logis — yang juga memungkinkan dua sequence dengan prefix bersama berbagi blok yang menahannya. Itulah fondasi vLLM, dan mengapa serving engine adalah memory allocator dengan transformer terpasang.

Separuh lain tagihannya adalah bobot itu sendiri. Setengah miliar parameter pada empat byte masing-masing adalah 1,98 GB; pada dua byte, 0,99 GB; pada satu byte, 0,49 GB. Bit per bobot yang lebih sedikit mengecilkan model di disk, mengecilkannya di memori, dan — karena decode bersifat bandwidth-bound — membuat setiap langkah lebih cepat, karena byte yang dipindahkan lebih sedikit.

Skema paling sederhana adalah kuantisasi symmetric absolute-maximum, dan ia muat dalam tiga baris:

qmax  = 2 ** (bits - 1) - 1
scale = W.abs().max() / qmax                        
Wq    = torch.round(W / scale).clamp(-qmax - 1, qmax)
W_hat = Wq * scale                                  # dequantized

Pilih scale agar bobot terbesar memetakan ke integer terbesar, bagi, bulatkan, simpan integer dan scale. Rekonstruksi dengan mengalikan kembali. Tidak ada yang pintar di dalamnya, dan ia bekerja — sampai tiba-tiba tidak.

Diukur pada bobot nyata model: seluruh 168 matriks proyeksi, 357,8 juta parameter, relative error $\lVert W - \hat{W}\rVert / \lVert W \rVert$:

Baris keempat adalah runtuhnya. Relative error 0,99 pada matriks terburuk berarti rekonstruksi pada dasarnya tidak mempertahankan apa pun dari yang asli — matriks telah diganti oleh noise dengan besar kira-kira benar. Penyebabnya terlihat dalam eksperimen yang sama pada satu matriks:

model.layers.12.mlp.down_proj.weight   (896 x 4864)
mean |w| 0.01386   std 0.01822   max |w| 0.43945   max/std 24.1
weights beyond 6 sigma: 692 of 4,358,144   (0.016 %)

Satu bobot dari enam ribu berada melewati enam standar deviasi, dan yang terbesar 24 jauhnya. Dengan satu scale untuk seluruh matriks, satu bobot itu menetapkan ukuran langkah untuk semua 4,3 juta bobot. Pada 8 bit ada 256 langkah dan bobot tipikal masih mendarat pada langkah yang bermakna. Pada 4 bit hanya ada 16, yang terluar dicadangkan untuk nilai yang hampir tidak dimiliki siapa pun, dan bobot biasa — yaitu semuanya — dibulatkan ke dua atau tiga level berbeda.

Semua setelah baris itu adalah perbaikan yang sama pada granularitas berbeda: beri scale wilayah yang lebih kecil. Per baris output membagi error dengan 3,4; per grup 128 bobot berurutan membaginya lagi. Biayanya adalah pembukuan — scale 16-bit per grup 128 adalah $4 + 16/128 = 4.125$ bit per bobot, bukan 4 — dan itu membeli kembali sebagian besar jarak.

NF4 menyerangnya dari sisi lain.⁵ Level tidak harus berjarak sama. Bobot dalam satu blok kira-kira terdistribusi normal, jadi pilih enam belas level sebagai kuantil distribusi normal: rapat di dekat nol tempat bobot memang berada, jarang di ekor tempat bobot tidak berada. Empat bit yang sama, block scaling yang sama, pada blok yang lebih kecil — 4,25 bit per bobot melawan 4,125 milik group-128 — dan error terukur turun dari 0,1323 menjadi 0,0952, 28 % lebih rendah. Sebagian karena blok yang lebih halus dan sisanya karena menaruh level di tempat massanya berada, dan memisahkan keduanya akan butuh baris ketiga.

Kotak floating-point Bab 2 berakhir dengan janji: bahwa bab ini akan mengkuantisasi bobot ke 8 dan 4 bit dan menemukan segelintir outlier features yang menolak diperas. Inilah mereka, dan mereka menjelaskan mengapa “cukup bulatkan angkanya” tidak pernah akan berhasil pada activation.

Bobot di atas berperilaku buruk. Activation berada di liga berbeda. Ambil prompt biasa berisi 84 token, tangkap residual stream pada setiap layer, dan ukur magnitudo terbesar yang dicapai masing-masing dari 896 dimensi:

Dimensi 62 mencapai 1.579,6 sementara dimensi median tidak pernah melebihi 1,6. Ini bukan kebetulan satu token atau satu layer: dimensi yang sama ada di layer 4 dan masih ada di layer 20, dengan nilai hampir sama. Inilah outlier features,⁶ dan mereka sistematis — properti model yang sudah trained, bukan input.

Histogram dari 896 maksimum per dimensi itu pada layer 16 membuat bentuknya tidak salah lagi:

     0 -      1 | ######################################## 254
     1 -      2 | ######################################## 283
     2 -      4 | ######################################## 226
     4 -      8 | ######################################## 93
     8 -     16 | ##################                       18
    16 -     32 | #########                                9
    32 -     64 | #######                                  7
    64 -    128 | #####                                    5
   128 -    256 |                                          0
   256 -    512 |                                          0
   512 -   1024 |                                          0
  1024 -   4096 | #                                        1

Sembilan ratus dimensi dalam tumpukan rapi di bawah 8, tidak ada sama sekali selama tiga oktaf, lalu satu dimensi sendirian di ujung jauh. Sekarang kuantisasi tensor itu ke INT8 dan hitung apa yang terjadi:

Empat belas level dari 256. Scale ditetapkan oleh 1.579,6, sehingga setiap langkah lebarnya 12,44, dan activation tipikal — magnitudo median 0,26, persentil kesembilan puluh sembilan 2,51 — tidak punya tempat untuk mendarat. Per dimensi, ini lebih mencolok:

single tensor-wide scale = 12.4378
  dim 826 (max |h| = 4.77):  1 distinct level out of 256
  dim 336 (max |h| = 1.62):  1 distinct level out of 256
  dim  96 (max |h| = 0.69):  1 distinct level out of 256

after excluding the top 4 dimensions, scale = 0.5749  (22x smaller)
  dim 826: 8 levels    dim 336: 4 levels    dim  96: 3 levels

Satu level. Seluruh dimensi, setiap token, terkuantisasi ke angka yang sama. Delapan bit dialokasikan dan kira-kira nol digunakan, dan model yang membaca activation itu diberi konstanta.

Pengukuran itu adalah justifikasi untuk setiap teknik yang benar-benar dipakai orang:

Hampir setiap artikel tentang kuantisasi berhenti di bagian sebelumnya: menjelaskan metode, mengutip rasio kompresi, dan menyatakan bahwa kualitas “sebagian besar terjaga”. Bab 4 membahas cara tidak menipu diri sendiri, jadi mari kita cari tahu.

Model yang sama, bobot dikuantisasi in place dengan tiap skema, lalu tiga pengukuran: perplexity pada 2.048 token prosa Inggris held-out — di sini, draf kursus ini, itulah mengapa repository mengganti dengan buku public-domain tetap dan mencetak tabel dengan bentuk sama tetapi angka berbeda — serangkaian 16 pertanyaan faktual pendek dengan jawaban diketahui di bawah greedy decoding, dan fraksi token ketika model terkuantisasi setuju dengan model full-precision pada context identik.

Empat hal dalam tabel itu layak dinyatakan terang-terangan.

INT8 yang dilakukan dengan benar itu gratis. INT8 per baris mencetak 22,96 melawan 23,08 referensi — jarak satu bagian dari dua ratus, yaitu noise dan sebaiknya dibaca sebagai “identik”. Arah noise tidak stabil: pada corpus public-domain repository, dua skema yang sama keluar 22,24 melawan 22,18: separuh jarak itu, dan mengarah sebaliknya. Ia setuju dengan model full-precision pada 142 dari 144 token yang dihasilkan. Seperempat memori dibanding referensi fp32, separuh dibanding fp16 yang benar-benar akan kamu deploy, dan tanpa biaya terdeteksi. INT8 yang dilakukan sembarangan juga hampir gratis: satu scale per matriks memakan 0,5 poin perplexity dan tidak kehilangan jawaban baterai. Delapan bit cukup pemaaf sehingga granularitas hampir tidak penting, tepat mengapa orang menggeneralisasi dari INT8 ke INT4 dan terluka.

INT4 dengan satu scale per tensor menghancurkan model. Perplexity 365 juta: bukan menurun, melainkan musnah. Granularitas lalu menjadi seluruh permainan — per-tensor 365.416.000, per-baris 46,18, per-group-of-128 31,08, NF4 24,55. Empat bit yang sama per bobot, selisih faktor lima belas juta antara terburuk dan terbaik.

Perplexity adalah instrumen kasar dan baterai lebih kasar lagi. Antara NF4 dan group-128 INT4, gap perplexity adalah 6,5 poin dan baterai berbeda satu pertanyaan — dan confidence interval Bab 4 mengatakan satu pertanyaan dari enam belas tidak membedakan apa pun. Ada demonstrasi yang lebih tajam daripada interval: jalankan baterai yang sama dengan repetition penalty bawaan model dimatikan, yang memang arti greedy decoding, dan dua baris itu bertukar tempat. Satu pertanyaan dari enam belas bukan efek kecil, melainkan tidak ada efek. Peringatan Bab 8 juga berlaku: perplexity hanya bisa dibandingkan antara model yang berbagi tokenizer, jadi angka dari tulisan orang lain tidak bisa dibandingkan dengan milikmu.

Kolom agreement adalah yang paling tajam dari ketiganya, dan hampir gratis: jalankan model full-precision secara greedy, lalu tanyakan model terkuantisasi, di setiap posisi, apa yang akan ia pilih dengan prefix yang sama. Ia punya 144 observasi independen alih-alih 16, tidak butuh ground truth, dan menurun halus ketika baterai menurun melompat-lompat. Ia juga persis kuantitas yang dibutuhkan bagian berikutnya.

Inilah janji yang dibuat Bab 1 tentang bab ini, tiba tepat waktu: matematika mengatakan model 4-bit mungkin, dan engineering memutuskan apakah ia usable.

Bab 12 mengumumkan ini dan meninggalkan tagihannya di sini.

Idenya langsung datang dari pemisahan prefill/decode. Memverifikasi sequence usulan berisi $\gamma$ token memakan biaya satu forward pass atas $\gamma$ posisi — produk matriks-matriks, hampir tidak lebih mahal daripada pass atas satu posisi. Jadi:

Distribusi output tidak berubah. Dengan greedy decoding itu jelas — token diterima hanya jika target akan menghasilkannya. Dengan sampling, ini membutuhkan aturan acceptance yang dimodifikasi, dan Leviathan et al. membuktikan distribusi hasilnya persis milik target.¹⁰ Ini adalah optimisasi eksak kedua dalam bab ini.

Maka semuanya bergantung pada acceptance rate $\alpha$, yang bisa diukur — ia adalah kolom agreement di atas, karena itu ia dihitung di sana. Menggunakan tiap model terkuantisasi sebagai draft untuk target full-precision, atas 144 posisi yang dihasilkan:

Token yang diharapkan diterima per verification pass, pada panjang draft $\gamma$, adalah

dan speedup bersih membaginya dengan biaya draft sendiri, fraksi $c$ dari target per token:

Entri tebal adalah yang harus diingat: speculative decoding bisa membuat generation lebih lambat. Pada acceptance 30 % dengan draft yang biayanya seperlima target, kamu membayar lima forward pass dan hanya menyimpan 1,4 token. Kolom terakhir adalah jebakan lain — draft yang lebih panjang hanya membantu saat acceptance tinggi, karena ekor tebakan $\gamma$-token hampir tidak pernah tercapai. Pada acceptance 90 %, $\gamma = 8$ bernilai 3,40x dan pada 30 % bernilai 0,79x: konfigurasi yang sama, menang atau kalah tergantung angka yang diukur pada traffic kamu.

Kuantisasi mengecilkan model dengan menyimpan fungsi yang sama dalam bit lebih sedikit. Distillation mengecilkannya dengan melatih model lebih kecil untuk meniru model lebih besar¹¹ — ide yang mendahului deep learning hampir satu dekade.¹²

Bagian halusnya adalah apa yang dipelajari student. Bukan jawaban benar: ia bisa saja dilatih langsung pada itu. Yang ditambahkan teacher adalah seluruh distribusi. Tanyakan model apa yang mengikuti sebuah frasa dan lihat melewati argmax:

"She poured the milk into the"
  ' jug' 0.1355   ' cup' 0.1051   ' bowl' 0.0605   ' large' 0.0380   ' milk' 0.0360

Hard label mengatakan jug dan tidak ada lagi. Soft label mengatakan jug, dan juga bahwa cup hampir sama bagusnya, bowl masuk akal, dan large — sebuah adjective, kelanjutan gramatikal yang sepenuhnya berbeda — masih hidup. Itulah argumen aslinya: ini adalah 7, tetapi cukup mirip dengan 1, dan kemiripan itu adalah informasi yang dibuang hard label.

Itulah juga mengapa distillation memakai temperature. Membagi logits dengan $T$ sebelum softmax meratakan distribusi dan menaikkan bobot relatif runner-up: pada frasa ini, rasio antara token teratas dan yang ketiga turun dari 2,24 pada $T = 1$ menjadi 1,50 pada $T = 2$ — akar kuadrat dari yang pertama, yang memang terjadi saat membagi logits dengan dua terhadap sebuah rasio. Urutan sama, lebih banyak attention loss pada near miss. Gradient student membawa ketidakpastian teacher dan bukan hanya vonisnya.

Semua dalam bab ini sekarang menjadi satu penjumlahan:

di mana $T$ adalah total token resident lintas semua request concurrent. Menerapkannya: baris 7B dan 70B mengasumsikan 8 key-value head berdimensi 128, baris 13B full multi-head attention dengan 40 head, seperti itulah generasi model itu dibangun — dan itu terlihat.

8 GB

16 GB

24 GB

Lihat baris 13B di tabel 8 GB. Bobotnya muat — 6,2 GB dari 8 — jadi dengan cara bicara biasa, model 13B “jalan di kartu 8 GB”. Ia punya 337 token context, yang bukan percakapan melainkan nyaris hanya prompt. “Apakah muat” adalah pertanyaan yang salah. Yang benar adalah “dengan berapa banyak context, dan untuk berapa user sekaligus”.

Lihat juga dua baris int8 16 GB. 7B mendapat 65.378 token dan 13B mendapat 3.136 — selisih dua puluh kali dari bobot ekstra 5,6 GB, karena 13B di sini punya multi-head attention dan cache-nya berbiaya 800 KB per token melawan 128 KB milik 7B. Dua model dengan ukuran mirip, satu tidak usable untuk long context, karena alasan yang tidak muncul di headline model card mana pun.

Tiga belas bab lalu ini adalah perceptron dengan dua bobot dan satu bias. Sekarang ia adalah transformer yang sudah dirancang, dilatih, di-align, diajari menghabiskan compute pada pertanyaan sulit, dan disajikan dengan biaya terukur per token — tanpa kotak yang tersisa belum dibuka.

Itu berakhir di sini, dan berakhir dengan sengaja.

Bab 14 dimulai dengan model berada di tempat lain. Bukan dalam prosesmu, bukan dalam memorimu, bukan dalam variabel yang bisa kamu print: pada mesin yang tidak kamu administrasikan, di balik API key, port, dan tagihan. Semua yang diukur di sini masih terjadi — prefill masih berjalan sebelum token pertama, cache masih tumbuh bersama percakapan, batch tempat kamu berada masih milik orang lain dan masih menentukan latensimu — tetapi mulai sekarang kamu mengamatinya melalui stream Server-Sent Events, sebuah finish_reason, dan HTTP 429 dengan header Retry-After. Pertanyaannya berubah bersama sudut pandang: bukan bagaimana gradient ini dihitung melainkan mengapa invoice-ku tiga kali lipat. Bahasanya juga berubah, dan Bab 14 menjelaskan aturan itu alih-alih sekadar mengumumkannya — sampai sini kode memegang bobot, gradient, logits, dan byte tokenizer; dari sana seterusnya ia memegang koneksi, retry, cancellation, dan state terakumulasi. Tiga belas bab di belakangmu tidak dibuang oleh penyeberangan itu. Mereka adalah deskripsi tentang apa yang berjalan di sisi lain port.

Dua penghilangan disengaja. FlashAttention (Dao et al., arXiv:2205.14135) bukan attention yang berbeda — ia menghitung fungsi yang sama dengan melakukan tiling operasi sehingga matriks skor $n \times n$ tidak pernah ditulis ke memori, itulah mengapa 67 MB pada tabel kedua bab ini lebih kecil dalam praktik daripada yang disiratkan aritmetika. Dan kernel itu sendiri didelegasikan: kuliah 10 Stanford CS336 membahas inference systems sedalam yang tidak dicoba di sini, dan repository llama.cpp serta spesifikasi GGUF adalah sumber utama untuk sisi CPU.