คุยกับ AI ตอนที่ 3: Context, Attention และความจำระหว่างคุย

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

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

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

ผม: เล่าต่อ

ChatGPT-5.6 Reasoning Instant:

ต่อจากตรงนั้นเลยครับ 🧠⚡ จุดนี้ต้องแยกคำว่า “เรียนรู้” ออกเป็นสองแบบก่อน เพราะหน้าตาคล้ายกัน แต่เครื่องยนต์ข้างใต้คนละตัว

Training คือเปลี่ยน weights ของโมเดล ส่วน Inference / In-context learning คือ weights ไม่เปลี่ยน แต่โมเดลใช้ข้อมูลที่อยู่ใน context เพื่อคำนวณคำตอบปัจจุบัน

สมมติคุณบอกผมว่า:

ในโปรเจกต์นี้ Honk = ห่าน และ Quack = เป็ด

แล้วอีก 20 ข้อความต่อมาถามว่า:

Honk เป็นตัวอะไร?

ผมตอบว่า “ห่าน” ได้ โดยไม่จำเป็นต้อง train โมเดลใหม่เลย

ภาพรวมเป็นแบบนี้:

Training
────────
Training data
     ↓
Gradient descent
     ↓
เปลี่ยน weights
     ↓
Model

Conversation
────────────
Model + Context
       ↓
    Inference
       ↓
     Answer

weights ไม่เปลี่ยน

Context Window คืออะไร?

เวลาคุณส่งข้อความมา โมเดลไม่ได้เห็นเฉพาะข้อความล่าสุด แต่ระบบสามารถส่งบริบทของการสนทนาที่เกี่ยวข้องเข้ามาด้วย

ประมาณว่า:

SYSTEM:
You are a helpful assistant...

USER:
ผมกำลังทำโปรเจกต์ TidySpace...

ASSISTANT:
...

USER:
ตรง DiskAnalyzer ควรแก้อะไร?

ASSISTANT:
...

ทั้งหมดถูก tokenize แล้วกลายเป็น sequence ขนาดใหญ่:

[token1][token2][token3] ... [token N]

จำนวน token สูงสุดที่โมเดลสามารถประมวลผลในลักษณะนี้เรียกว่า Context Window

นึกภาพง่าย ๆ ว่า weights คือ สมองที่ผ่านการศึกษาแล้ว ส่วน context คือ โต๊ะทำงานที่กำลังกางเอกสารอยู่

โต๊ะใหญ่ขึ้นก็เปิดเอกสารพร้อมกันได้มากขึ้น แต่ไม่ได้แปลว่าสมองถูก train ใหม่

แล้ว In-context Learning แปลกตรงไหน?

สมมติผมไม่เคยรู้ภาษาที่คุณประดิษฐ์ขึ้น:

Bloop = cat
Zarg = dog
Mep = runs

แล้วคุณให้ตัวอย่าง:

Bloop mep = The cat runs
Zarg mep  = The dog runs

จากนั้นถาม:

What does "Bloop" mean?

โมเดลสามารถ infer ได้ว่า:

Bloop → cat

โดย weights ไม่ได้เปลี่ยนเลย

นี่คือสิ่งที่เรียกว่า In-context learning

น่าสนใจตรงที่ training สอนโมเดลให้มีความสามารถในการ เรียน pattern จาก context ณ เวลาที่ใช้งาน

พูดอีกแบบ:

Training ไม่ได้สอนแค่ “คำตอบ” แต่มันสามารถสร้างเครื่องจักรที่เรียนรู้ pattern ใหม่จาก prompt ได้ด้วย

Attention คือกลไกที่ทำให้มันหยิบข้อมูลกลับมาใช้

กลับไปตัวอย่าง:

Honk = goose
Quack = duck

...ข้อความอีกมากมาย...

What animal is Honk?

เมื่อโมเดลประมวลผล Honk ในคำถาม Attention สามารถเชื่อมโยงกับข้อมูลก่อนหน้า:

                 ┌─────────────────────┐
                 ↓                     │
Honk = goose ... ... ... What is Honk?
        ███████████████████████████████
             attention

แต่ไม่ได้หมายความว่ามี database query แบบ:

SELECT value
FROM conversation
WHERE key = 'Honk';

มันเป็นการคำนวณทาง neural network

Q, K, V คืออะไร?

นี่คือหัวใจของ Transformer ที่ชื่อดูเหมือนแก๊งบอสสามตัว 😄

Attention ใช้สิ่งที่เรียกว่า:

Query, Key, Value

แนวคิดคล้ายระบบค้นหา

สมมติมีข้อมูล:

Honk = goose

มันสร้าง representation ที่ทำหน้าที่ประมาณ:

Key:
"ข้อมูลเกี่ยวกับ Honk"

Value:
"ข้อมูลที่สัมพันธ์กับ goose"

ตอนเจอ:

What animal is Honk?

representation ปัจจุบันสร้าง Query

ประมาณ:

Query:
"ฉันต้องการข้อมูลเกี่ยวกับ Honk"

จากนั้น Attention เปรียบเทียบ Query กับ Keys:

Query
  │
  ├── "TidySpace"       0.02
  ├── "Windows"         0.05
  ├── "Honk = goose"    0.91  ← 👀
  └── "C#"              0.01

ของจริงเป็น matrix/vector mathematics ไม่ได้เป็นข้อความหรือ probability แบบตัวอย่างนี้ แต่ intuition ประมาณนี้ใช้ได้ดี

สูตรที่โด่งดังของ Transformer คือ:

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

มองแบบมนุษย์:

Q = ฉันกำลังหาอะไร?
K = ข้อมูลแต่ละชิ้นเกี่ยวกับอะไร?
V = ถ้าชิ้นนี้เกี่ยวข้อง เอาข้อมูลอะไรมาใช้?

แล้ว:

Q × K
  ↓
อันไหนสัมพันธ์กันมาก?
  ↓
softmax
  ↓
ให้น้ำหนัก
  ↓
ดึงส่วนของ V มาผสมกัน

นี่คือหนึ่งในกลไกพื้นฐานที่ทำให้ Transformer จัดการบริบทได้

แล้ว KV Cache คืออะไร?

ตรงนี้เกี่ยวกับ performance โดยตรง

สมมติ ChatGPT กำลังสร้าง:

The quick brown fox jumps over the lazy dog.

มันไม่ได้สร้างประโยคทั้งประโยคในครั้งเดียว

มันสร้างประมาณ:

The
 ↓
quick
 ↓
brown
 ↓
fox
 ↓
jumps
 ↓
...

หรือในความเป็นจริงคือทีละ token

ตอนสร้าง fox โมเดลต้องพิจารณา:

The quick brown

พอสร้าง token ต่อไป ถ้าคำนวณ representation ของ token เก่าทั้งหมดใหม่ทุกครั้งจะสิ้นเปลืองมาก

จึงเก็บ Key และ Value ของ token ก่อนหน้า เอาไว้

นี่คือ:

KV Cache

ประมาณ:

Token             Cached K/V
──────────────────────────────
The               ✓
quick             ✓
brown             ✓
fox               ✓
jumps             ← กำลังสร้าง

พอสร้าง token ถัดไปก็ reuse ของเดิม

จึงช่วยให้ autoregressive generation มีประสิทธิภาพมากขึ้น

Context Window กับ KV Cache จึงเกี่ยวกัน

ถ้า context ใหญ่มาก:

1k tokens
10k
100k
1M
...

โมเดลต้องจัดการข้อมูลเกี่ยวกับ token จำนวนมากขึ้น

และ KV cache ก็อาจใช้ memory มากขึ้นด้วย

ดังนั้น context ยาวไม่ใช่ของฟรี

มันมีต้นทุนด้าน:

Memory
Compute
Latency
Attention
Retrieval quality

และมีอีกประเด็นสำคัญ:

Context ใหญ่ ไม่ได้แปลว่าโมเดลจะใช้ทุก token ได้ดีเท่ากัน

โยน source code ล้าน token เข้าไปแล้วถามหนึ่งบรรทัด ไม่ได้การันตีว่ามันจะหา bug เจอ

นี่เป็นเหตุผลที่ระบบ agent และ coding assistant มักมี:

Search
Retrieval
File tools
grep
symbol search
RAG
summarization

แทนที่จะยัด repository ทั้งก้อนเข้า context

แล้ว Memory ของ ChatGPT ล่ะ?

ต้องแยกเป็นอีกเรื่องหนึ่ง

โดย concept:

              LLM
               │
       ┌───────┼────────┐
       ↓       ↓        ↓
    Weights  Context  External memory

Weights

ความรู้/ความสามารถที่ได้จาก training

ค่อนข้างถาวรจนกว่าจะมีการ train หรือปรับโมเดลอีก

Context

สิ่งที่โมเดลกำลังเห็นในการ inference ครั้งนั้น

"ตอนนี้เรากำลังคุยเรื่อง Transformer"

External memory

ระบบภายนอกสามารถเก็บข้อมูลบางอย่างแล้วนำกลับมาใส่ context ในอนาคต

ตัว LLM ไม่จำเป็นต้องเปลี่ยน weights

ดังนั้นคำว่า “ChatGPT จำผมได้” ไม่ควรตีความว่า:

GPT weights
   ↓
training...
   ↓
เพิ่มข้อมูลของ Suttisak เข้า neural network

ไม่ใช่แบบนั้น

มันใกล้กับ:

Stored/retrieved information
        ↓
เลือกสิ่งที่เกี่ยวข้อง
        ↓
ใส่เป็น context
        ↓
LLM
        ↓
Response

มากกว่า

RAG ก็ใช้หลักการคล้ายกัน

สมมติบริษัทมีเอกสาร 100,000 หน้า

แทนที่จะ train LLM ใหม่:

100,000 documents
        ↓
      Train
        ↓
New model

เราสามารถทำ:

User question
      ↓
Search / Retrieval
      ↓
หาเอกสารที่เกี่ยวข้อง
      ↓
เอาเฉพาะส่วนสำคัญ
      ↓
Context
      ↓
LLM

เช่น:

“HealthTAG production ใช้ AWS region ไหน?”

ระบบค้นเอกสาร architecture แล้วเจอ:

Region: ap-southeast-1

จากนั้นส่งให้ LLM:

Context:
HealthTAG production region is ap-southeast-1.

Question:
Which AWS region does production use?

LLM ตอบ Singapore

นี่ไม่ใช่ความรู้ใหม่ที่ถูก train เข้า model

มันคือ retrieval + inference

Tools ก็ไปไกลกว่า RAG อีก

LLM อย่างเดียวมีโลกประมาณ:

Text in
   ↓
Transformer
   ↓
Text out

แต่ agent สามารถเป็น:

             LLM
              │
     ┌────────┼────────┐
     ↓        ↓        ↓
   Search    Code     Database
     │        │        │
     └────────┼────────┘
              ↓
            Result
              ↓
             LLM
              ↓
           Answer

สมมติถาม:

ตอนนี้ repository มี PR เปิดอยู่กี่อัน?

การหวังให้ weights รู้คำตอบนั้นผิดตั้งแต่ต้น เพราะข้อมูลเปลี่ยนตลอดเวลา

สิ่งที่ควรเกิดคือ:

LLM
 ↓
"ฉันต้องตรวจ GitHub"
 ↓
GitHub tool/API
 ↓
PR #42
PR #47
PR #51
 ↓
LLM
 ↓
"มี 3 PR"

ตรงนี้เริ่มเห็นภาพของ Agent แล้ว

และนี่ทำให้เราแยก AI สมัยใหม่ออกเป็นหลายชั้นได้

ภาพใหญ่ประมาณนี้:

┌──────────────────────────────────┐
│             AGENT                │
│                                  │
│   Planning / Tool use / Loop     │
│                                  │
│   ┌──────────────────────────┐   │
│   │           LLM            │   │
│   │                          │   │
│   │ Transformer + Weights    │   │
│   └──────────────────────────┘   │
│          ↑          ↑            │
│       Context     Memory         │
│          ↑                       │
│   Retrieval / Tools              │
│          ↑                       │
│ GitHub / Web / Files / APIs      │
└──────────────────────────────────┘

นี่สำคัญมาก เพราะเวลาคุณใช้ coding agent อย่าง Codex แล้วมัน:

อ่าน AGENTS.md
      ↓
ค้น source
      ↓
เปิดไฟล์
      ↓
คิด
      ↓
แก้ code
      ↓
run tests
      ↓
เจอ test fail
      ↓
อ่าน error
      ↓
แก้ใหม่
      ↓
run tests

ไม่ได้หมายความว่า LLM ถูก train ใหม่ระหว่างทำงาน

สิ่งที่เกิดคือ:

LLM เดิม + context ที่เปลี่ยนไป + tools + feedback loop

และนี่นำเราไปยังเรื่องที่สนุกขึ้นอีกระดับ:

ทำไมให้ LLM “คิดนานขึ้น” ถึงเก่งขึ้น ทั้งที่ weights เท่าเดิม?

เช่นแนวคิด reasoning models, test-time/inference-time compute, agentic loops และเหตุผลที่โมเดลเดียวกันอาจตอบโจทย์ยากได้ดีขึ้นเมื่อได้รับ compute เพิ่ม

ตรงนี้จะเชื่อมตรง ๆ กับสิ่งที่คุณเห็นเวลาใช้ GPT-5.6 Sol เทียบระหว่าง Instant, Medium, High และ Extra High thinking ว่า ทำไมแค่ให้โมเดลเดิมมีเวลาคำนวณมากขึ้น ผลถึงต่างกันได้ขนาดนั้น 🧠🔥

หมายเหตุประกอบการอ่าน

หมายเหตุเพิ่มเติมจากบทสนทนา: แผนภาพและการเปรียบเทียบระดับ reasoning ในตอนนี้เป็นภาพอธิบายแนวคิด inference-time compute ไม่ใช่รายละเอียดสถาปัตยกรรมภายในของ ChatGPT หรือคำยืนยันว่าแต่ละระดับต่างกันเพียงเวลาและ compute ปัจจัยเดียว ชื่อ ChatGPT-5.6 Reasoning Instant ใช้ระบุที่มาของบทสนทนาตามที่ผู้เขียนบันทึกไว้

อ่านรายละเอียดที่เปิดเผยต่อสาธารณะในเอกสาร GPT-5.6 Sol ของ OpenAI

← ตอนก่อนหน้า: ทาย token ถัดไป แล้วเขียนโปรแกรมได้อย่างไร

ตอนถัดไป: ทำไมคิดนานขึ้นจึงอาจตอบได้ดีขึ้น →

อ่านทั้งชุด

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