microgpt - Pelatihan dan inferensi GPT yang diimplementasikan dalam 200 baris Python murni

• Proyek seni yang dirilis oleh karpathy. Mengimplementasikan seluruh algoritme GPT dalam satu file 200 baris tanpa dependensi eksternal
• Perbedaannya dengan LLM produksi hanyalah pada skala dan efisiensi; inti dasarnya sama, dan memahami kode ini berarti memahami esensi algoritmis GPT
• Mencakup dataset, tokenizer, mesin autograd, arsitektur Transformer mirip GPT-2, optimizer Adam, hingga loop pelatihan dan inferensi
• Merupakan puncak dari upaya penyederhanaan LLM selama 10 tahun melalui proyek-proyek sebelumnya seperti micrograd, makemore, dan nanogpt, merangkum esensi GPT dalam bentuk minimum yang tak bisa disederhanakan lagi
• Dengan melatih pada 32.000 data nama, model ini menghasilkan nama baru yang terdengar masuk akal, dan seluruh perhitungannya dilakukan langsung dengan autograd tingkat skalar
• Proses pelatihan terdiri dari perhitungan loss → backpropagation → pembaruan Adam, dan dapat dijalankan dalam sekitar 1 menit

---

Gambaran umum microgpt

• microgpt adalah skrip Python 200 baris yang mengimplementasikan proses pelatihan dan inferensi model GPT secara lengkap
  • Tanpa library eksternal, sudah mencakup dataset, tokenizer, autograd, model, optimizer, loop pelatihan
• Menggabungkan proyek-proyek sebelumnya seperti micrograd, makemore, dan nanogpt ke dalam satu file
• Implementasi yang hanya menyisakan inti algoritmis pada tingkat “tidak bisa disederhanakan lagi”
• Seluruh kode tersedia di GitHub Gist, halaman web, dan Google Colab

Susunan dataset

• Bahan bakar model bahasa skala besar adalah aliran data teks; dalam produksi biasanya memakai halaman web internet, tetapi microgpt menggunakan contoh sederhana berupa 32.000 nama yang ditulis satu per baris
• Setiap nama diperlakukan sebagai satu "dokumen", dan tujuan model adalah mempelajari pola statistik dalam data untuk menghasilkan dokumen baru yang serupa
• Setelah pelatihan selesai, model akan "berhalusinasi(hallucinate)" nama baru yang masuk akal seperti "kamon", "karai", dan "vialan"
• Dari sudut pandang ChatGPT, percakapan dengan pengguna juga hanyalah "dokumen berbentuk aneh"; saat dokumen diinisialisasi dengan prompt, respons model merupakan bentuk penyelesaian dokumen secara statistik

Tokenizer

• Karena jaringan saraf bekerja dengan angka, bukan karakter, dibutuhkan cara untuk mengubah teks menjadi urutan ID token bilangan bulat dan memulihkannya kembali
• Tokenizer produksi seperti tiktoken (digunakan GPT-4) bekerja pada unit potongan karakter demi efisiensi, tetapi tokenizer paling sederhana adalah memberikan satu bilangan bulat untuk setiap karakter unik dalam dataset
• Huruf kecil a-z diurutkan lalu setiap karakter diberi ID berdasarkan indeksnya; nilai bilangan bulat itu sendiri tidak memiliki makna, dan setiap token adalah simbol diskret yang terpisah
• Ditambahkan token khusus BOS(Beginning of Sequence) untuk menandakan "dokumen baru dimulai/diakhiri", sehingga "emma" dibungkus sebagai [BOS, e, m, m, a, BOS]
• Ukuran kosakata akhir adalah 27 (26 huruf kecil + 1 BOS)

Diferensiasi otomatis(Autograd)

• Pelatihan jaringan saraf membutuhkan gradien: untuk setiap parameter, perlu diketahui "jika nilai ini dinaikkan sedikit, apakah loss naik atau turun, dan seberapa besar?"
• Graf komputasi memiliki banyak input (parameter model dan token input), tetapi semuanya bermuara pada satu output skalar yaitu loss
• Backpropagation dimulai dari output lalu menelusuri graf ke arah balik, mengandalkan aturan rantai dalam kalkulus untuk menghitung gradien loss terhadap semua input
• Diimplementasikan dengan kelas Value: setiap Value membungkus satu skalar (.data) dan melacak bagaimana ia dihitung
  • Saat operasi seperti penjumlahan atau perkalian dilakukan, Value baru menyimpan input (_children) dan turunan lokal(_local_grads) dari operasi tersebut
  • Contoh: __mul__ mencatat ∂(a·b)/∂a=b, ∂(a·b)/∂b=a
• Blok operasi yang didukung: penjumlahan, perkalian, perpangkatan, log, exp, ReLU
• Metode backward() menelusuri graf dalam urutan fase balik dan menerapkan aturan rantai di setiap langkah
  • Dimulai dari node loss dengan self.grad = 1 (∂L/∂L=1)
  • Gradien lokal dikalikan sepanjang jalur lalu dipropagasikan sampai ke parameter
• Diakumulasikan dengan += (bukan assignment): saat graf bercabang, gradien dari tiap cabang harus mengalir secara independen lalu dijumlahkan (hasil dari aturan rantai multivariabel)
• Secara algoritmis identik dengan .backward() milik PyTorch, tetapi bekerja pada tingkat skalar, bukan tensor, sehingga jauh lebih sederhana namun kurang efisien

Inisialisasi parameter

• Parameter adalah pengetahuan model: kumpulan besar angka floating-point yang dimulai secara acak lalu dioptimalkan berulang kali selama pelatihan
• Diinisialisasi dengan nilai acak kecil dari distribusi Gaussian
• Terdiri dari matriks-matriks bernama state_dict: tabel embedding, bobot attention, bobot MLP, proyeksi output akhir
• Pengaturan hyperparameter:
  • n_embd = 16: dimensi embedding
  • n_head = 4: jumlah head attention
  • n_layer = 1: jumlah layer
  • block_size = 16: panjang urutan maksimum
• Model kecil ini memiliki 4.192 parameter (GPT-2 memiliki 1,6 miliar, LLM modern memiliki ratusan miliar)

Arsitektur

• Arsitektur model adalah fungsi tanpa state: menerima token, posisi, parameter, serta key/value yang di-cache dari posisi sebelumnya, lalu mengembalikan logit (skor) untuk token berikutnya
• Mengikuti GPT-2 tetapi sedikit disederhanakan: RMSNorm (bukan LayerNorm), tanpa bias, ReLU (bukan GeLU)

• Fungsi helper

  • linear: perkalian matriks-vektor yang menghitung satu dot product untuk setiap baris matriks bobot, transformasi linear terlatih yang menjadi komponen dasar jaringan saraf
  • softmax: mengubah skor mentah (logit) menjadi distribusi probabilitas, semua nilai berada dalam rentang [0,1] dan totalnya menjadi 1, dengan mengurangkan nilai maksimum terlebih dahulu demi stabilitas numerik
  • rmsnorm: menyesuaikan ulang vektor agar memiliki root mean square satuan sehingga aktivasi tidak membesar atau mengecil saat melewati jaringan, menstabilkan pelatihan

• Struktur model

  • Embedding: ID token dan ID posisi masing-masing merujuk ke baris pada tabel embedding (wte, wpe), lalu kedua vektor dijumlahkan untuk mengodekan secara bersamaan apa token tersebut dan di mana posisinya dalam sekuens
    • LLM modern sering melewati embedding posisi dan memakai teknik penentuan posisi berbasis relatif seperti RoPE
  • Blok attention: memproyeksikan token saat ini menjadi tiga vektor Q (query), K (key), V (value)
    • Query: "apa yang saya cari?", key: "apa yang saya miliki?", value: "apa yang saya berikan jika dipilih?"
    • Contoh: saat huruf "m" kedua dalam "emma" memprediksi token berikutnya, ia bisa mempelajari query seperti "vokal apa yang baru saja muncul?", lalu huruf "e" sebelumnya cocok dengan query ini dan mendapat bobot attention tinggi
    • Key dan value ditambahkan ke KV cache sehingga posisi sebelumnya bisa dirujuk
    • Setiap head attention menghitung dot product antara query dan semua key yang di-cache (diskalakan dengan √d_head), memakai softmax untuk mendapatkan bobot attention, lalu menghitung penjumlahan berbobot dari value yang di-cache
    • Semua keluaran head digabungkan lalu diproyeksikan dengan attn_wo
    • Blok attention adalah satu-satunya tempat token di posisi t dapat "melihat" token masa lalu 0..t-1, attention adalah mekanisme komunikasi antar-token
  • Blok MLP: jaringan feedforward 2 lapis: diperluas menjadi 4x dimensi embedding → ReLU diterapkan → lalu diperkecil kembali
    • Tempat sebagian besar "pemikiran" per posisi terjadi
    • Tidak seperti attention, ini adalah komputasi lokal sepenuhnya pada waktu t
    • Transformer menyusun selang-seling komunikasi (attention) dan komputasi (MLP)
  • Koneksi residual: baik blok attention maupun MLP menambahkan kembali keluarannya ke input
    • Membiarkan gradien mengalir langsung melalui jaringan sehingga model yang dalam tetap bisa dilatih
  • Output: hidden state akhir diproyeksikan dengan lm_head ke ukuran kosakata untuk menghasilkan satu logit per token (di sini 27 angka), logit tinggi = token tersebut lebih mungkin muncul berikutnya
  • Keunikan KV cache: penggunaan KV cache selama pelatihan jarang dilakukan, tetapi karena microgpt hanya memproses satu token setiap kali, cache dibangun secara eksplisit; key dan value yang di-cache adalah node Value aktif dalam grafik komputasi yang menjadi target backpropagation

Loop pelatihan

• Loop pelatihan berulang kali melakukan: (1) memilih dokumen → (2) menjalankan forward model pada token → (3) menghitung loss → (4) memperoleh gradien lewat backpropagation → (5) memperbarui parameter

• Tokenisasi

  • Pada setiap step pelatihan, satu dokumen dipilih lalu dibungkus BOS di kedua sisi: "emma" → [BOS, e, m, m, a, BOS]
  • Tujuan model adalah memprediksi setiap token berikutnya berdasarkan token-token sebelumnya

• Forward pass dan loss

  • Token dimasukkan ke model satu per satu sambil membangun KV cache
  • Pada setiap posisi, model mengeluarkan 27 logit, lalu diubah menjadi probabilitas dengan softmax
  • Loss pada setiap posisi adalah log probabilitas negatif dari token berikutnya yang benar: −log p(target), ini disebut cross-entropy loss
  • Loss mengukur seberapa terkejut model terhadap apa yang benar-benar datang: jika memberi probabilitas 1.0 maka loss 0, jika probabilitas mendekati 0 maka loss +∞
  • Loss pada semua posisi dalam dokumen dirata-ratakan untuk memperoleh satu loss skalar

• Backward pass

  • Satu panggilan loss.backward() menjalankan backpropagation pada seluruh grafik komputasi
  • Setelah itu, .grad pada setiap parameter menunjukkan bagaimana parameter itu harus diubah untuk menurunkan loss

• Optimizer Adam

  • Alih-alih gradient descent sederhana (p.data -= lr * p.grad), digunakan Adam
  • Menyimpan dua moving average per parameter:
    • m: rata-rata gradien terbaru (momentum)
    • v: rata-rata kuadrat gradien terbaru (adaptasi learning rate per parameter)
  • m_hat, v_hat adalah koreksi bias untuk m dan v yang diinisialisasi dari 0
  • Learning rate menurun secara linear selama pelatihan
  • Setelah update, .grad = 0 untuk inisialisasi ulang

• Hasil pelatihan

  • Selama 1.000 step, loss turun dari sekitar 3,3 (tebakan acak dari 27 token: −log(1/27)≈3,3) menjadi sekitar 2,37
  • Semakin rendah semakin baik, dan nilai terendah adalah 0 (prediksi sempurna), jadi masih ada ruang perbaikan, tetapi jelas bahwa model sedang mempelajari pola statistik nama

Inferensi

• Setelah pelatihan selesai, model dapat mengambil sampel nama baru, dengan parameter dibekukan lalu forward pass dijalankan dalam loop, dan setiap token yang dihasilkan diumpankan kembali sebagai input berikutnya

• Proses sampling

  • Setiap sampel dimulai dengan token BOS ("mulai nama baru")
  • Model menghasilkan 27 logit → diubah menjadi probabilitas → lalu satu token diambil secara acak sesuai probabilitas tersebut
  • Token itu diumpankan kembali sebagai input berikutnya, diulangi sampai model kembali menghasilkan BOS ("selesai") atau panjang sekuens maksimum tercapai

• Temperature

  • Sebelum softmax, logit dibagi dengan temperature
  • Temperature 1.0: sampling langsung dari distribusi yang dipelajari model
  • Temperature rendah (mis. 0.5): membuat distribusi lebih tajam sehingga model cenderung lebih konservatif dan memilih opsi teratas
  • Temperature mendekati 0: selalu memilih satu token dengan probabilitas tertinggi (greedy decoding)
  • Temperature tinggi: membuat distribusi lebih datar sehingga output lebih beragam tetapi kurang konsisten

Cara menjalankan

• Hanya perlu Python (tanpa pip install, tanpa dependensi): python train.py
• Memakan waktu sekitar 1 menit di MacBook
• Menampilkan loss pada setiap step: dari ~3,3 (acak) turun menjadi ~2,37
• Setelah pelatihan selesai, menghasilkan nama baru hasil halusinasi: "kamon", "ann", "karai", dll.
• Bisa juga dijalankan di notebook Google Colab, dan bisa bertanya ke Gemini
• Coba dataset lain, tingkatkan num_steps untuk melatih lebih lama, dan perbesar model untuk hasil yang lebih baik

Tahapan perkembangan kode

File	Tambahan
train0.py	Tabel hitung bigram — tanpa jaringan saraf, tanpa gradien
train1.py	MLP + gradien manual (numerik & analitik) + SGD
train2.py	Autograd (kelas Value) — menggantikan gradien manual
train3.py	Embedding posisi + attention satu head + rmsnorm + residual
train4.py	Multi-head attention + loop layer — arsitektur GPT lengkap
train5.py	Optimizer Adam — inilah train.py

• Semua versi dan diff antar-step dapat dilihat di Revisions pada Gist build_microgpt.py

Perbedaan dengan LLM produksi

• microgpt mencakup esensi algoritmik yang lengkap dari pelatihan dan eksekusi GPT, dan perbedaannya dengan LLM produksi seperti ChatGPT tidak mengubah algoritme intinya, melainkan elemen-elemen yang membuatnya berjalan pada skala besar

• Data

  • Alih-alih 32K nama pendek, model dilatih dengan triliunan token teks internet (halaman web, buku, kode, dll.)
  • Deduplikasi data, penyaringan kualitas, dan pencampuran antardomain yang cermat

• Tokenizer

  • Menggunakan tokenizer subword seperti BPE (Byte Pair Encoding) alih-alih karakter tunggal
  • Menggabungkan urutan karakter yang sering muncul bersama menjadi satu token; kata umum seperti "the" menjadi satu token, sedangkan kata langka dipecah menjadi beberapa bagian
  • Kosakata ~100K token, melihat lebih banyak konten per posisi sehingga jauh lebih efisien

• Autograd

  • Alih-alih objek Value skalar dalam Python murni, digunakan tensor (array angka multidimensi besar) yang berjalan di GPU/TPU yang melakukan miliaran operasi floating point per detik
  • PyTorch menangani autograd untuk tensor, dan kernel CUDA seperti FlashAttention menggabungkan beberapa operasi
  • Matematikanya sama, hanya banyak skalar yang diproses secara paralel

• Arsitektur

  • microgpt: 4.192 parameter, model setara GPT-4: ratusan miliar
  • Secara umum tetap merupakan jaringan saraf Transformer yang sangat mirip, tetapi jauh lebih lebar (dimensi embedding 10.000+) dan jauh lebih dalam (100+ layer)
  • Jenis blok Lego tambahan dan perubahan urutan:
    • RoPE (rotary positional embeddings) — menggantikan positional embedding terlatih
    • GQA (grouped-query attention) — mengurangi ukuran cache KV
    • Gated linear activations — menggantikan ReLU
    • Layer MoE (mixture of experts)
  • Struktur inti dengan attention (komunikasi) dan MLP (komputasi) yang berselang-seling di atas residual stream tetap terjaga dengan baik

• Pelatihan

  • Alih-alih satu dokumen per langkah, digunakan batch besar (jutaan token per langkah), akumulasi gradien, mixed precision (float16/bfloat16), dan tuning hyperparameter yang cermat
  • Pelatihan model frontier dijalankan pada ribuan GPU selama berbulan-bulan

• Optimisasi

  • microgpt: Adam + penurunan learning rate linear sederhana
  • Pada skala besar, optimisasi adalah bidang tersendiri: precision yang diturunkan (bfloat16, fp8), pelatihan di klaster GPU skala besar
  • Pengaturan optimizer (learning rate, weight decay, parameter beta, jadwal warmup/decay) perlu dituning secara presisi; nilai yang tepat bergantung pada ukuran model, ukuran batch, dan komposisi dataset
  • Scaling laws (misalnya Chinchilla) memandu bagaimana mengalokasikan anggaran komputasi tetap antara ukuran model dan jumlah token pelatihan
  • Jika detail ini salah pada skala besar, bisa terjadi pemborosan komputasi senilai jutaan dolar; tim biasanya melakukan eksperimen kecil yang ekstensif sebelum menjalankan pelatihan penuh

• Post-training

  • Model dasar yang keluar dari pelatihan (model pra-pelatihan) adalah pelengkap dokumen, bukan chatbot
  • Proses menjadikannya ChatGPT terdiri dari dua tahap:
    • SFT (supervised fine-tuning): mengganti dokumen dengan percakapan yang dikurasi lalu melanjutkan pelatihan, tanpa perubahan algoritmik
    • RL (reinforcement learning): model menghasilkan respons → diberi skor (oleh manusia, model "juri", atau algoritme) → belajar dari umpan balik
  • Pada dasarnya model tetap belajar dari dokumen, tetapi kini dokumen itu terdiri dari token yang berasal dari model itu sendiri

• Inferensi

  • Untuk melayani model ke jutaan pengguna dibutuhkan stack rekayasa tersendiri: batching request, manajemen dan paging cache KV (seperti vLLM), speculative decoding untuk kecepatan, quantization untuk mengurangi memori (berjalan pada int8/int4), dan membagi model ke beberapa GPU
  • Pada dasarnya model tetap memprediksi token berikutnya dalam urutan, tetapi banyak upaya rekayasa dilakukan untuk membuatnya lebih cepat

FAQ

• Apakah model "memahami" sesuatu?

  • Ini pertanyaan filosofis, atau secara mekanis: tidak ada sihir yang terjadi
  • Model adalah fungsi matematika besar yang memetakan token input menjadi distribusi probabilitas untuk token berikutnya
  • Selama pelatihan, parameter disesuaikan agar token berikutnya yang benar menjadi lebih mungkin
  • Apakah itu termasuk "pemahaman" tergantung masing-masing orang, tetapi mekanismenya sepenuhnya ada dalam 200 baris di atas

• Mengapa ini bekerja?

  • Model memiliki ribuan parameter yang bisa disesuaikan, dan optimizer menggesernya sedikit demi sedikit di setiap langkah agar loss turun
  • Setelah banyak langkah, parameter menjadi stabil pada nilai-nilai yang menangkap keteraturan statistik dalam data
  • Dalam kasus nama: banyak yang dimulai dengan konsonan, "qu" cenderung muncul bersama, tiga konsonan berturut-turut jarang, dan seterusnya
  • Model mempelajari distribusi probabilitas yang mencerminkan hal-hal ini, bukan aturan eksplisit

• Apa hubungannya dengan ChatGPT?

  • ChatGPT memperbesar loop inti yang sama ini (prediksi token berikutnya, sampling, pengulangan) secara besar-besaran dan menambahkan post-training agar menjadi interaktif
  • Saat mengobrol, system prompt, pesan pengguna, dan respons semuanya hanyalah token dalam sebuah urutan
  • Model melengkapi dokumen satu token pada satu waktu dengan cara yang sama seperti microgpt melengkapi nama

• Apa itu "halusinasi"?

  • Model menghasilkan token dengan melakukan sampling dari distribusi probabilitas
  • Model tidak memiliki konsep kebenaran dan hanya mengetahui urutan yang secara statistik masuk akal menurut data pelatihannya
  • microgpt yang "menghalusinasikan" nama seperti "karia" adalah fenomena yang sama dengan ChatGPT yang dengan percaya diri mengatakan fakta palsu
  • Keduanya adalah pelengkapan yang terdengar masuk akal tetapi tidak nyata

• Mengapa ini sangat lambat?

  • microgpt memproses satu skalar pada satu waktu dalam Python murni, sehingga satu langkah pelatihan membutuhkan beberapa detik
  • Di GPU, matematika yang sama memproses jutaan skalar secara paralel, sehingga berjalan beberapa orde magnitudo lebih cepat

• Bisakah dibuat menghasilkan nama yang lebih baik?

  • Bisa: latih lebih lama (num_steps lebih besar), perbesar model (n_embd, n_layer, n_head), gunakan dataset yang lebih besar
  • Ini adalah tuas pengaturan yang sama yang juga penting pada skala besar

• Bagaimana jika dataset diganti?

  • Model akan mempelajari pola apa pun yang ada dalam data
  • Jika diganti dengan nama kota, nama Pokemon, kata-kata bahasa Inggris, atau file puisi pendek, model akan belajar menghasilkan hal-hal itu sebagai gantinya
  • Sisa kode tidak perlu diubah

[mhj5730]

Terima kasih atas artikelnya yang bagus.