Forem

Cover image for Cara Melatih ChatGPT Sendiri dengan Budget 50 Dolar
Walse
Walse

Posted on • Originally published at apidog.com

Cara Melatih ChatGPT Sendiri dengan Budget 50 Dolar

TL;DR

nanochat adalah kerangka kerja pelatihan LLM open source milik Andrej Karpathy yang memungkinkan Anda melatih chatbot setara GPT-2 dengan biaya kurang dari $50 dalam waktu sekitar 2 jam. Proyek ini menggunakan satu node GPU 8xH100, kode minimal (sekitar 500 baris untuk model inti), dan satu tombol konfigurasi (--depth) untuk mengoptimalkan semua hyperparameter secara otomatis. Catatan saat ini menunjukkan penyelesaian pelatihan dalam 1,65 jam dengan skor CORE 0,2626, mengalahkan GPT-2 OpenAI tahun 2019 yang menelan biaya $43.000 dan membutuhkan waktu 168 jam.

Coba Apidog hari ini

Pendahuluan

Melatih model bahasa besar dulunya membutuhkan jutaan dolar dan tim peneliti PhD. Masa-masa itu sudah berlalu.

Andrej Karpathy baru saja merilis nanochat, sebuah proyek open source yang melatih AI percakapan yang mumpuni dengan biaya kurang dari harga makan malam yang enak. Seluruh pipeline berjalan pada satu node GPU 8xH100 dan selesai dalam waktu kurang dari 2 jam.

Mengapa Ini Penting Sekarang

Lanskap AI berubah total pada awal 2026. Apa yang dulunya butuh 168 jam dan $43.000 bagi OpenAI pada 2019, kini bisa dikerjakan hanya dalam 1,65 jam dan $48. Peningkatan kecepatan 100x ini didorong oleh algoritma yang lebih baik, hardware modern, dan optimasi komunitas.

Bagi developer API dan tim yang membangun aplikasi AI, ini membuka pintu eksperimen pelatihan model kustom, menguji perubahan arsitektur, dan memahami internals LLM tanpa biaya infrastruktur besar.

đź’ˇ Padukan ini dengan platform pengembangan API seperti Apidog untuk menguji dan mendokumentasikan layanan AI Anda. Dengan begitu, Anda punya stack lengkap untuk membangun aplikasi AI produksi.

Apa yang Akan Anda Pelajari

Setelah membaca, Anda akan memahami:

  • Cara nanochat memangkas biaya 100x dibanding pelatihan LLM tradisional
  • Arsitektur lengkap (model GPT, optimizer Muon, data loading)
  • Langkah konkret melatih model sendiri
  • Cara menggunakan nanochat untuk eksperimen LLM cepat
  • Batasan nyata dan makna “kemampuan GPT-2”

Apa Itu nanochat?

nanochat adalah framework pelatihan LLM minimal yang mencakup seluruh pipeline: tokenisasi, pra-pelatihan, fine-tuning, evaluasi, inferensi, hingga UI web seperti ChatGPT.

Kode sumbernya satu repo tanpa konfigurasi rumit. Karpathy mendesainnya sebagai baseline kuat yang mudah dibaca, diubah, dan di-fork.

Klaim Utama

Latih model GPT-2 (1,6B parameter) dengan:

  • $48 on-demand (2 jam, ~$24/jam 8xH100)
  • ~$15 pada instans spot

Sebagai perbandingan, pelatihan GPT-2 OpenAI 2019: $43.000, 7 hari, 32 TPU v3.

Fitur nanochat

Tahap Skrip Deskripsi
Tokenisasi scripts.tok_train Melatih tokenizer BPE (32.768 vocab)
Pra-pelatihan scripts.base_train Melatih model GPT dasar
Fine-tuning scripts.chat_sft Fine-tuning untuk chat
Evaluasi scripts.base_eval Metrik CORE, bit-per-byte
Inferensi scripts.chat_cli CLI chat interface
UI Web scripts.chat_web Web UI mirip ChatGPT

Filosofi: Satu Tombol Mengontrol Semua

Kebanyakan framework LLM membanjiri Anda dengan konfigurasi. nanochat hanya satu parameter: --depth (jumlah layer transformer).

# Model GPT-1
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12

# Model GPT-2
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=24

# Model lebih besar
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26
Enter fullscreen mode Exit fullscreen mode

Atur kedalaman, nanochat otomatis menentukan:

  • Lebar transformer (dimensi embedding)
  • Jumlah attention head
  • Learning rate tiap grup parameter
  • Total langkah training
  • Weight decay schedule
  • Ukuran batch

Filosofi "satu tombol" ini memudahkan pembuatan keluarga model optimal hanya dengan mengubah satu argumen.

Kenapa Pendekatan Ini Efektif

Tim mengukur hukum penskalaan di puluhan sesi pelatihan dan menemukan pola prediktif antara depth, width, batch, dan durasi training. nanochat meng-encode hubungan ini langsung di skrip training.

Jadi, Anda bisa training optimal tanpa perlu jadi PhD ML.

Papan Peringkat: Berpacu Mengalahkan GPT-2

nanochat punya leaderboard publik yang melacak "waktu ke GPT-2". Targetnya mengalahkan skor CORE OpenAI 0.256525 pada 22 tugas (ARC, MMLU, dll – benchmark DCLM).

Rekor Saat Ini

Jalankan Model Waktu Skor CORE Inovasi Utama
GPT-2 Asli 1.6B 168 jam 0.2565 Baseline OpenAI 2019
Jalankan 1 d24 3.04 jam 0.2585 Baseline awal
Jalankan 2 d26 2.91 jam 0.2578 Pelatihan FP8
Jalankan 3 d26 2.76 jam 0.2602 Batch size 1M token
Jalankan 4 d24 2.02 jam 0.2571 Dataset ClimbMix
Jalankan 5 d24 1.80 jam 0.2690 Optimisasi oleh AI
Jalankan 6 d24 1.65 jam 0.2626 Smear/backout improvement

Bagaimana AI Menemukan Optimasi

Eksekusi 5 dan 6 menggabungkan perubahan dari sistem "autoresearch" Karpathy: agent AI bereksperimen arsitektur pada model kecil (d12, 5 menit training), lalu apply ke d24 penuh.

Contoh optimasi yang ditemukan:

  • Backout: Skema residual layer tengah lebih baik
  • Smear: Pencampuran bigram token sebelumnya lebih efisien

Hasil: Waktu training turun dari 2,02 jam ke 1,65 jam (peningkatan 19%).

Bagaimana nanochat Bekerja

Kode inti sekitar 3.000 baris. Berikut komponen utamanya:

1. Model GPT (nanochat/gpt.py)

Transformer mengikuti best practice modern plus beberapa optimasi:

Fitur:

  • Rotary embeddings (RoPE): positional encoding efisien
  • Normalisasi QK: stabilisasi training skala besar
  • Bobot tidak terikat: token embedding & output projection terpisah
  • ReLU²: MLP pakai ReLU kuadrat
  • Grouped Query Attention (GQA): KV head < query head → inferensi cepat
  • Sliding window attention: pola SSSL, dsb
  • Flash Attention 3: GPU Hopper optimal, fallback SDPA

Value Embeddings (ResFormer):

# Value residual: mix in value embedding with per-head gate
if ve is not None:
    ve = ve.view(B, T, self.n_kv_head, self.head_dim)
    gate = 3 * torch.sigmoid(self.ve_gate(x[..., :self.ve_gate_channels]))
    v = v + gate.unsqueeze(-1) * ve
Enter fullscreen mode Exit fullscreen mode

Menambah kapasitas tanpa overhead signifikan.

Trik Efisiensi:

# 1. Per-layer residual scaling
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0

# 2. Smear: bigram info
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: subtract mid-layer residual
x = x - self.backout_lambda * x_backout
Enter fullscreen mode Exit fullscreen mode

2. Optimizer Muon (nanochat/optim.py)

nanochat pakai optimizer campuran:

Parameter Optimizer Tujuan
Embedding, lm_head AdamW Optimasi adaptif standar
Skalar AdamW Faktor penskalaan
Matriks 2D Muon Update ortogonal

Muon (MomentUm Orthogonalized by Newton-Schulz):

# Polar Express coefficients (5 iterations)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ... more coefficients
]

# Orthogonalization loop
for a, b, c in polar_express_coeffs[:ns_steps]:
    A = X.mT @ X
    B = b * A + c * (A @ A)
    X = a * X + X @ B
Enter fullscreen mode Exit fullscreen mode

Reduksi Varians NorMuon:

v_mean = g.float().square().mean(dim=red_dim, keepdim=True)
v_norm = v_mean.sum(dim=(-2, -1), keepdim=True).sqrt()
final_scale = step_size * (v_norm / v_norm_new.clamp_min(1e-10))
g = g * final_scale.to(g.dtype)
Enter fullscreen mode Exit fullscreen mode

Distributed Training:

Phase 1: Launch all async reduce_scatter
Phase 2: Tunggu reduce, update, all_gather
Phase 3: Tunggu gather, copy param
Enter fullscreen mode Exit fullscreen mode

3. Manajemen Presisi (nanochat/common.py)

nanochat atur presisi eksplisit (tanpa torch.amp.autocast):

Hardware dtype default Alasan
CUDA SM 80+ (A100, H100) bfloat16 Core tensor BF16
CUDA SM < 80 (V100, T4) float32 Tidak ada BF16
CPU / MPS float32 Tidak ada core presisi

Lapisan Linear kustom:

class Linear(nn.Linear):
    def forward(self, x):
        return F.linear(x, self.weight.to(dtype=x.dtype))
Enter fullscreen mode Exit fullscreen mode

Bobot master tetap FP32. Untuk H100/Blackwell, training FP8 via --fp8 (Float8Linear).

4. Data Loading (nanochat/dataloader.py)

Dataloader: best-fit packing sejajar BOS

  • Tiap baris mulai token BOS
  • Dokumen dikemas best-fit untuk minim waste
  • Jika tidak muat, dokumen terpendek dipotong pas
  • Efisiensi 100% (pemotongan token ~35% di seq 2048) 
# Find largest document that fits entirely
best_idx = -1
best_len = 0
for i, doc in enumerate(doc_buffer):
    doc_len = len(doc)
    if doc_len <= remaining and doc_len > best_len:
        best_idx = i
        best_len = doc_len

if best_idx >= 0:
    doc = doc_buffer.pop(best_idx)
    # Add full document
else:
    # Crop shortest doc to fill remaining space
Enter fullscreen mode Exit fullscreen mode

5. Flash Attention Unification (nanochat/flash_attention.py)

Interface otomatis antara FA3 dan PyTorch SDPA:

from nanochat.flash_attention import flash_attn

# Otomatis pilih backend terbaik
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
Enter fullscreen mode Exit fullscreen mode

Di GPU Hopper + bfloat16: Flash Attention 3. Lainnya: fallback SDPA.

6. Mesin Inferensi (nanochat/engine.py)

Kelas Engine menangani inference efisien:

  • KV Cache: Cache prompt dengan flash_attn_with_kvcache (FA3)
  • Penggunaan alat: Token khusus trigger kalkulator Python via eval()
  • Generasi batch: Kloning KV cache untuk sampling paralel

Mesin mengatur alur chat, termasuk forced output token saat kalkulator dipanggil.

Langkah Demi Langkah: Latih Model Sendiri

Semua pipeline ada di runs/speedrun.sh. Berikut step-by-step-nya:

Prasyarat

  • Node GPU 8xH100 (atau setara)
  • Disk ~20 GB untuk dataset
  • Python 3.10+
  • Paket manager uv

1. Pengaturan Lingkungan 

# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Buat dan aktifkan virtual environment
uv venv
source .venv/bin/activate

# Install dependensi
uv sync --extra gpu
Enter fullscreen mode Exit fullscreen mode

2. Download Data Training 

# Download ~2B karakter dari dataset ClimbMix
python -m nanochat.dataset -n 170

# ~170 shard, ~100MB per shard
# Total ~17 GB terkompresi
Enter fullscreen mode Exit fullscreen mode

Skrip otomatis handle koordinasi multi-rank via file lock.

3. Latih Tokenizer 

# Latih BPE tokenizer
python -m scripts.tok_train

# Evaluasi rasio kompresi
python -m scripts.tok_eval
Enter fullscreen mode Exit fullscreen mode

Tokenizer model split ala GPT-4 + byte-fallback. Training ~10 menit (2B karakter).

4. Pra-pelatihan Model Dasar 

# Latih model d24 (GPT-2 capability)
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=24 \
    --target-param-data-ratio=8 \
    --device-batch-size=16 \
    --fp8 \
    --run=my-first-model
Enter fullscreen mode Exit fullscreen mode

Parameter penting:

  • --depth=24: model GPT-2
  • --target-param-data-ratio=8: undertrain untuk speed
  • --device-batch-size=16: batch per GPU
  • --fp8: aktifkan training FP8 (H100+)

Estimasi waktu: ~2 jam.

5. Fine-tuning Terarah 

# Download identity conversations
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

# Jalankan SFT untuk chat
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft
Enter fullscreen mode Exit fullscreen mode

Langkah ini menambah kemampuan percakapan, token spesial, dan penggunaan alat.

6. Chat dengan Model Anda 

# CLI chat
python -m scripts.chat_cli -p "Why is the sky blue?"

# Atau jalankan web UI
python -m scripts.chat_web
Enter fullscreen mode Exit fullscreen mode

Web UI di port 8000, layout mirip ChatGPT.

Alur Kerja Penelitian: Eksperimen Cepat

Untuk menguji ide baru, gunakan model kecil agar iterasi cepat.

Eksperimen 5 Menit 

OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=12 \
    --run="d12-test" \
    --core-metric-every=999999 \
    --sample-every=-1 \
    --save-every=-1
Enter fullscreen mode Exit fullscreen mode

Latih model d12 (GPT-1 size) dengan logging minimal.

Metrik yang Harus Dipantau

Pantau di Weights & Biases:

  1. val_bpb: validasi bits-per-byte (loss independen vocab size)
  2. core_metric: skor evaluasi DCLM CORE
  3. train/mfu: FLOPS utilization
  4. train/tok_per_sec: throughput training

Persyaratan Pengujian

Setiap perubahan harus valid di semua depth (d12 sampai d26) untuk mencegah overfit satu ukuran model.

Mengapa nanochat Penting

Aksesibilitas Biaya

Pendekatan Biaya Waktu Hardware
OpenAI GPT-2 (2019) $43.000 168 jam 32 TPU v3
nanochat (2026) $48 2 jam 8xH100
nanochat spot ~$15 2 jam Spot 8xH100

LLM training kini bisa diakses oleh:

  • Peneliti individu
  • Startup kecil
  • Kelas universitas
  • Penghobi

Nilai Edukasional

Kode sumber = sumber belajar:

  • ~500 baris untuk model GPT
  • ~530 baris untuk optimizer
  • Komentar jelas di tiap keputusan desain
  • Tidak ada konfigurasi tersembunyi

Kecepatan Penelitian

Training dari hari ke jam →:

  • Hipotesis diuji lebih cepat
  • Lebih banyak eksperimen/minggu
  • Biaya gagal rendah
  • Kolaborasi komunitas (leaderboard)

Transparansi

Setiap keputusan desain terdokumentasi:

  • Hukum penskalaan: dev/LOG.md
  • Studi ablation: Diskusi GitHub
  • Detail reproduksi leaderboard
  • Kontribusi AI dioptimisasi jelas

Keterbatasan & Cek Realitas

nanochat mengesankan, tapi punya batas:

Persyaratan Hardware

Harga $48 untuk node 8xH100. Biaya cloud bervariasi:

  • Lambda Labs: ~$25/jam (8xH100)
  • RunPod: ~$15/jam spot
  • Total: ~2 jam pretrain + SFT

Butuh ~$50-100 sekali jalan, tergantung provider.

Batas Kemampuan

nanochat = kinerja setingkat GPT-2 (2019):

Bisa:

  • Chat dasar
  • Penalaran sederhana
  • Matematika dasar
  • Mengingat fakta (terbatas)

Tidak bisa:

  • Penalaran multi-langkah kompleks
  • Generasi kode sulit
  • Instruksi bernuansa
  • Bersaing GPT-4/Claude/Gemini

Bayangkan: Anak TK – bisa chat dasar, tapi bukan ekspert.

Data Requirement

Speedrun lengkap unduh:

  • ~170 shard data
  • ~17 GB terkompresi
  • ~2B karakter total

Butuh storage + bandwidth memadai.

Keterbatasan Metrik

CORE score mengukur 22 tugas, tapi tidak mencakup:

  • Kualitas chat real-world
  • Pengetahuan domain spesifik
  • Nuansa instruksi
  • Keamanan & alignment

Seed acak beda → varians CORE ~0,016.

FAQ

Berapa biaya melatih model dengan nanochat?

Sekitar $48 on-demand ($24/jam Ă— 2 jam), atau ~$15 di spot. Hanya pretrain, tambah ~30 menit untuk SFT.

GPU apa yang dibutuhkan?

Minimal: 1 GPU (datacenter class). Optimal: 8xH100/A100. Kode otomatis diskalakan dari 1–8 GPU.

Berapa lama training?

1,65–3 jam tergantung hardware. Rekor saat ini: 1,65 jam model d24.

Apa itu metrik CORE?

CORE = DCLM, menguji 22 tugas (ARC, MMLU, dll). GPT-2: 0,256525. nanochat: >0,26 reguler.

Bisa training di 1 GPU?

Bisa. Hilangkan torchrun, kode auto pakai gradient accumulation. Training 8x lebih lama, hasil hampir sama.

Dataset apa yang dipakai?

Terbaik saat ini: ClimbMix (web curated NVIDIA). Dulu: FineWeb-EDU. Tokenizer ~2B karakter dari 8 shard awal.

nanochat support Apple Silicon?

Ya. Jalan di MPS (float32). Training lebih lambat, tapi cukup buat eksperimen.

Bisa lanjut training dari checkpoint?

Bisa. Pakai --resume-from-step=<step>. Dataloader status juga disimpan.

nanochat vs nanoGPT?

nanoGPT: hanya pretraining. nanochat: pipeline penuh (tokenisasi, pretrain, SFT, RLHF, evaluasi, inferensi, UI web).

Kesimpulan

nanochat membuktikan: pelatihan LLM kini murah dan mudah. Dulu $43.000 (2019), sekarang < $50.

Dampaknya lebih dari sekadar cost reduction. Dengan basecode minimal + interface “satu tombol”, Karpathy menciptakan alat penelitian & edukasi nyata.

Poin-Poin Penting

  • 100x lebih murah: $43.000 → $48 (GPT-2 capability)
  • 100x lebih cepat: 168 jam → 1,65 jam
  • Satu tombol konfigurasi: --depth
  • Pipeline lengkap: Tokenisasi – UI web
  • Driven by komunitas: Leaderboard publik, perbaikan berkelanjutan

Langkah Selanjutnya

Siap melatih model sendiri? Mulai dari repo nanochat dan skrip runs/speedrun.sh.

Untuk developer API yang membangun aplikasi AI, memahami training LLM kini sangat mudah. Batas masuk turun dari "startup VC" ke "proyek akhir pekan".

Top comments (0)