Thanawat Wongchai

Posted on Mar 19 • Originally published at apidog.com

วิธีฝึก ChatGPT ส่วนตัว งบ 50 ดอลลาร์

#llm #ai #opensource #machinelearning

TL;DR (สรุปย่อ)

nanochat คือเฟรมเวิร์กโอเพนซอร์สสำหรับฝึก LLM ของ Andrej Karpathy ที่ช่วยให้คุณฝึกแชทบอทระดับ GPT-2 ได้ในงบไม่ถึง $50 ใช้เวลาไม่ถึง 2 ชั่วโมงบนโหนด GPU 8xH100 เดียว โค้ดหลักประมาณ 500 บรรทัด มีตัวควบคุมเดียว (--depth) สำหรับตั้งค่าทั้งหมด สถิติล่าสุด: การฝึกเสร็จใน 1.65 ชั่วโมง, คะแนน CORE 0.2626 ดีกว่า GPT-2 ดั้งเดิม (2019) ที่ใช้เงิน $43,000 และเวลาฝึก 168 ชั่วโมง

ทดลองใช้ Apidog วันนี้

บทนำ

การฝึกโมเดลภาษาขนาดใหญ่ไม่จำเป็นต้องใช้งบมหาศาลหรือทีมนักวิจัยอีกต่อไป

Andrej Karpathy เปิดตัว nanochat โอเพนซอร์สสำหรับฝึก AI สนทนาความสามารถสูง งบประมาณน้อยกว่ามื้อค่ำดีๆ ใช้ GPU 8xH100 เดียว ไม่ถึง 2 ชั่วโมง

ทำไมสิ่งนี้จึงสำคัญในตอนนี้

ต้นปี 2026 เห็นการเปลี่ยนแปลงของ AI อย่างมาก จากที่ OpenAI ใช้ 168 ชั่วโมง และ $43,000 ในปี 2019 วันนี้เหลือแค่ 1.65 ชั่วโมง และ $48 ทั้งหมดนี้เกิดจากอัลกอริทึมใหม่ ฮาร์ดแวร์ดีขึ้น และการ optimize โดยคอมมูนิตี้

สำหรับ dev API และทีม AI-app คุณสามารถฝึกโมเดลเอง ทดลองสถาปัตยกรรมใหม่ เข้าถึงการเรียนรู้เชิงลึกได้โดยไม่ต้องลงทุนโครงสร้างพื้นฐานใหญ่

💡 จับคู่กับแพลตฟอร์ม API Dev อย่าง Apidog เพื่อทดสอบ/จัดทำเอกสารบริการ AI ของคุณ ครบเครื่องสำหรับ AI production

สิ่งที่คุณจะได้เรียนรู้

วิธีที่ nanochat ลด cost การฝึก LLM ได้ 100 เท่า
โครงสร้าง (GPT, Muon optimizer, data loader)
วิธีฝึกโมเดลด้วยตนเองแบบ step by step
การใช้ nanochat เพื่อวิจัยและทดลอง LLM
ข้อจำกัดและความหมายของระดับ GPT-2

nanochat คืออะไร?

nanochat คือชุดเครื่องมือฝึก LLM ครบวงจร: tokenization, pretraining, finetuning, evaluation, inference, และ Web UI สไตล์ ChatGPT

โค้ดเบสอยู่ repo เดียว ไม่มี config ซับซ้อน Karpathy ออกแบบให้ “พื้นฐานแข็งแรง” — อ่านง่าย แก้ไขง่าย แตกกิ่งหรือแฮ็กต่อยอดสะดวก

ข้อกล่าวอ้างหลัก

ฝึกโมเดลระดับ GPT-2 (1.6B params) ด้วย:
- $48 (On-demand, 2 ชั่วโมง, $24/ชม. สำหรับ 8xH100)
- ~$15 (Spot Instances)
เทียบกับ GPT-2 ดั้งเดิม (2019): $43,000, 7 วัน, 32 TPU v3

nanochat ครอบคลุมอะไรบ้าง

ขั้นตอน	สคริปต์	คำอธิบาย
การสร้างโทเค็น	`scripts.tok_train`	ฝึก BPE tokenizer (32,768 vocab)
การฝึกก่อน	`scripts.base_train`	ฝึกโมเดล GPT พื้นฐาน
การปรับแต่ง	`scripts.chat_sft`	SFT สำหรับการสนทนา
การประเมินผล	`scripts.base_eval`	CORE metric, bits-per-byte
การอนุมาน	`scripts.chat_cli`	CLI interface
Web UI	`scripts.chat_web`	Web UI สไตล์ ChatGPT

ปรัชญา: ตัวควบคุมเดียวสำหรับทุกสิ่ง

เฟรมเวิร์ก LLM ส่วนใหญ่ config เยอะ nanochat มีพารามิเตอร์เดียว: --depth (จำนวนเลเยอร์ของ transformer)

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

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

# กดขีดจำกัด
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26

ระบุแค่ความลึก (depth) ที่เหลือคำนวณอัตโนมัติ:

ความกว้างของ transformer
จำนวน attention heads
learning rate
steps
schedule
batch size

“ตัวควบคุมเดียว” = nanochat miniseries: โมเดลหลายขนาด เหมาะสมที่สุดกับ compute ทุกระดับ

เหตุผลที่ได้ผล

ทีมวัด scaling laws จากการฝึกหลายสิบครั้ง พบความสัมพันธ์ลึก-กว้าง-batch-training steps แล้ว encode ลงใน training script โดยตรง

คุณฝึกโมเดลได้แบบ optimal โดยไม่ต้องจูนอะไรเอง

กระดานผู้นำ: แข่งกับ GPT-2

nanochat มี public leaderboard ติดตาม "เวลาสู่ GPT-2" — เป้าหมาย: เอาชนะคะแนน CORE ของ GPT-2 (0.256525) ใน 22 งาน DCLM

สถิติปัจจุบัน

การรัน	โมเดล	เวลา	CORE	นวัตกรรมหลัก
GPT-2 ดั้งเดิม	1.6B	168 ชม.	0.2565	OpenAI 2019 baseline
run 1	d24	3.04 ชม.	0.2585	baseline
run 2	d26	2.91 ชม.	0.2578	FP8 training
run 3	d26	2.76 ชม.	0.2602	1M-token batch
run 4	d24	2.02 ชม.	0.2571	ClimbMix dataset
run 5	d24	1.80 ชม.	0.2690	AI-found efficiency
run 6	d24	1.65 ชม.	0.2626	Improved smear/backout

การปรับปรุงที่ AI ค้นพบ

run 5-6 ได้ไอเดียจากระบบ “autoresearch” ของ Karpathy — AI agent ทดสอบโมเดล d12 (ฝึก 5 นาที) แล้วนำสิ่งที่เวิร์คไปใช้กับ d24 จริง เช่น:

กลไก Backout ที่ดีขึ้น
Smear (bigram) ที่มีประสิทธิภาพกว่าเดิม

ลดเวลาฝึกจาก 2.02 เหลือ 1.65 ชั่วโมง (เร็วขึ้น 19%)

nanochat ทำงานอย่างไร

โค้ดหลัก ~3,000 บรรทัด แบ่งเป็นโมดูล:

1. โมเดล GPT (`nanochat/gpt.py`)

Transformer ตาม best-practice สมัยใหม่
ฟีเจอร์:
- Rotary embeddings (RoPE)
- QK normalization
- Untied weights
- ReLU² activation
- Grouped Query Attention (GQA)
- Sliding window attention
- Flash Attention 3 (FA3)

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

Performance tricks:

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

# 2. Smear: mix previous token embedding for 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

2. ตัวปรับปรุง Muon (`nanochat/optim.py`)

ใช้ optimizer แบบผสม:

ประเภทพารามิเตอร์	Optimizer	วัตถุประสงค์
Embeddings, lm_head	AdamW	Adaptive update
Scalar parameters	AdamW	Learnable scale factors
2D matrix	Muon	Orthogonalized updates

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),
    # ...
]

# 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

NorMuon variance scaling:

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)

Distributed training: ZeRO-2 partitioning, async 3-phase communication

3. การจัดการความแม่นยำ (`nanochat/common.py`)

ควบคุม dtype เอง (ไม่ใช้ torch.amp.autocast):

ฮาร์ดแวร์	dtype	เหตุผล
CUDA SM 80+ (A100+)	bfloat16	Native BF16 tensor cores
CUDA SM < 80	float32	ไม่มี BF16
CPU / MPS	float32	ไม่มี reduced-precision cores

Custom Linear layer:

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

น้ำหนักหลักเก็บ FP32, H100/Blackwell GPUs ใช้ FP8 ได้ (--fp8)

4. การโหลดข้อมูล (`nanochat/dataloader.py`)

BOS-aligned best-fit packing: ทุกแถวเริ่ม BOS, บรรจุเอกสารด้วย best-fit, crop เอกสารถ้าจำเป็น, ใช้งานโทเค็น 100% (~35% cropping ที่ seq 2048)
ทุกโทเค็นเห็น context เต็ม

# 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

5. Flash Attention integration (`nanochat/flash_attention.py`)

อินเทอร์เฟซรวม FA3 กับ PyTorch SDPA:

from nanochat.flash_attention import flash_attn

y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)

Hopper GPUs + bf16 ใช้ FA3, ที่เหลือ fallback SDPA

6. Inference Engine (`nanochat/engine.py`)

KV cache
Tool use (เรียก Python calculator ด้วยโทเค็นพิเศษ)
Batch generation

Web/CLI UI สะดวกต่อการทดสอบ prompt/response

ทีละขั้นตอน: ฝึกโมเดลของคุณเอง

ไฟล์หลัก: runs/speedrun.sh

ข้อกำหนดเบื้องต้น

GPU node 8xH100 (หรือใกล้เคียง)
20GB disk space
Python 3.10+
uv package manager

ขั้นตอนที่ 1: การตั้งค่าสภาพแวดล้อม

# ติดตั้ง uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# สร้างและ activate venv
uv venv
source .venv/bin/activate

# ติดตั้ง dependencies
uv sync --extra gpu

ขั้นตอนที่ 2: ดาวน์โหลดข้อมูลการฝึก

# ดาวน์โหลดประมาณ 2B ตัวอักษร ClimbMix
python -m nanochat.dataset -n 170

ได้ shard ~170 ชิ้น ชิ้นละ ~100MB รวม ~17GB

ขั้นตอนที่ 3: ฝึก Tokenizer

# ฝึก BPE tokenizer vocab 32,768
python -m scripts.tok_train

# ประเมิน compression rate
python -m scripts.tok_eval

ขั้นตอนที่ 4: ฝึกโมเดลพื้นฐาน

# ฝึกโมเดล d24 (GPT-2)
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

--depth=24: ขนาด GPT-2
--fp8: เปิด FP8 (H100+ เท่านั้น)
ใช้เวลาประมาณ 2 ชั่วโมง

ขั้นตอนที่ 5: Supervised Finetuning (SFT)

# ดาวน์โหลด identity conversations
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

# SFT เพื่อเพิ่มความสามารถสนทนา
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft

ขั้นตอนที่ 6: สนทนากับโมเดลของคุณ

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

# หรือเปิด Web UI
python -m scripts.chat_web

Web UI เปิดที่ port 8000

ขั้นตอนการวิจัย: ทดลองเร็ว

ต้องการวนลูปไอเดียไวๆ? ใช้โมเดลขนาดเล็กลง (d12)

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

ฝึก d12 (GPT-1) ~5 นาที

Metrics ติดตาม (Weights & Biases):

val_bpb: bits-per-byte validation
core_metric: DCLM CORE score
train/mfu: Model FLOPS utilization
train/tok_per_sec: tokens/sec

ข้อกำหนดการทดสอบ: improvement ต้องใช้ได้กับทุก depth (d12-d26)

ทำไม nanochat ถึงสำคัญ

ความสามารถในการเข้าถึงด้านต้นทุน

แนวทาง	ต้นทุน	เวลา	ฮาร์ดแวร์
OpenAI GPT-2 (2019)	$43,000	168 ชม.	32 TPU v3
nanochat (2026)	$48	2 ชม.	8xH100
nanochat spot	~$15	2 ชม.	8xH100 spot

ใครก็ฝึก LLM ได้: นักวิจัย, สตาร์ทอัพ, หลักสูตร, บุคคลทั่วไป

คุณค่าทางการศึกษา

โค้ด ~500 บรรทัด (GPT), ~530 (optimizer)
อธิบาย design ตัดสินใจชัดเจน
ไม่มี config ซ่อน
เหมาะกับการอ่าน/ทดลอง

ความเร็วในการวิจัย

ฝึกเร็วขึ้น = ทดสอบ hypothesis ไวขึ้น
ทดลองได้มากขึ้น ลด cost ของ failure
community ร่วมกันแข่งบน leaderboard

ความโปร่งใส

scaling laws: dev/LOG.md
ablation studies: GitHub Discussions
log การรันแบบ reproducible
เปิดเผยส่วนที่ AI มีส่วนช่วย

ข้อจำกัดและการตรวจสอบความเป็นจริง

ข้อกำหนดด้านฮาร์ดแวร์

$48 = สมมติคุณมี 8xH100
Lambda Labs: ~$25/ชม., RunPod: ~$15/ชม. (spot)
เตรียม $50-100 ต่อรันเต็ม

ขีดจำกัดความสามารถ

เทียบเท่า GPT-2 (2019)
ทำได้: สนทนาพื้นฐาน, reasoning ง่าย, คณิตเบื้องต้น
ทำไม่ได้: reasoning หลายขั้น, โค้ดซับซ้อน, instruction following ลึก, แข่ง GPT-4/Claude/Gemini

ข้อกำหนดด้านข้อมูล

170 shards, ~17GB, 2B ตัวอักษร
ต้องมี storage/bandwidth

ข้อจำกัดของ metric

CORE วัด 22 งาน, ไม่ครอบคลุมคุณภาพสนทนา, ความรู้เชิงลึก, ความละเอียด instruction, safety
seed ต่าง ผลลัพธ์ต่างได้ ~0.016

คำถามที่พบบ่อย (FAQ)

การฝึกโมเดลด้วย nanochat มีค่าใช้จ่ายเท่าไหร่?

ประมาณ $48 (On-demand, 2 ชั่วโมง) หรือ ~$15 (Spot) + SFT ~30 นาที

ฉันต้องใช้ GPU รุ่นใด?

ขั้นต่ำ: GPU เดี่ยวก็ได้, เหมาะสุด: 8xH100/A100 โค้ด scale auto 1-8 GPU

การฝึกใช้เวลานานเท่าใด?

1.65-3 ชั่วโมง ขึ้นกับ setting/hardware

CORE metric คืออะไร?

DCLM CORE: 22 งาน (ARC, MMLU, ฯลฯ) GPT-2 = 0.256525, nanochat ส่วนใหญ่ >0.26

ฉันสามารถฝึกบน GPU ตัวเดียวได้หรือไม่?

ได้ ละเว้น torchrun ใช้ Gradient Accumulation อัตโนมัติ แต่ช้าขึ้น 8 เท่า

nanochat ใช้ชุดข้อมูลใด?

ClimbMix (NVIDIA curated web dataset), รุ่นก่อนใช้ FineWeb-EDU, ฝึกบน 2B ตัวอักษร (8 shards แรก)

nanochat ใช้งานกับ Apple Silicon ได้ไหม?

ได้ ใช้ MPS (float32), ช้ากว่า CUDA แต่ใช้งานได้

ฉันสามารถฝึกต่อจาก checkpoint ได้หรือไม่?

ได้ --resume-from-step=<step> ดึง dataloader state กลับมาด้วย

nanochat กับ nanoGPT ต่างกันอย่างไร?

nanoGPT มีแค่ pretrain, nanochat ครบทั้ง pipeline: tokenize, pretrain, SFT, RLHF, eval, infer, Web UI

บทสรุป

nanochat แสดงให้เห็นว่าการฝึก LLM ไม่ต้องใช้งบหรือ infra ใหญ่อีกต่อไป จาก $43,000 (2019) เหลือไม่ถึง $50

จุดเด่นไม่ใช่แค่ลดต้นทุน แต่คือโค้ดที่อ่านง่าย ใช้งานง่าย (“ตัวควบคุมเดียว”) เป็นทั้งเครื่องมือวิจัยและแหล่งเรียนรู้

ประเด็นสำคัญ

ลดต้นทุน 100 เท่า: $43,000 → $48 สำหรับ GPT-2
เร็วขึ้น 100 เท่า: 168 ชม. → 1.65 ชม.
ตัวควบคุมเดียว: --depth
ไปป์ไลน์ครบ: ตั้งแต่ tokenize ถึง Web UI
ขับเคลื่อนโดยชุมชน: Public leaderboard

ขั้นตอนต่อไป

พร้อมฝึกโมเดลเองหรือยัง? เริ่มที่ nanochat repository กับสคริปต์ runs/speedrun.sh

สำหรับ dev API ที่สร้าง AI app — วันนี้คุณเข้าถึง LLM training ได้ง่าย อุปสรรคจาก “สตาร์ทอัพ VC” กลายเป็น “โปรเจกต์วันหยุด”