จาก Deep Text Classification สู่ AST: แนวคิด AI แบบ Recursive ที่ได้รับแรงบันดาลใจจาก Lisp, Compiler และ Minimax

ในยุคที่ AI ส่วนใหญ่ขับเคลื่อนด้วย Transformer และ Large Language Models (LLMs) เรามักคุ้นเคยกับสถาปัตยกรรมแบบ

ข้อความ
    ↓
Transformer
    ↓
คำตอบ

แต่จะเป็นอย่างไร หากเราเปลี่ยนมุมมองจากการ "ทำนายคำถัดไป" (Next Token Prediction) ไปเป็นการ "สร้างโครงสร้างความคิด" (Structure Prediction) ก่อน แล้วค่อยประมวลผลแบบ Recursive?

บทความนี้เป็นการสำรวจแนวคิดการแปลงข้อความธรรมชาติให้กลายเป็น AST (Abstract Syntax Tree) แล้วใช้ Python ทำหน้าที่เป็น Recursive Engine คล้ายกับ Compiler, Lisp Interpreter และระบบค้นหาแบบ Minimax

---

จุดเริ่มต้น: จาก Minimax สู่ AST

แรงบันดาลใจหนึ่งมาจากชื่อบริษัท AI ของจีนชื่อ MiniMax

แม้บริษัทจะไม่ได้ใช้ Minimax Algorithm โดยตรง แต่ชื่อดังกล่าวชวนให้นึกถึงแนวคิดการค้นหาต้นไม้ (Tree Search)

Game State
    ↓
Move Tree
    ↓
Evaluate
    ↓
Best Move

เมื่อนำแนวคิดเดียวกันมาใช้กับภาษา

Raw Text
    ↓
AST Candidates
    ↓
Evaluate
    ↓
Best Interpretation

เราจะได้ระบบที่ไม่ได้พยายามตอบทันที แต่พยายาม "ตีความข้อความ" ให้กลายเป็นโครงสร้างก่อน

---

AST คืออะไร?

AST ย่อมาจาก

Abstract Syntax Tree

เป็นโครงสร้างต้นไม้ที่แทนความหมายของข้อความหรือโค้ด

ตัวอย่าง

1 + 2 * 3

AST จะเป็น

    +
   / \
  1   *
     / \
    2   3

เนื่องจากการคูณต้องเกิดก่อนการบวก

ในโลกของภาษาไทย

ถ้า hp ต่ำกว่า 30 ให้ใช้ยา

สามารถแทนเป็น

if
├── hp < 30
└── use_potion

ได้เช่นกัน

---

ทำไม Lisp ถึงเกี่ยวข้อง?

Lisp เป็นภาษาที่โด่งดังในวงการ AI ยุคแรก

เพราะแนวคิด

Code = Data

ตัวอย่าง

(if (< hp 30)
    (use_potion))

จริง ๆ แล้วคือ Tree

if
├── <
│   ├── hp
│   └── 30
└── use_potion

ซึ่งสามารถประมวลผลแบบ Recursive ได้ง่ายมาก

---

Python ก็คิดแบบ Lisp ได้

แม้จะไม่ได้เขียน Lisp จริง ๆ

เราสามารถเก็บ AST ในรูป List ได้

[
    "if",
    ["<", "hp", 30],
    ["use_potion"]
]

หรือ JSON

{
    "type": "if",
    "condition": {
        "type": "lt",
        "left": "hp",
        "right": 30
    },
    "action": {
        "type": "use_potion"
    }
}

ซึ่งมีความหมายเหมือนกันทุกประการ

---

แนวคิดหลัก: Text → AST → Function

แทนที่จะทำ

ข้อความ
    ↓
LLM
    ↓
คำตอบ

เราอาจทำ

ข้อความ
    ↓
Parser
    ↓
AST
    ↓
Recursive Evaluator
    ↓
Function Call

ตัวอย่าง

เปิดไฟห้องนอน

แปลงเป็น

[
    "turn_on_light",
    "bedroom"
]

จากนั้นเรียก

turn_on_light("bedroom")

---

Label ก่อน สร้าง AST ทีหลัง

หนึ่งในแนวคิดที่น่าสนใจคือ

แทนที่จะให้โมเดลสร้าง AST ทั้งต้น

ให้โมเดลทำหน้าที่ติด Label

ถ้า hp ต่ำกว่า 30 ให้ใช้ยา

กลายเป็น

IF
VARIABLE(hp)
OPERATOR(<)
NUMBER(30)
ACTION(use_potion)

จากนั้น Python จึงนำ Labels ไปสร้าง AST

ข้อดีคือ

• ใช้ Dataset น้อยลง

• Debug ง่าย

• อธิบายได้

• ตรวจ Syntax Error ได้ทันที

---

Syntax Error แบบภาษาโปรแกรม

เมื่อมี Label แล้ว

ประโยค

ถ้า hp ต่ำกว่า ให้ใช้ยา

จะกลายเป็น

IF
VARIABLE(hp)
OPERATOR(<)
ACTION(use_potion)

Parser พบว่า

VARIABLE
OPERATOR
???

ขาด NUMBER

จึงรายงานได้ว่า

Syntax Error

Expected NUMBER after OPERATOR

คล้าย Compiler ของภาษาโปรแกรม

---

Recursive Parsing: งูเหลือมกินควาย

แทนที่จะให้โมเดลเข้าใจทุกอย่างพร้อมกัน

อาจแบ่งเป็นชั้น

ถ้า hp ต่ำกว่า 30 ให้ใช้ยา
ไม่งั้นถ้ามีศัตรูใกล้ให้โจมตี
ไม่งั้นกลับเมือง

แตกเป็น

IF
├── Condition
├── Action
└── Else

จากนั้น Else ถูกส่งเข้า Parser อีกครั้ง

IF
├── enemy_near
├── attack
└── go_town

กระบวนการนี้เกิดซ้ำไปเรื่อย ๆ

เหมือนงูเหลือมที่ค่อย ๆ กลืนเหยื่อทีละส่วน

---

เมื่อ Confidence ต่ำ

ถ้าประโยคกำกวม

เอายาที่อยู่ในกล่องแดงให้คนที่ยืนข้างหมอ

อาจตีความได้หลายแบบ

AST #1
AST #2
AST #3

แทนที่จะเลือกทันที

ระบบสามารถสร้าง Candidate หลายตัว

แล้วใช้ Scoring Function เลือกต้นไม้ที่ดีที่สุด

Generate
    ↓
Score
    ↓
Select

แนวคิดนี้คล้าย

• Minimax

• Beam Search

• Monte Carlo Tree Search

• AlphaGo

---

ซ่อม AST แทนการเดาข้อความใหม่

เมื่อ Parser พบ Error

hp <

ระบบสามารถสร้าง Candidate Fix

hp < 10
hp < 20
hp < 30

แล้วประเมินคะแนน

แทนที่จะให้โมเดลสร้างข้อความใหม่ทั้งหมด

ข้อดีคือ

• แก้เฉพาะจุด

• อธิบายได้

• ตรวจสอบได้

• ควบคุมได้

---

รูปแบบ Dataset ที่เป็นไปได้

แบบ Text → AST

{
  "input": "ถ้า hp ต่ำกว่า 30 ให้ใช้ยา",
  "output": [
    "if",
    ["<", "hp", 30],
    ["use_potion"]
  ]
}

แบบ Labeling

{
  "text": "hp",
  "label": "VARIABLE"
}

{
  "text": "ต่ำกว่า",
  "label": "OPERATOR_LT"
}

{
  "text": "30",
  "label": "NUMBER"
}

แบบ Recursive Node Classification

{
  "node": "ถ้า hp ต่ำกว่า 30 ให้ใช้ยา",
  "type": "if"
}

แล้วค่อยแตกเป็น Node ย่อย

---

สถาปัตยกรรมที่เป็นไปได้

ภาพรวมของระบบ

Raw Text
    ↓
Labeler
    ↓
Parser
    ↓
AST
    ↓
Executor

เมื่อเกิด Error

AST Error
    ↓
Repair Engine
    ↓
Generate Candidates
    ↓
Score
    ↓
Fixed AST

---

สรุป

แนวคิดนี้เป็นการผสมผสานข้อดีจากหลายโลกเข้าด้วยกัน

• Lisp ให้แนวคิด Code = Data

• Compiler ให้แนวคิด AST และ Syntax Checking

• Minimax ให้แนวคิด Tree Search

• Python ให้ Ecosystem และ Recursive Processing

• Deep Learning ให้ความสามารถในการจำแนกและตีความข้อความ

แทนที่จะพึ่งโมเดลขนาดใหญ่ให้คิดทุกอย่างในครั้งเดียว

ระบบสามารถ

ข้อความ
    ↓
Label
    ↓
AST
    ↓
Recursive Search
    ↓
Function
    ↓
ผลลัพธ์

ได้อย่างเป็นระบบ อธิบายได้ และตรวจสอบได้

ซึ่งในบางโดเมน เช่น Game AI, Home Automation, ERP, Workflow Engine, MCP Router หรือ Agent Framework แนวทางนี้อาจมีประสิทธิภาพและควบคุมได้ดีกว่าการใช้ LLM แบบ End-to-End เพียงอย่างเดียว