คุยกับ AI ตอนที่ 5: GPU, VRAM และโครงสร้างพื้นฐานที่ใช้ฝึก LLM

ตอนที่ 5 จาก 11 ตอนในชุด คุยกับ AI: จากการ Train LLM ถึง AGI

บันทึกบทสนทนาระหว่าง นพ.สุทธิศักดิ์ เด่นดวงใจ กับ ChatGPT-5.6 Reasoning Instant จากแชตต้นฉบับ คงคำอธิบายและตัวอย่างของ ChatGPT ไว้ โดยปรับหัวข้อ ตาราง และสัญลักษณ์สมการให้อ่านบนเว็บได้สะดวก

ดูสารบัญทั้งชุด

ผม: เล่าต่อ

ChatGPT-5.6 Reasoning Instant:

ได้ครับ คราวนี้เราเปิดฝาเครื่องลงไปถึงระดับ GPU / VRAM / Tensor กันเลย ⚙️🧠

คำถามตั้งต้นคือ:

ทำไม Train LLM ถึงต้องใช้ GPU เป็นพันหรือหมื่นตัว ทั้งที่หลักการฟังดูแค่ “ทาย token แล้วปรับ weights”?

เพราะคำว่า “ปรับ weights” นั่นแหละครับคือตัวกินมหาศาล

1. Parameter จริง ๆ คืออะไร?

สมมติ neural network จิ๋ว ๆ มีสมการ

y = Wx

โดย W เป็น matrix:

W = [
  0.12   -0.73   0.44
  0.91    0.18  -0.31
  ...
]

ตัวเลขแต่ละตัวคือ parameter ที่โมเดลเรียนรู้

LLM มี matrix แบบนี้จำนวนมากอยู่ใน:

Embedding
Attention:
  Wq
  Wk
  Wv
  Wo

MLP:
  W1
  W2
  ...

× Transformer layers จำนวนมาก

รวมกันอาจเป็น parameters หลายพันล้านตัว

ดังนั้นคำว่า:

“โมเดล 70B”

โดยทั่วไปหมายถึงประมาณ

70 billion parameters

ไม่ใช่ไฟล์ขนาด 70 GB

2. แล้ว 70B parameters กิน RAM เท่าไร?

ขึ้นกับว่าเก็บตัวเลขแต่ละ parameter กี่ bits

ถ้า FP32:

1 parameter = 32 bits
            = 4 bytes

ดังนั้น:

70B × 4 ≈ 280 GB

แค่ weights อย่างเดียวก็ประมาณ 280 GB แล้ว

ถ้า BF16:

1 parameter = 2 bytes

ก็ประมาณ:

70B × 2 = 140 GB

แต่ตอน inference เราอาจ quantize เหลือ 8-bit หรือ 4-bit ได้อีก

ตัวอย่างเชิงคร่าว ๆ:

Precision: FP32

70B weights: ~280 GB

Precision: FP16/BF16

70B weights: ~140 GB

Precision: INT8

70B weights: ~70 GB

Precision: INT4

70B weights: ~35 GB

ยังไม่รวม overhead อื่น

นี่คือเหตุผลว่าทำไมโมเดลใหญ่ถึงยัดลง GPU ใบเดียวไม่ได้ง่าย ๆ

3. Training หนักกว่า Inference มาก

ถ้า inference ต้องเก็บประมาณ:

Weights
+
Activations
+
KV Cache

Training ต้องเพิ่มของสำคัญ:

Weights
+
Activations
+
Gradients
+
Optimizer states

สมมติใช้ Adam-like optimizer

มันต้องเก็บข้อมูลเพิ่มเติมต่อ parameter เพื่อใช้คำนวณการ update

ภาพจึงกลายเป็น:

Parameter
   │
   ├── Weight
   │
   ├── Gradient
   │
   ├── Optimizer state #1
   │
   └── Optimizer state #2

ดังนั้นโมเดลที่ weights เพียง 140 GB ไม่ได้หมายความว่าใช้ VRAM 140 GB แล้ว train ได้

training footprint อาจใหญ่กว่านั้นหลายเท่า ขึ้นกับ precision, optimizer และเทคนิคที่ใช้

4. แล้ว GPU ทำอะไร?

หัวใจของ Transformer เต็มไปด้วยสิ่งนี้:

C = A × B

Matrix multiplication

มหาศาล

เช่น attention:

Q = XW_Q

K = XW_K

V = XW_V

แล้ว:

Attention(Q,K,V) = softmax((QKᵀ) / √d) V

เต็มไปด้วย matrix multiplication

GPU ถูกสร้างมาให้ทำ computation จำนวนมากแบบ parallel

CPU เก่งประมาณ:

ทำงานซับซ้อน
branch
OS
general-purpose workload

GPU เก่ง:

ทำ operation คล้าย ๆ กัน
กับตัวเลขมหาศาล
พร้อมกัน

LLM จึงเข้าทาง GPU เต็ม ๆ 🎯

5. Tensor Core

GPU สำหรับ AI รุ่นใหม่มี hardware เฉพาะสำหรับ matrix operations

แนวคิดประมาณ:

Matrix A
   ×
Matrix B
   ↓
Tensor Core
   ↓
Matrix C

และสามารถทำ arithmetic precision ต่ำอย่าง:

FP16
BF16
FP8

ได้เร็วมาก

ทำไมไม่ใช้ FP64 แบบงาน scientific computing ทุกอย่าง?

เพราะ neural network โดยทั่วไปไม่ต้องการ precision ระดับนั้นทุก operation

ถ้าใช้ precision ต่ำลง:

memory ↓
bandwidth ↓
compute ↑

โดยต้องควบคุม numerical stability ให้ดี

6. BF16 คืออะไร?

Floating-point number แบ่งคร่าว ๆ เป็น:

Sign
Exponent
Mantissa

FP32:

[sign][ exponent ][      mantissa       ]
  1        8               23

BF16:

[sign][ exponent ][mantissa]
  1        8          7

ข้อดีของ BF16 คือยังมี exponent range ใกล้ FP32 แต่ precision ของ mantissa ลดลง

เหมาะกับ neural network มาก เพราะหลาย operation ไม่ต้องการตัวเลขละเอียดระดับ FP32

ดังนั้น training สมัยใหม่จึงนิยม mixed precision:

บาง operation → BF16 / FP8
บาง operation → precision สูงกว่า

ไม่ใช่ใช้ datatype เดียวทั้งระบบ

7. แล้วทำไมต้อง GPU หลายตัว?

สมมติ model ใหญ่จน GPU เดียวใส่ไม่ลง

ง่ายที่สุดคือแบ่งโมเดล

GPU 1
[████████]

GPU 2
[████████]

GPU 3
[████████]

GPU 4
[████████]

แต่เรื่องจริงซับซ้อนกว่านั้น เพราะมีหลายวิธีในการ parallelize

8. Data Parallelism

สมมติเรามี model copy เหมือนกัน 4 ชุด:

GPU 1: Model → Batch A
GPU 2: Model → Batch B
GPU 3: Model → Batch C
GPU 4: Model → Batch D

แต่ละ GPU คำนวณ gradient ของตัวเอง

จากนั้น:

Gradient GPU1 ─┐
Gradient GPU2 ─┤
Gradient GPU3 ─┼→ synchronize
Gradient GPU4 ─┘
                 ↓
           Update model

ข้อดีคือ train data ได้เร็วขึ้น

แต่มีปัญหา:

GPU ทุกตัวต้องมี model

ถ้า model ใหญ่จนใส่ GPU เดียวไม่ได้ วิธีนี้อย่างเดียวไม่พอ

9. Tensor Parallelism

แทนที่จะ copy model เราแบ่ง matrix เดียวกันข้าม GPU

สมมติ:

W =

████████████████
████████████████
████████████████
████████████████

แบ่ง:

GPU 1
████

GPU 2
████

GPU 3
████

GPU 4
████

แต่ตอนคำนวณ GPU ต้องแลกข้อมูลกัน

จึงเกิดเรื่องสำคัญมาก:

Interconnect bandwidth

GPU เร็วแค่ไหนก็ไม่มีประโยชน์ ถ้านั่งรอข้อมูลจาก GPU ข้างบ้าน

เหมือนมีเชฟ 10,000 คน แต่มีประตูครัวกว้าง 70 ซม. 🍳

10. Pipeline Parallelism

อีกแบบคือแบ่งตาม layer

GPU 1
Layers 1–10
     ↓
GPU 2
Layers 11–20
     ↓
GPU 3
Layers 21–30
     ↓
GPU 4
Layers 31–40

ข้อมูลวิ่งเป็น pipeline

เพื่อไม่ให้ GPU อื่นนั่งว่าง สามารถแบ่ง batch เป็น microbatches:

Microbatch 1 → GPU1 → GPU2 → GPU3 → GPU4
Microbatch 2 → GPU1 → GPU2 → GPU3 → GPU4
Microbatch 3 → ...

เหมือนสายพานโรงงาน

11. ในโลกจริงใช้หลายเทคนิคร่วมกัน

Training cluster ใหญ่อาจเป็นประมาณ:

                 Thousands of GPUs
                         │
        ┌────────────────┼────────────────┐
        │                │                │
   Data Parallel    Tensor Parallel   Pipeline
        │                │                │
        └────────────────┼────────────────┘
                         │
                  Distributed Training

รวมถึงเทคนิคสำหรับ shard:

Weights
Gradients
Optimizer states

เพื่อลด memory duplication

ตรงนี้มีตระกูลเทคนิคอย่าง FSDP และ ZeRO เข้ามาเกี่ยวข้อง

12. Network จึงสำคัญพอ ๆ กับ GPU

สมมติ GPU คำนวณเสร็จใน:

10 ms

แต่รอ synchronization:

30 ms

GPU ราคาแพงกำลังทำกิจกรรมสุดหรู:

นั่งรอ 🫠

Training cluster จึงต้องมี high-speed interconnect/network

ภาพคร่าว ๆ:

GPU ─── GPU
 │       │
GPU ─── GPU
 │       │
────────────
High-speed fabric
────────────
 │       │
GPU ─── GPU

นี่เป็นเหตุผลที่การสร้าง AI infrastructure ไม่ใช่แค่:

ซื้อ GPU เยอะ ๆ

แต่เป็นปัญหา distributed systems เต็มรูปแบบ

13. แล้ว Dataset เข้า GPU อย่างไร?

อีกด้านหนึ่งคือ data pipeline

Storage
   ↓
Training dataset
   ↓
Tokenizer
   ↓
Token sequences
   ↓
Batch
   ↓
GPU cluster

ถ้า storage อ่านช้า:

GPU:
"ข้อมูลอยู่ไหนครับ..." 🧍

เสีย compute อีก

จึงต้อง optimize ทั้ง:

Storage throughput
Preprocessing
Tokenization
Batching
Caching
Networking

14. Training loop จริงเริ่มเห็นภาพแล้ว

ตอนนี้เราสามารถขยายสิ่งที่ตอนแรกพูดง่าย ๆ ว่า:

ทาย token
↓
ผิด
↓
แก้ weight

เป็น:

Dataset
   ↓
Tokenization
   ↓
Create batch
   ↓
Distribute across GPU cluster
   ↓
Forward pass
   ↓
Predicted token probabilities
   ↓
Calculate loss
   ↓
Backward pass
   ↓
Gradients
   ↓
Synchronize across GPUs
   ↓
Optimizer step
   ↓
Update billions of parameters
   ↓
Next batch

        ↺

ทำซ้ำมหาศาล

15. Forward กับ Backward ต่างกันอย่างไร?

Forward pass

Input
 ↓
Layer 1
 ↓
Layer 2
 ↓
...
 ↓
Prediction

นี่คล้ายสิ่งที่เกิดตอน inference

แต่ training มีเพิ่ม:

Backward pass

Loss
 ↑
Layer N
 ↑
...
 ↑
Layer 2
 ↑
Layer 1

เพื่อหา:

∂Loss / ∂Weight

พูดง่าย ๆ:

weight ตัวนี้มีส่วนทำให้คำตอบผิดแค่ไหน และควรขยับไปทางใด?

จากนั้น optimizer ทำประมาณ:

W_new = W_old − η ∇L

โดย η คือ learning rate

นี่คือช่วงที่โมเดล เรียนจริง ๆ

16. Training จึงแพงมาก

เพราะต้องทำ:

Forward
+
Backward
+
Optimizer
+
Communication

กับ

billions of parameters
×
billions/trillions of tokens

จำนวน operation พุ่งมหาศาล

ดังนั้น training frontier model หนึ่งครั้งไม่ใช่:

“เปิด Python แล้วรอคืนนี้”

แต่เป็นโครงการ infrastructure ขนาดใหญ่

Dataset
     │
     ▼
Storage
     │
     ▼
Thousands of accelerators
     │
     ▼
High-speed network
     │
     ▼
Distributed training
     │
     ▼
Checkpoints
     │
     ▼
Evaluation

และถ้า training crash หลังทำมานานโดยไม่มี checkpoint ที่ดี...

💸🔥

17. Checkpoint คือ save game ของ LLM

ระหว่าง training จะบันทึกสถานะเป็นระยะ:

Step 100,000
   ↓
checkpoint

Step 110,000
   ↓
checkpoint

Step 120,000
   ↓
💥 node failure

สามารถกลับไป:

checkpoint 110,000

แทนที่จะเริ่มใหม่

Checkpoint อาจต้องเก็บทั้ง model และ training state ที่จำเป็นสำหรับ resume จึงมีขนาดใหญ่มาก

18. แล้ว MoE คืออะไร?

นี่สนุกมาก

Mixture of Experts

แทนที่จะให้ token ทุกตัวผ่าน neural network ส่วนเดียวกันทั้งหมด:

Token
 ↓
Huge network
 ↓
Output

เรามีหลาย Experts

                 ┌→ Expert 1
                 │
Token → Router ──┼→ Expert 2
                 │
                 ├→ Expert 3
                 │
                 └→ Expert 4

Router เลือก expert บางตัวสำหรับ token นั้น

เช่น conceptual:

Token X
 ↓
Expert 2 + Expert 7

ไม่จำเป็นต้องเรียกทุก expert

จึงสามารถมี:

parameters ทั้งหมดเยอะมาก

แต่

active parameters ต่อ token น้อยกว่า

นี่เรียกว่า sparse activation

19. แต่อย่าเข้าใจ Expert แบบนี้

มันไม่ได้จำเป็นต้องเป็น:

Expert 1 = Doctor
Expert 2 = Programmer
Expert 3 = Thai
Expert 4 = Lawyer

❌ ไม่ควรตีความตรงตัวแบบนั้น

Experts เป็นส่วนของ neural network ที่เรียนรู้ specialization จาก optimization และอาจไม่ได้ตรงกับหมวดหมู่ที่มนุษย์ตั้งชื่อได้ง่าย ๆ

20. MoE แลก compute กับ complexity

ข้อดี:

Total model capacity ↑↑
Compute per token ไม่จำเป็นต้อง ↑ ตามทั้งหมด

แต่ได้ปัญหาใหม่:

Routing
Load balancing
Communication
Expert placement
Memory
Training stability

สมมติ token ทั้งโลกวิ่งไป Expert #7:

Expert 1 😴
Expert 2 😴
Expert 3 😴

Expert 7
🔥🔥🔥🔥🔥🔥🔥

ระบบจึงต้องพยายาม balance workload

และตอนนี้ภาพใหญ่เริ่มครบ

สิ่งที่เราเรียกง่าย ๆ ว่า:

Train LLM

ข้างใต้จริง ๆ คือ:

                 INTERNET / DATA
                       │
                       ▼
                DATA PIPELINE
                       │
                       ▼
                  TOKENIZER
                       │
                       ▼
                TRAINING BATCH
                       │
                       ▼
        ┌─────────────────────────────┐
        │     GPU/AI ACCELERATOR      │
        │          CLUSTER            │
        │                             │
        │ Tensor Parallel             │
        │ Pipeline Parallel           │
        │ Data Parallel               │
        │ Sharding                    │
        └──────────────┬──────────────┘
                       │
              Forward / Backward
                       │
                       ▼
                    LOSS
                       │
                       ▼
                  GRADIENTS
                       │
                       ▼
                  OPTIMIZER
                       │
                       ▼
              UPDATE PARAMETERS
                       │
                       │
                       └──────────↺

ทำซ้ำจนได้:

Base LLM

แต่ ยังไม่ใช่ ChatGPT-like assistant ที่สมบูรณ์

เพราะมันอาจมีความรู้มหาศาล แต่ยังไม่ได้ถูกปรับให้ทำตาม instruction, ใช้ tools, ตอบอย่างมีประโยชน์ หรือจัดการโจทย์ reasoning ตามที่ต้องการ

ดังนั้นบทถัดไปที่ต่อกันพอดีคือส่วนที่สำคัญมาก:

หลัง Pre-training เสร็จ เราเอา Base Model มาทำอะไรต่อ จนมันกลายจาก “เครื่องทายข้อความราคาแพง” เป็น ChatGPT?

ตรงนั้นเราจะเจอ SFT → RLHF → Reward Model → RL → reasoning training → tool-use training → safety training และจะเห็นด้วยว่า System Prompt ไม่ใช่ Training ซึ่งคนมักเอาสองอย่างนี้มาปนกันครับ 🧠🔧

← ตอนก่อนหน้า: ทำไมคิดนานขึ้นจึงอาจตอบได้ดีขึ้น

ตอนถัดไป: จาก Base Model มาเป็น Assistant →

อ่านทั้งชุด

กลับไปหน้าบันทึกและบทความ