คุยกับ AI ตอนที่ 2: ทาย token ถัดไป แล้วเขียนโปรแกรมได้อย่างไร

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

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

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

ผม: เล่าต่อ

ChatGPT-5.6 Reasoning Instant:

ได้เลย จุดนี้คือส่วนที่น่าสนใจที่สุดของ LLM 🧠 เพราะคำถามสำคัญคือ

ถ้ามันถูก Train แค่ให้ทาย token ถัดไป แล้วทำไมสุดท้ายมันถึงเขียนโปรแกรม แปลภาษา สรุปบทความ หรือแก้โจทย์ที่ไม่เคยเห็นได้?

คำตอบสั้น ๆ คือ ถ้าจะทำนายข้อความได้เก่งมากพอ โมเดลถูกบีบให้สร้าง representation ของสิ่งที่อยู่เบื้องหลังข้อความขึ้นมา

จาก Next-token prediction ไปสู่ "ความเข้าใจ"

ลองให้โมเดลเติมประโยคนี้:

John put the ice cream on the table and left it there for five hours. When he returned, the ice cream was ____

ถ้าจะตอบ melted ให้แม่น โมเดลต้องจับความสัมพันธ์หลายอย่างพร้อมกัน:

ice cream
   ↓
temperature
   ↓
room conditions
   ↓
time = 5 hours
   ↓
solid → liquid

มันไม่ได้ถูกสอนตรง ๆ ว่า

RULE #492:
ice cream + room temperature + 5 hours = melted

แต่ถ้าโมเดลไม่เรียนรู้ pattern ประมาณนี้ มันจะทำนายข้อความจำนวนมากใน training data ได้ไม่ดี

ยิ่งต้องทำนายข้อความหลากหลายมหาศาล มันยิ่งต้องสร้าง internal representations ที่มีประโยชน์มากขึ้น

แล้ว Transformer ทำอะไร?

นี่คือเครื่องยนต์หลัก

สมมติผมเขียนว่า:

The animal didn't cross the street because it was too tired.

คำว่า it หมายถึงอะไร?

Transformer ใช้กลไกสำคัญที่เรียกว่า Attention

แบบง่ายมาก:

                    ┌── animal
                    │
The animal ... because it was too tired
                       │
                       └──── Attention

ตอนประมวลผล it โมเดลสามารถให้น้ำหนักกับ token ก่อนหน้าแตกต่างกัน

animal     ██████████
street     ██
cross      █
because    █

แต่ละ attention head สามารถเรียนรู้ pattern ต่างกันได้

บาง head อาจสนใจ:

Pronoun → noun

อีกตัวอาจจับ:

Subject → verb

อีกตัว:

Opening bracket → closing bracket

อีกตัวอาจเรียนรู้ dependency ใน code:

var customer = GetCustomer();

Console.WriteLine(customer.Name);
                  ↑
             customer

และ Transformer มี หลาย layer

จึงเกิดการประมวลผลต่อเนื่องประมาณ:

Tokens
  ↓
Layer 1
  ↓
Layer 2
  ↓
Layer 3
  ↓
...
  ↓
Layer N
  ↓
Next-token probabilities

ในแต่ละชั้น representation ถูกเปลี่ยนไปเรื่อย ๆ

Token เองก็ไม่ได้เป็น "คำ"

อันนี้สำคัญมาก

ข้อความ:

The cat is sleeping

จะถูก Tokenizer แปลงเป็น token IDs ก่อน เช่นในเชิงแนวคิด:

"The"       → 1234
" cat"      → 5678
" is"       → 318
" sleeping" → 9012

จากนั้นแต่ละ token ถูกแปลงเป็น vector

เช่นจาก

cat

กลายเป็นประมาณ:

[0.21, -0.81, 0.14, 0.53, ...]

ของจริงมีมิติสูงมาก

พื้นที่ vector นี้ทำให้โมเดลสามารถสร้าง representation ของความสัมพันธ์ต่าง ๆ ได้

เราอาจจินตนาการแบบหยาบมากว่า:

             animal
                ↑
       cat •    |    • dog
                |
                |
     car •      |           • horse
                |
────────────────────────────→ living thing

แต่ของจริงไม่ใช่กราฟ 2 มิติแบบนี้ เป็น high-dimensional space ที่ซับซ้อนกว่ามาก

แล้วมัน "เรียนรู้ concept" ได้อย่างไร?

สมมติ training data มีข้อความนับไม่ถ้วนเกี่ยวกับแมว:

Cats have four legs.

My cat is sleeping.

Cats are mammals.

The kitten chased a mouse.

Unlike dogs, cats...

ไม่มีใครบอก neural network ว่า

สร้าง concept ชื่อ CAT

แต่การสร้าง representation บางอย่างที่รวบรวมคุณสมบัติของ "cat" ทำให้มันลด Loss ได้

จึงเกิด concept ขึ้นจากแรงกดดันของ optimization

นี่เรียกกว้าง ๆ ว่า representation learning

แล้วความสามารถที่ดูเหมือน Reasoning มาจากไหน?

ลองดูโจทย์:

Alice has 5 apples. She gives Bob 2. How many remain?

คำตอบคือ 3

แต่ใน training data มีโจทย์ ตัวอย่างคำอธิบาย คณิตศาสตร์ code proofs และข้อความที่มีโครงสร้างเชิงเหตุผลจำนวนมาก

โมเดลจึงสามารถเรียนรู้ computational patterns เช่น:

initial quantity
      ↓
operation
      ↓
new quantity

หรือ:

5
↓
subtract 2
↓
3

เมื่อโมเดลใหญ่ขึ้น มีข้อมูลมากขึ้น และ training ดีขึ้น ความสามารถบางประเภทอาจปรากฏชัดขึ้น แม้เราไม่ได้สร้าง module ชื่อ:

reasoning.dll

ไว้ในโมเดล 😆

Code ยิ่งเห็นภาพชัด

สมมติ training data มี code จำนวนมหาศาล:

if (user == null)
{
    return;
}

และ

if user is None:
    return

และ

if (!user) {
    return;
}

ถ้าโมเดลต้อง predict code เหล่านี้ให้ดี มันไม่พอที่จะจำ syntax อย่างเดียว

มันจะได้ประโยชน์จากการจับ concept:

Check whether value exists
        ↓
If invalid
        ↓
Exit early

ดังนั้น representation บางส่วนจึงอยู่เหนือภาษาโปรแกรมหนึ่งภาษา

นี่ทำให้เกิดสิ่งที่น่าสนใจ:

C#
 │
 │
 ├──────→ underlying concept ←──── Python
 │
 │
JavaScript

จึงสามารถขอว่า:

Convert this C# algorithm to Python

แม้ Python output นั้นอาจไม่เคยปรากฏแบบตรงตัวใน training set

นี่นำไปสู่ Generalization

นี่คือเรื่องใหญ่กว่าการจำ

สมมติโมเดลเคยเห็น:

2 + 3 = 5
4 + 7 = 11
10 + 5 = 15

ถ้ามันเรียนรู้เพียง lookup table:

2+3 → 5
4+7 → 11

มันจะพังเมื่อเจอสิ่งใหม่

แต่ถ้ามันเรียนรู้ pattern ของ addition ได้ในระดับหนึ่ง มันสามารถจัดการ input ใหม่ได้

13 + 8

นี่คือ generalization

แน่นอนว่า LLM ไม่ได้ generalize สมบูรณ์ และ arithmetic ของโมเดลก็มีข้อจำกัด โดยเฉพาะเมื่อโจทย์ซับซ้อนหรือยาว

แล้ว Scaling เข้ามาเกี่ยวตรงไหน?

นักวิจัยพบว่าพอเพิ่มองค์ประกอบอย่าง

Model parameters ↑
Training data ↑
Compute ↑
Training quality ↑

โดยทั่วไป loss ลดลงและความสามารถเพิ่มขึ้น

โมเดลเล็กอาจทำได้แค่:

autocomplete

ใหญ่ขึ้น:

เขียน paragraph

ใหญ่ขึ้นอีก:

summarize

translate

code

solve problems

follow complicated instructions

แต่ปัจจุบันไม่ควรคิดว่า "parameters เยอะกว่า = ฉลาดกว่าเสมอ"

เพราะ architecture, data quality, post-training, inference-time compute, tools และ training recipe มีผลมหาศาลเช่นกัน

จุดที่ชวนงงที่สุด 🤯

ระหว่าง training ไม่มี programmer นั่งเขียนว่า:

model.learn("economics")
model.learn("C#")
model.learn("Thai")
model.learn("medicine")
model.learn("sarcasm")

Programmer กำหนด architecture และ training objective

ประมาณง่ายสุดว่า:

อ่านข้อความ
      ↓
ทาย token ต่อไป
      ↓
ผิดเท่าไร?
      ↓
ปรับ parameters
      ↓
ทำใหม่

ทำซ้ำใน scale มหาศาล

แล้วโครงสร้างภายในจำนวนมาก เกิดจากการเรียนรู้

แต่ตรงนี้ต้องระวังคำว่า "เข้าใจ"

มี debate ใหญ่มากว่า LLM เข้าใจจริงหรือไม่

มุมหนึ่งบอกว่า:

มันเป็น statistical model ที่เก่งมากในการสร้างภาษา ไม่ได้เข้าใจโลกแบบมนุษย์

อีกมุมหนึ่งบอกว่า:

ถ้ามันสร้าง representations ของวัตถุ ความสัมพันธ์ เหตุและผล และใช้สิ่งเหล่านั้น generalize ได้ เราจะปฏิเสธทั้งหมดว่าไม่ใช่ความเข้าใจก็ง่ายเกินไป

ผมว่าคำอธิบายที่ปลอดภัยกว่าคือ:

LLM มี internal representations ที่รองรับพฤติกรรมบางอย่างซึ่งเราเรียกว่า reasoning และ understanding ได้ แต่ไม่ควรสมมติว่ากระบวนการภายในหรือประสบการณ์ของมันเหมือนมนุษย์

และเรายังเข้าใจกลไกภายในของโมเดลขนาดใหญ่อย่างไม่สมบูรณ์

ทีนี้มีเรื่องที่เด็ดกว่านี้อีก

หลังจาก Train เสร็จแล้ว weights แทบไม่เปลี่ยนตอนที่เราคุยกับมัน

TRAINING
ข้อมูลมหาศาล
     ↓
เปลี่ยน weights
     ↓
████████████
     ↓
Finished model

INFERENCE
คุณถามคำถาม
     ↓
weights เดิม
     ↓
คำนวณ
     ↓
ตอบ

แล้วคำถามคือ...

ถ้า weights ไม่เปลี่ยน แล้วทำไม LLM อ่านสิ่งที่เราเพิ่งบอกไป 10 หน้าก่อน และดูเหมือน "เรียนรู้" จากมันได้ทันที?

ตรงนี้จะพาเราไปสู่ Context Window, In-Context Learning, KV Cache และ Attention ซึ่งเป็นคนละเรื่องกับ Training เลย และเป็นกุญแจสำคัญในการเข้าใจว่า ChatGPT ทำงานอย่างไรตอนเรากำลังคุยกันอยู่ 🧠⚡

← ตอนก่อนหน้า: การ Train LLM คืออะไร

ตอนถัดไป: Context, Attention และความจำระหว่างคุย →

อ่านทั้งชุด

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