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

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

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

บทนำ

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

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

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

ภูมิทัศน์ของ AI ได้เปลี่ยนแปลงไปอย่างมากในช่วงต้นปี 2026 สิ่งที่ OpenAI ใช้เวลา 168 ชั่วโมง และ 43,000 ดอลลาร์ในปี 2019 ตอนนี้ใช้เวลาเพียง 1.65 ชั่วโมง และ 48 ดอลลาร์ นั่นคือความเร็วที่เพิ่มขึ้น 100 เท่า ซึ่งขับเคลื่อนโดยการปรับปรุงอัลกอริทึม ฮาร์ดแวร์ที่ดีขึ้น และการเพิ่มประสิทธิภาพโดยชุมชน

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

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

เมื่ออ่านบทความนี้จบ คุณจะเข้าใจสิ่งต่อไปนี้:

• nanochat ลดต้นทุนการฝึก LLM แบบเดิมได้ 100 เท่าได้อย่างไร
• สถาปัตยกรรมทั้งหมด (โมเดล GPT, ตัวปรับปรุง Muon, การโหลดข้อมูล)
• คำแนะนำทีละขั้นตอนในการฝึกโมเดลของคุณเอง
• วิธีใช้ nanochat สำหรับการวิจัยและการทดลอง LLM อย่างรวดเร็ว
• ข้อจำกัดที่แท้จริงและความหมายของความสามารถระดับ GPT-2

nanochat คืออะไร?

nanochat คือชุดเครื่องมือการฝึก LLM ที่ครอบคลุมไปป์ไลน์การพัฒนาทั้งหมด: การสร้างโทเค็น, การฝึกก่อน (pretraining), การปรับแต่ง (finetuning), การประเมินผล, การอนุมาน (inference) และ Web UI ที่เหมือน ChatGPT

โค้ดเบสทั้งหมดอยู่ใน repository เดียวกัน โดยไม่มีไฟล์การตั้งค่าที่ซับซ้อนหรือความซับซ้อนของเฟรมเวิร์ก Karpathy ออกแบบให้เป็น “พื้นฐานที่แข็งแกร่ง” ที่อ่านง่าย แฮ็กได้ และสามารถนำไปแตกกิ่งต่อยอดได้

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

ฝึกโมเดลที่มีความสามารถระดับ GPT-2 (พารามิเตอร์ 1.6 พันล้านตัว) ด้วย:

• $48 แบบ On-demand (2 ชั่วโมง ที่ประมาณ $24/ชั่วโมง สำหรับ 8xH100)
• ~$15 บน Spot Instances

สำหรับบริบท การฝึก GPT-2 ดั้งเดิมของ OpenAI ในปี 2019 มีค่าใช้จ่ายประมาณ 43,000 ดอลลาร์ และใช้เวลา 7 วัน บนชิป TPU v3 จำนวน 32 ชิ้น

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

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

เฟรมเวิร์ก LLM ส่วนใหญ่ทำให้คุณจมอยู่กับไฟล์การตั้งค่าจำนวนมาก nanochat ใช้วิธีตรงกันข้าม

ทั้งระบบหมุนรอบพารามิเตอร์เดียว: --depth (จำนวนเลเยอร์ของทรานส์ฟอร์เมอร์)

# โมเดลขนาด 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

กำหนดความลึก แล้ว nanochat จะคำนวณทุกสิ่งโดยอัตโนมัติ:

• ความกว้างของทรานส์ฟอร์เมอร์ (มิติการฝังตัว)
• จำนวนหัว Attention
• อัตราการเรียนรู้สำหรับแต่ละกลุ่มพารามิเตอร์
• ขอบเขตการฝึก (จำนวนขั้นตอนทั้งหมด)
• ตารางเวลาการลดน้ำหนัก
• ขนาดแบทช์

ปรัชญา “ตัวควบคุมเดียว” นี้ทำให้เกิดสิ่งที่ Karpathy เรียกว่า nanochat miniseries: กลุ่มโมเดลที่เหมาะสมที่สุดในการคำนวณที่ขนาดต่างๆ กัน ซึ่งทั้งหมดถูกฝึกด้วยแนวทางที่เป็นหลักการเดียวกัน

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

ทีมได้วัดกฎการขยายขนาดจากการฝึกนับสิบครั้ง พวกเขาพบความสัมพันธ์ที่คาดการณ์ได้ระหว่างความลึก ความกว้าง ขนาดแบทช์ และระยะเวลาการฝึก แทนที่จะเปิดเผยตัวแปรทั้งหมดเหล่านี้ nanochat ได้เข้ารหัสความสัมพันธ์เหล่านี้ลงในสคริปต์การฝึกโดยตรง

คุณได้รับการฝึกที่เหมาะสมที่สุดในการคำนวณโดยไม่จำเป็นต้องมีปริญญาเอกด้าน Deep Learning

กระดานผู้นำ: แข่งขันเพื่อเอาชนะ GPT-2

nanochat รักษากระดานผู้นำสาธารณะที่ติดตามความสามารถ “เวลาสู่ GPT-2” เป้าหมายคือการเอาชนะคะแนน CORE ดั้งเดิมของ OpenAI ที่ 0.256525 ใน 22 งานประเมินผล (ARC, MMLU และอื่นๆ จากชุดมาตรฐาน DCLM)

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

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

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

ระบบพบการปรับปรุงในด้าน:

• กลไก Backout: การลบส่วนเหลือของเลเยอร์กลางที่ดีขึ้น
• การนำ Smear ไปใช้: การผสมไบแกรมจากโทเค็นก่อนหน้าที่มีประสิทธิภาพมากขึ้น

การเปลี่ยนแปลงเหล่านี้ลดเวลาการฝึกจาก 2.02 ชั่วโมงเหลือ 1.65 ชั่วโมง ซึ่งเป็นการปรับปรุง 19% ที่ถูกค้นพบผ่านการทดลองแบบอัตโนมัติ

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

โค้ดเบสประกอบด้วยโค้ดประมาณ 3,000 บรรทัดในโมดูลหลักต่างๆ มาดูกันที่แต่ละส่วนประกอบ

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

ทรานส์ฟอร์เมอร์นี้เป็นไปตามหลักปฏิบัติที่ดีที่สุดสมัยใหม่ พร้อมการเพิ่มประสิทธิภาพหลายประการ:

คุณสมบัติสถาปัตยกรรม:

• Rotary embeddings (RoPE): การเข้ารหัสตำแหน่งสัมพัทธ์โดยไม่มีการฝังตำแหน่งที่เรียนรู้ได้
• QK normalization: ทำให้การฝึกมีเสถียรภาพในขนาดใหญ่
• Untied weights: เลเยอร์การฝังโทเค็นและการฉายภาพเอาต์พุตที่แยกจากกัน
• ReLU² activation: ReLU แบบยกกำลังสองใน MLP แทน GeLU
• Grouped Query Attention (GQA): หัว KV น้อยกว่าหัว Query เพื่อการอนุมานที่เร็วขึ้น
• Sliding window attention: รูปแบบที่กำหนดค่าได้ (เช่น “SSSL” สลับบริบทสั้น/ยาว)
• Flash Attention 3: การเพิ่มประสิทธิภาพ GPU ของ Hopper พร้อมการสำรองข้อมูล 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

สิ่งนี้ช่วยเพิ่มขีดความสามารถโดยไม่เพิ่มค่าใช้จ่ายในการคำนวณมากนัก

เคล็ดลับประสิทธิภาพ:

โมเดลนี้มีกลไกที่เรียนรู้ได้สามอย่างที่ช่วยปรับปรุงพลวัตของการฝึก:

# 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)

nanochat ใช้กลยุทธ์ตัวปรับปรุงแบบผสม:

Muon (MomentUm Orthogonalized by Newton-Schulz):

ตัวปรับปรุง Muon ทำให้การอัปเดตน้ำหนักเป็น Orthogonal โดยใช้วิธี Newton-Schulz แบบ quintic ที่เรียกว่า “Polar Express”:

# 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

การลดความแปรปรวนของ NorMuon:

หลังจากการทำ Orthogonalization การอัปเดตจะถูกทำให้เป็นปกติสำหรับแต่ละนิวรอนเพื่อป้องกันการยุบตัวของขนาด:

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)

การฝึกแบบกระจาย:

สำหรับการตั้งค่าหลาย GPU ตัวปรับปรุงใช้การแบ่งส่วนแบบ ZeRO-2 ด้วยการสื่อสารแบบอะซิงโครนัสสามเฟส:

Phase 1: Launch all async reduce_scatter operations
Phase 2: Wait for reduces, compute updates, launch all_gathers
Phase 3: Wait for gathers, copy back updated params

สิ่งนี้ช่วยให้การสื่อสารทับซ้อนกับการคำนวณ ทำให้ใช้ประโยชน์จาก GPU ได้สูงสุด

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

nanochat จัดการความแม่นยำอย่างชัดเจน แทนที่จะใช้ torch.amp.autocast:

เลเยอร์ Linear ที่กำหนดเองจะทำการส่งค่า Weight ให้ตรงกับ Compute Dtype ระหว่าง Forward Pass:

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

น้ำหนักหลักจะคงอยู่ใน FP32 เพื่อความแม่นยำของตัวปรับปรุง สำหรับ H100 และ Blackwell GPUs การฝึก FP8 สามารถทำได้ผ่าน --fp8 ซึ่งจะแปลงเลเยอร์ส่วนใหญ่เป็น Float8Linear ด้วย Tensorwise Scaling

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

ตัวโหลดข้อมูลใช้ BOS-aligned best-fit packing:

• ทุกแถวเริ่มต้นด้วยโทเค็น BOS (Beginning of Sequence)
• เอกสารถูกบรรจุโดยใช้อัลกอริทึม Best-fit เพื่อลดการสิ้นเปลือง
• เมื่อไม่มีเอกสารที่พอดี เอกสารหนึ่งจะถูกตัดเพื่อให้พอดีกับพื้นที่ที่เหลือ
• ใช้ประโยชน์ 100% พร้อมการตัดโทเค็นประมาณ 35% ที่ความยาวลำดับ 2048

สิ่งนี้ทำให้มั่นใจได้ว่าทุกโทเค็นสามารถย้อนกลับไปที่ BOS และเห็นบริบทเอกสารทั้งหมด

# 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 (nanochat/flash_attention.py)

โครงการนี้มีอินเทอร์เฟซแบบรวมที่สลับระหว่าง FA3 และ PyTorch SDPA โดยอัตโนมัติ:

from nanochat.flash_attention import flash_attn

# Works on any hardware - auto-selects best backend
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)

บน Hopper GPUs ที่ใช้ bfloat16 จะใช้ Flash Attention 3 ส่วนที่เหลือจะกลับไปใช้ Scaled Dot-Product Attention ของ PyTorch

6. เอ็นจินการอนุมาน (nanochat/engine.py)

คลาส Engine จัดการการสร้างอย่างมีประสิทธิภาพด้วย:

• KV Cache: แคช Prompt ที่โหลดไว้ล่วงหน้าด้วย flash_attn_with_kvcache ของ FA3
• Tool Use: โทเค็นพิเศษจะเรียกใช้เครื่องคิดเลข Python ผ่าน eval()
• Batch Generation: โคลน KV Cache สำหรับการสุ่มตัวอย่างแบบขนาน

เอนจินจะประสานงานการไหลของการสนทนา รวมถึงการบังคับโทเค็นเอาต์พุตของเครื่องมือเมื่อโมเดลเรียกใช้เครื่องคิดเลข

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

ไปป์ไลน์ทั้งหมดอยู่ใน runs/speedrun.sh นี่คือวิธีการรัน

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

• โหนด GPU 8xH100 (หรือคล้ายกัน)
• พื้นที่ดิสก์ประมาณ 20 GB สำหรับชุดข้อมูล
• Python 3.10+
• ตัวจัดการแพ็กเกจ uv

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

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

# สร้างและเปิดใช้งานสภาพแวดล้อมเสมือน
uv venv
source .venv/bin/activate

# ติดตั้งแพ็กเกจที่จำเป็น
uv sync --extra gpu

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

# ดาวน์โหลดข้อมูลประมาณ 2 พันล้านตัวอักษรจากชุดข้อมูล ClimbMix
python -m nanochat.dataset -n 170

# สิ่งนี้จะดาวน์โหลด shard ประมาณ 170 ชิ้น ชิ้นละประมาณ 100MB
# ทั้งหมด: ประมาณ 17 GB (แบบบีบอัด)

สคริปต์จะดาวน์โหลด shard ของข้อมูลการฝึกก่อน พร้อมการล็อกไฟล์เพื่อจัดการการประสานงานแบบหลายลำดับ

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

# ฝึก BPE tokenizer ด้วยคำศัพท์ 32,768 คำ
python -m scripts.tok_train

# ประเมินอัตราการบีบอัด
python -m scripts.tok_eval

Tokenizer ใช้รูปแบบการแบ่งแบบ GPT-4 พร้อม Byte-fallback BPE การฝึกจะเสร็จสมบูรณ์ในเวลาประมาณ 10 นาทีสำหรับข้อมูล 2 พันล้านตัวอักษร

ขั้นตอนที่ 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
• --target-param-data-ratio=8: การฝึกที่ไม่สมบูรณ์เล็กน้อยเพื่อความเร็ว
• --device-batch-size=16: ขนาดแบทช์ต่อ GPU
• --fp8: เปิดใช้งานการฝึก FP8 (สำหรับ H100+ เท่านั้น)

ระยะเวลาที่คาดไว้: ประมาณ 2 ชั่วโมง

ขั้นตอนที่ 5: การปรับแต่งด้วยการควบคุม (Supervised Finetuning)

# ดาวน์โหลดบทสนทนาตัวตน
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
python -m scripts.chat_cli -p "Why is the sky blue?"

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

Web UI จะทำงานบนพอร์ต 8000 และมีอินเทอร์เฟซที่เหมือน ChatGPT

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

สำหรับการทดสอบแนวคิดใหม่ๆ ให้ใช้โมเดลขนาดเล็กกว่าเพื่อการวนซ้ำที่เร็วขึ้น

การทดลองอย่างรวดเร็ว (ประมาณ 5 นาที)

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) ด้วยการบันทึกที่น้อยที่สุด เหมาะสำหรับการทดสอบการเปลี่ยนแปลงสถาปัตยกรรม

เมตริกที่ต้องติดตาม

ติดตามสิ่งเหล่านี้ใน Weights & Biases:

1. val_bpb: บิตต่อไบต์ในการตรวจสอบความถูกต้อง (ค่า Loss ที่ไม่ขึ้นกับขนาดของคำศัพท์)
2. core_metric: คะแนนการประเมิน DCLM CORE
3. train/mfu: การใช้ Model FLOPS (ประสิทธิภาพฮาร์ดแวร์)
4. train/tok_per_sec: อัตราการประมวลผลในการฝึก

ข้อกำหนดในการทดสอบ

การปรับปรุงใดๆ ต้องทำงานได้ในทุกระดับความลึก (d12 ถึง d26) สิ่งนี้ช่วยป้องกันการ Overfitting กับขนาดโมเดลเดียว และรับประกันความก้าวหน้าตามหลักการ

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

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

สิ่งนี้ทำให้การฝึก LLM อยู่ในขอบเขตของ:

• นักวิจัยแต่ละคน
• สตาร์ทอัพขนาดเล็ก
• หลักสูตรมหาวิทยาลัย
• ผู้ที่สนใจทั่วไป

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

โค้ดเบสนี้ทำหน้าที่เป็นแหล่งเรียนรู้:

• ประมาณ 500 บรรทัดสำหรับโมเดล GPT
• ประมาณ 530 บรรทัดสำหรับตัวปรับปรุง
• คำอธิบายที่ชัดเจนสำหรับทุกการตัดสินใจออกแบบ
• ไม่มีการกำหนดค่าที่ซ่อนอยู่

นักเรียนสามารถอ่าน แก้ไข และทดลองกับไปป์ไลน์ LLM ที่สมบูรณ์ได้

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

การลดระยะเวลาการฝึกจากหลายวันเหลือเพียงไม่กี่ชั่วโมงช่วยให้:

• การทดสอบสมมติฐานเร็วขึ้น
• การทดลองได้มากขึ้นในแต่ละสัปดาห์
• ลดต้นทุนของความล้มเหลว
• การทำงานร่วมกันในชุมชนผ่านกระดานผู้นำ

ความโปร่งใส

ทุกทางเลือกในการออกแบบมีการจัดทำเป็นเอกสาร:

• Scaling laws ใน dev/LOG.md
• Ablation studies ใน GitHub Discussions
• รายละเอียดการจำลองแบบเต็มสำหรับการบันทึกในกระดานผู้นำ
• การเปิดเผยการมีส่วนร่วมของ AI อย่างชัดเจน

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

nanochat น่าประทับใจ แต่ก็มีขอบเขตที่ชัดเจน

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

ตัวเลข 48 ดอลลาร์นี้สมมติว่าคุณสามารถเข้าถึงโหนด 8xH100 ได้ ค่าเช่าคลาวด์แตกต่างกันไป:

• Lambda Labs: ประมาณ $25/ชั่วโมง สำหรับ 8xH100
• RunPod: ประมาณ $15/ชั่วโมง สำหรับราคาแบบ Spot
• ระยะเวลาการรันทั้งหมด: ประมาณ 2 ชั่วโมงสำหรับการฝึกก่อน + SFT

คุณจะต้องใช้งบประมาณประมาณ $50-100 สำหรับการรันเต็มรูปแบบ ขึ้นอยู่กับผู้ให้บริการ

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

nanochat มีประสิทธิภาพเทียบเท่า GPT-2 (เทคโนโลยีปี 2019) ซึ่งหมายความว่า:

สิ่งที่ทำได้:

• การสนทนาพื้นฐาน
• การให้เหตุผลอย่างง่าย
• คณิตศาสตร์เบื้องต้น
• การจำข้อมูลเชิงข้อเท็จจริง (จำกัด)

สิ่งที่ไม่สามารถทำได้:

• การให้เหตุผลหลายขั้นตอนที่ซับซ้อน
• การสร้างโค้ดที่ซับซ้อนกว่าฟังก์ชันง่ายๆ
• การปฏิบัติตามคำสั่งที่ละเอียดอ่อน
• แข่งขันกับ GPT-4, Claude หรือ Gemini ไม่ได้

ลองนึกภาพว่าเป็นเด็กอนุบาล: สามารถสนทนาพื้นฐานได้ แต่ไม่สามารถทำงานระดับผู้เชี่ยวชาญได้

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

การรันแบบ Speedrun เต็มรูปแบบจะดาวน์โหลด:

• Shard ข้อมูลประมาณ 170 ชิ้น
• ประมาณ 17 GB (แบบบีบอัด)
• ตัวอักษรทั้งหมดประมาณ 2 พันล้านตัว

คุณจะต้องมีพื้นที่จัดเก็บและแบนด์วิดท์ที่เพียงพอ

ข้อจำกัดของเมตริก

คะแนน CORE วัด 22 งาน แต่ไม่ครอบคลุมถึง:

• คุณภาพการสนทนาในโลกแห่งความเป็นจริง
• ความรู้เฉพาะทาง
• ความละเอียดอ่อนของการปฏิบัติตามคำสั่ง
• ความปลอดภัยและการจัดแนว

Seed สุ่มที่แตกต่างกันทำให้เกิดความแปรปรวนของ CORE ประมาณ 0.016 ผลลัพธ์ของคุณอาจแตกต่างกันไป

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

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

ประมาณ $48 แบบ On-demand ($24/ชั่วโมง × 2 ชั่วโมง) หรือประมาณ $15 บน Spot Instances ซึ่งครอบคลุมเฉพาะการฝึกก่อนเท่านั้น เพิ่มเวลาประมาณ 30 นาทีสำหรับการทำ SFT

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

ขั้นต่ำ: GPU เดี่ยว (GPU ดาต้าเซ็นเตอร์สมัยใหม่ใดก็ได้) เหมาะสมที่สุด: 8xH100 หรือ 8xA100 เพื่อการฝึกที่เร็วที่สุด โค้ดสามารถปรับขนาดได้ตั้งแต่ 1 GPU ถึง 8 GPU พร้อมการสะสม Gradient โดยอัตโนมัติ

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

1.65 ถึง 3 ชั่วโมง ขึ้นอยู่กับการตั้งค่าและฮาร์ดแวร์ สถิติกระดานผู้นำปัจจุบันคือ 1.65 ชั่วโมงสำหรับโมเดล d24

CORE metric คืออะไร?

คะแนน DCLM CORE ประเมินโมเดลใน 22 งาน รวมถึง ARC (คำถามวิทยาศาสตร์), MMLU (ความเข้าใจภาษาแบบหลายงาน) และมาตรฐานอื่นๆ GPT-2 ได้คะแนน 0.256525 nanochat ทำคะแนนได้เกิน 0.26 เป็นประจำ

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

ได้ หากละเว้น torchrun โค้ดจะใช้ Gradient Accumulation โดยอัตโนมัติ การฝึกจะใช้เวลานานขึ้น 8 เท่า แต่ให้ผลลัพธ์ที่เกือบจะเหมือนกัน

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

เวอร์ชันที่ดีที่สุดในปัจจุบันใช้ ClimbMix (ชุดข้อมูลเว็บที่ได้รับการคัดสรรของ NVIDIA) เวอร์ชันก่อนหน้าใช้ FineWeb-EDU Tokenizer จะฝึกบนตัวอักษรประมาณ 2 พันล้านตัวจากประมาณ 8 Shard แรก

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

ได้ โค้ดรันบน MPS (Metal Performance Shaders) ด้วยความแม่นยำ float32 การฝึกจะช้ากว่า CUDA แต่ใช้งานได้สำหรับการทดลอง

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

ได้ ใช้ --resume-from-step=<step> เพื่อฝึกต่อจาก Checkpoint ที่บันทึกไว้ สถานะของ Dataloader ก็ถูกบันทึกไว้เช่นกันเพื่อให้สามารถกลับมาดำเนินการต่อได้อย่างแม่นยำ

nanochat และ nanoGPT แตกต่างกันอย่างไร?

nanoGPT ครอบคลุมเฉพาะการฝึกก่อนเท่านั้น nanochat ขยายไปถึงไปป์ไลน์ทั้งหมด: การสร้างโทเค็น, การฝึกก่อน, SFT, RLHF, การประเมินผล, การอนุมาน และ Web UI

บทสรุป

nanochat พิสูจน์ให้เห็นว่าการฝึก LLM ไม่จำเป็นต้องใช้งบประมาณมหาศาลหรือโครงสร้างพื้นฐานเฉพาะทางอีกต่อไป สิ่งที่เคยมีค่าใช้จ่าย 43,000 ดอลลาร์ในปี 2019 ตอนนี้มีค่าใช้จ่ายไม่ถึง 50 ดอลลาร์

ผลกระทบของโปรเจกต์นี้ขยายไปไกลกว่าการลดต้นทุนดิบ ด้วยการจัดหาโค้ดเบสที่เรียบง่าย อ่านง่าย และมีอินเทอร์เฟซแบบ “ตัวควบคุมเดียว” Karpathy ได้สร้างทั้งเครื่องมือวิจัยและแหล่งการเรียนรู้

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

• ลดต้นทุน 100 เท่า: จาก $43,000 เหลือ $48 สำหรับความสามารถระดับ GPT-2
• เร่งความเร็ว 100 เท่า: จาก 168 ชั่วโมง เหลือ 1.65 ชั่วโมง
• ตัวควบคุมการตั้งค่าเดียว: --depth ควบคุมทุกอย่าง
• ไปป์ไลน์ที่สมบูรณ์: ตั้งแต่การสร้างโทเค็นไปจนถึง Web UI
• ขับเคลื่อนโดยชุมชน: กระดานผู้นำสาธารณะพร้อมการปรับปรุงอย่างต่อเนื่อง

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

พร้อมที่จะฝึกโมเดลของคุณเองแล้วหรือยัง? เริ่มต้นด้วย nanochat repository และสคริปต์ runs/speedrun.sh

สำหรับนักพัฒนา API ที่สร้างแอปพลิเคชันที่ขับเคลื่อนด้วย AI การทำความเข้าใจหลักการทำงานภายในของการฝึก LLM ไม่เคยเข้าถึงได้ง่ายเท่านี้มาก่อน อุปสรรคในการเข้าสู่ตลาดได้ลดลงจาก “สตาร์ทอัพที่ได้รับการสนับสนุนจาก Venture Capital” กลายเป็น “โปรเจกต์สำหรับวันหยุดสุดสัปดาห์”