เลือกโมเดล Claude ให้ถูกงานด้วยการเทสจริง 3 ตัวใน 30 นาที

ข่าวโมเดลออกใหม่ทุกเดือน ตัวเลขเบนช์มาร์กในข่าวอย่างFable 5.1 หรือ GPT-6 Astra คือผลของ “งานของคนอื่น” สิ่งเดียวที่ควรตัดสินว่าคุณจะจ่ายค่ารุ่นไหน คือผลบน “งานของคุณ” workshop นี้ต่อจากสคริปต์ 15 บรรทัดที่เรียก Claude ได้ เราจะเพิ่มโค้ดอีกนิดให้มันรันงานเดียวกันบน 3 รุ่น (Haiku 4.5, Sonnet 5, Opus 5) แล้วพิมพ์คำตอบ ค่าใช้จ่ายเป็นบาท และเวลาตอบ ออกมาเทียบกันในหน้าจอเดียว ตอนท้ายจะได้เห็นกับตาว่าโมเดลถูกสุดพลาดตรงไหน โดยที่ JSON ที่ได้ยังดูสวยงามทุกอย่าง ถ้ายังไม่แน่ใจว่าจะสั่งงาน AI ยังไงให้ชัด อ่านเขียน Prompt ให้ได้ผลก่อนได้ แต่สำหรับ workshop นี้ prompt ตรง ๆ แบบมือใหม่ก็พอแล้ว

ขั้นที่ 1: ตั้งงานเทส 1 งาน แล้วเขียนคำตอบที่ถูกไว้ก่อนรัน

เลือกงานที่คุณจะเอา AI ไปทำจริง 1 งาน ใช้ข้อมูลจริงหรือใกล้จริง แล้ว เขียนคำตอบที่ถูกไว้ก่อน ไม่งั้นพอเห็นคำตอบสวย ๆ จากโมเดล คุณจะเผลอเชื่อมันเอง ตัวอย่างที่เราใช้ตลอด workshop นี้คือร้านเบเกอรี่ที่รับออร์เดอร์ทางแชต อยากให้ AI แปลงข้อความลูกค้าเป็นข้อมูลที่ระบบรับต่อได้:

สวัสดีค่ะ ร้านป้าแดงนะคะ ขอสั่งกล่องเค้กขนาด 2 ปอนด์ สองโหลก่อนค่ะ
เอ๊ย เปลี่ยนเป็นสามโหลดีกว่าค่ะ งานเยอะ ขอรับของภายในวันศุกร์ที่ 18 นี้ได้ไหมคะ
ถ้าไม่ทันบอกด้วยนะคะ ส่งมาที่ร้านเหมือนเดิมค่ะ

ข้อความนี้ตั้งใจให้มีกับดักแบบที่เจอในแชตจริง: ลูกค้าเปลี่ยนใจกลางประโยค จำนวนบอกเป็น “โหล” และวันที่บอกแค่ “ศุกร์ที่ 18” ไม่มีเดือนปี คำตอบที่ถูกที่เราจดไว้คือ ลูกค้า = ร้านป้าแดง, สินค้า = กล่องเค้กขนาด 2 ปอนด์, จำนวน = 36 (สามโหล ไม่ใช่สองโหล), กำหนดส่ง = 2026-09-18 และ note ต้องมีเรื่องแจ้งถ้าไม่ทันกับส่งที่ร้านเดิม

จากนั้นตั้งเกณฑ์ตัดสินไว้แค่ 3 ข้อ ให้ตอบได้ด้วยการกวาดตาไม่เกิน 10 วินาทีต่อคำตอบ:

• ถูกครบ — ทุกช่องตรงกับคำตอบที่จดไว้ ไม่มีตัวเลขเพี้ยน ไม่มีข้อมูลที่แต่งเพิ่มเอง
• รูปแบบตรง — ได้ JSON ที่เอาไปใช้ต่อได้จริง ไม่มีคำอธิบายพ่วง
• อ่านรู้เรื่อง — note สรุปเงื่อนไขของลูกค้าครบและอ่านแล้วเข้าใจทันที

มีข้อความทดสอบ 1 ก้อน คำตอบที่ถูกจดไว้แล้ว และเกณฑ์ 3 ข้อ = ผ่าน ไปเขียนสคริปต์ได้เลย

ขั้นที่ 2: สคริปต์เทียบโมเดล

สร้างไฟล์ bakeoff.py ในโฟลเดอร์เดียวกับ first_claude.py ของ workshop ก่อน (เพื่อให้ key จาก env var ใช้ได้เหมือนเดิม) แล้ววางทั้งก้อน:

import time
import anthropic

# ราคาต่อ 1 ล้านโทเคน (ขาเข้า, ขาออก) หน่วยดอลลาร์ ตรวจล่าสุด 2026-09-09
MODELS = {
    "claude-haiku-4-5": (1.00, 5.00),
    "claude-sonnet-5": (2.00, 10.00),
    "claude-opus-5": (5.00, 25.00),
}
THB_PER_USD = 36

TASK = """วันนี้คือวันพุธที่ 9 กันยายน 2026 จากข้อความลูกค้าด้านล่าง ดึงข้อมูลออกมาเป็น JSON ที่มีคีย์ customer, product, quantity (ตัวเลข), deadline (รูปแบบ YYYY-MM-DD), note ตอบเป็น JSON อย่างเดียว

ข้อความลูกค้า: สวัสดีค่ะ ร้านป้าแดงนะคะ ขอสั่งกล่องเค้กขนาด 2 ปอนด์ สองโหลก่อนค่ะ เอ๊ย เปลี่ยนเป็นสามโหลดีกว่าค่ะ งานเยอะ ขอรับของภายในวันศุกร์ที่ 18 นี้ได้ไหมคะ ถ้าไม่ทันบอกด้วยนะคะ ส่งมาที่ร้านเหมือนเดิมค่ะ"""

client = anthropic.Anthropic()

for model, (price_in, price_out) in MODELS.items():
    start = time.time()
    response = client.messages.create(
        model=model,
        max_tokens=1000,
        messages=[{"role": "user", "content": TASK}],
    )
    seconds = time.time() - start
    answer = "".join(block.text for block in response.content if block.type == "text")
    usage = response.usage
    cost_usd = usage.input_tokens * price_in / 1_000_000 + usage.output_tokens * price_out / 1_000_000
    per_call_thb = cost_usd * THB_PER_USD
    print(f"=== {model} · {seconds:.1f} วินาที · ขาเข้า {usage.input_tokens} ขาออก {usage.output_tokens}")
    print(f"    ครั้งละ {per_call_thb:.3f} บาท · 1,000 ครั้ง ≈ {per_call_thb * 1000:.0f} บาท")
    print(answer)
    print()

สิ่งที่ต่างจากสคริปต์แรกมีแค่ 3 จุด: MODELS คือลิสต์รุ่นพร้อมราคา (มีรุ่นใหม่ออกก็เติมบรรทัดเดียว) ตัว loop รันงานเดิมซ้ำทีละรุ่น และ 3 บรรทัดท้ายแปลงโทเคนเป็นบาทให้เลย ราคาที่ใส่คือราคาทางการ ณ วันที่เขียน ใส่วันที่กำกับไว้ในคอมเมนต์เสมอเพราะราคาโมเดลเปลี่ยนบ่อย (ในข่าวที่เราลง ถูกลงมาแล้ว 2 รอบภายในปีนี้) ส่วน TASK ให้เปลี่ยนเป็นงานของคุณเอง ใส่ข้อความทดสอบจากขั้นที่ 1 ลงไปตรง ๆ

รัน (Windows ใช้ python bakeoff.py และต้องเป็นหน้าต่างเทอร์มินัลที่ตั้ง key ไว้แล้ว):

python3 bakeoff.py

ผลจากการรันจริงตอนเขียน (ไม่ได้แต่งคำตอบ):

=== claude-haiku-4-5 · 2.0 วินาที · ขาเข้า 339 ขาออก 123
    ครั้งละ 0.034 บาท · 1,000 ครั้ง ≈ 34 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "product": "กล่องเค้กขนาด 2 ปอนด์",
  "quantity": 36,
  "deadline": "2026-09-18",
  "note": "ส่งมาที่ร้านเหมือนเดิม ถ้าไม่ทันบอกด้วย"
}
```

=== claude-sonnet-5 · 7.4 วินาที · ขาเข้า 351 ขาออก 543
    ครั้งละ 0.221 บาท · 1,000 ครั้ง ≈ 221 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "product": "กล่องเค้กขนาด 2 ปอนด์",
  "quantity": 36,
  "deadline": "2026-09-18",
  "note": "เปลี่ยนจำนวนจาก 2 โหลเป็น 3 โหล หากทำไม่ทันตามกำหนดให้แจ้งลูกค้า จัดส่งที่ร้านเหมือนเดิม"
}
```

=== claude-opus-5 · 7.1 วินาที · ขาเข้า 351 ขาออก 440
    ครั้งละ 0.459 บาท · 1,000 ครั้ง ≈ 459 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "product": "กล่องเค้กขนาด 2 ปอนด์",
  "quantity": 36,
  "deadline": "2026-09-18",
  "note": "แก้ไขจำนวนจากเดิม 2 โหล เป็น 3 โหล (36 ใบ); ขอรับของภายในวันศุกร์ที่ 18 ก.ย. 2026 หากไม่ทันให้แจ้งลูกค้า; จัดส่งที่ร้านที่อยู่เดิม"
}
```

ได้ 3 บล็อก บล็อกละ 1 รุ่น แต่ละบล็อกมีบรรทัดวินาที/โทเคน บรรทัดบาท แล้วตามด้วยคำตอบ = ผ่าน ไปอ่านผลกัน

ขั้นที่ 3: อ่านผลด้วยเกณฑ์ 3 ข้อ แล้วกรอกตาราง

เอาเกณฑ์จากขั้นที่ 1 ไล่ทีละบล็อก ผลของงานนี้:

• ถูกครบ — ผ่านทั้ง 3 รุ่น จำนวน 36 และวันที่ 2026-09-18 ตรงหมด ไม่มีใครหลงไปเอา “สองโหล” ที่ลูกค้าพูดก่อน
• รูปแบบตรง — ไม่ผ่านทั้ง 3 รุ่นแบบเดียวกัน คือครอบด้วย ```json ทั้งที่สั่งว่า “JSON อย่างเดียว” ถ้าเอาไป json.loads ตรง ๆ จะพัง (วิธีแก้อยู่ในกล่องท้ายเรื่อง)
• อ่านรู้เรื่อง — Haiku เขียน note สั้นเกินไปนิด ไม่บอกว่าเคยเปลี่ยนจำนวน ส่วน Sonnet/Opus เก็บเงื่อนไขครบ ตรงนี้แล้วแต่ว่างานคุณต้องการแค่ไหน

ทีนี้ดูฝั่งราคากับเวลา ซึ่งเป็นตัวเลขจริงจากบิล ไม่ใช่ราคาต่อโทเคนที่คูณเอง:

• Haiku 4.5 — 34 บาทต่อ 1,000 ครั้ง · 2 วินาที
• Sonnet 5 — 221 บาทต่อ 1,000 ครั้ง · 7 วินาที
• Opus 5 — 459 บาทต่อ 1,000 ครั้ง · 7 วินาที

ต่างกัน 13 เท่า ระหว่างถูกสุดกับแพงสุด ทั้งที่งานนี้ตอบถูกเท่ากัน สังเกตอีกอย่างคือโทเคนขาออกของ Sonnet (543) กับ Opus (440) มากกว่า Haiku (123) ถึง 3-4 เท่า ทั้งที่ JSON ยาวพอ ๆ กัน ส่วนต่างนั้นคือโทเคนที่รุ่นใหญ่ใช้ “คิดก่อนตอบ” ซึ่งคิดเงินเป็นขาออกเหมือนกัน นี่คือเหตุผลที่ต้องรันจริงแล้วอ่านบิล เพราะราคาต่อโทเคนบอกไม่ได้ว่าแต่ละรุ่นจะใช้กี่โทเคน

สรุปสำหรับงานนี้: ถ้าหยุดแค่ตรงนี้ คำตอบคือใช้ Haiku ประหยัดกว่า 13 เท่า เร็วกว่า 3 เท่า ถูกเท่ากัน แต่อย่าเพิ่งหยุด

กรอกครบ 3 รุ่น × (ผ่าน/ไม่ผ่านตามเกณฑ์ 3 ข้อ + บาทต่อ 1,000 ครั้ง + วินาที) ของงานตัวเองแล้ว = ผ่าน ไปขั้นที่สำคัญที่สุด

ขั้นที่ 4: ทำงานให้ยากขึ้นอีกขั้น แล้วรันซ้ำ

งานเทสงานเดียวมักง่ายเกินจริง ให้แต่งข้อความรอบสองที่ใกล้เคียง “วันที่ลูกค้าวุ่นวายที่สุด” ของงานคุณ ของเราคือลูกค้าสั่ง 2 อย่าง ยกเลิกไป 1 บอกจำนวนเป็น “โหลครึ่ง” มีเงื่อนไขสินค้าสำรอง และกำหนดส่งต้องคิดจากวันงาน แก้ค่า TASK ในไฟล์เป็นแบบนี้ (คีย์เปลี่ยนเป็น items ที่เป็นลิสต์ เพราะมีหลายสินค้าได้):

TASK = """วันนี้คือวันพุธที่ 9 กันยายน 2026 จากข้อความลูกค้าด้านล่าง ดึงข้อมูลออกมาเป็น JSON ที่มีคีย์ customer, items (ลิสต์ของ {product, quantity} โดย quantity เป็นตัวเลขจำนวนชิ้น), deadline (รูปแบบ YYYY-MM-DD), note ตอบเป็น JSON อย่างเดียว

ข้อความลูกค้า: สวัสดีค่ะ ร้านป้าแดงนะคะ รอบนี้ขอกล่องเค้ก 2 ปอนด์ โหลครึ่ง กับกล่องคุกกี้แบบมีหน้าต่าง 50 ใบค่ะ อ้อ คุกกี้ไม่เอาแล้วนะคะ เพิ่งเช็กสต๊อกยังเหลือ เหลือแค่เค้กพอ งานลูกค้าเป็นวันศุกร์ที่ 18 ขอรับของก่อนวันงาน 1 วันนะคะ ถ้า 2 ปอนด์หมดเอา 1 ปอนด์แทนได้ค่ะ จำนวนเท่าเดิม"""

คำตอบที่ถูกจดไว้ก่อน: items มีรายการเดียวคือกล่องเค้ก 2 ปอนด์ จำนวน 18 (โหลครึ่ง) กำหนดส่ง 2026-09-17 (ก่อนวันงาน 1 วัน) และ note ต้องมีเรื่องยกเลิกคุกกี้กับเงื่อนไขแทนด้วย 1 ปอนด์ รันซ้ำ:

python3 bakeoff.py

ผลจริง:

=== claude-haiku-4-5 · 2.5 วินาที · ขาเข้า 439 ขาออก 189
    ครั้งละ 0.050 บาท · 1,000 ครั้ง ≈ 50 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "items": [
    {
      "product": "กล่องเค้ก 2 ปอนด์",
      "quantity": 6
    },
    {
      "product": "กล่องเค้ก 1 ปอนด์",
      "quantity": 6
    }
  ],
  "deadline": "2026-09-17",
  "note": "หากเค้ก 2 ปอนด์หมด ให้ใช้เค้ก 1 ปอนด์แทนจำนวนเท่าเดิม"
}
```

=== claude-sonnet-5 · 7.4 วินาที · ขาเข้า 453 ขาออก 694
    ครั้งละ 0.282 บาท · 1,000 ครั้ง ≈ 282 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "items": [
    {"product": "กล่องเค้ก 2 ปอนด์", "quantity": 18}
  ],
  "deadline": "2026-09-17",
  "note": "ยกเลิกคุกกี้กล่องหน้าต่าง 50 ใบ (มีสต๊อกเหลือ); หากเค้ก 2 ปอนด์หมด ให้เปลี่ยนเป็น 1 ปอนด์แทนในจำนวนเท่าเดิม (18 กล่อง); งานลูกค้าวันศุกร์ที่ 18 ก.ย. 2026 ต้องการรับของก่อนวันงาน 1 วัน"
}
```

=== claude-opus-5 · 8.2 วินาที · ขาเข้า 453 ขาออก 594
    ครั้งละ 0.616 บาท · 1,000 ครั้ง ≈ 616 บาท
```json
{
  "customer": "ร้านป้าแดง",
  "items": [
    {
      "product": "กล่องเค้ก 2 ปอนด์",
      "quantity": 18
    }
  ],
  "deadline": "2026-09-17",
  "note": "ยกเลิกกล่องคุกกี้แบบมีหน้าต่าง 50 ใบ (ลูกค้าแจ้งว่าสต๊อกยังเหลือ) เอาเฉพาะกล่องเค้ก; โหลครึ่ง = 18 ใบ; หากกล่องเค้ก 2 ปอนด์หมด ให้ใช้ขนาด 1 ปอนด์แทนในจำนวนเท่าเดิม (18 ใบ); งานลูกค้าวันศุกร์ที่ 18 ก.ย. 2026 ขอรับของก่อนวันงาน 1 วัน"
}
```

นี่คือจุดที่ workshop นี้อยากให้คุณเห็นกับตา ดูบล็อกของ Haiku อีกที: JSON สวย ครบทุกคีย์ วันที่ถูก แต่ “โหลครึ่ง” กลายเป็น 6 และมันไปแตกสินค้าสำรอง (1 ปอนด์) ออกมาเป็นรายการสั่งซื้อจริงอีกรายการ ถ้าระบบรับออร์เดอร์ต่อจากตรงนี้ ร้านจะทำเค้กผิดจำนวนโดยไม่มี error ไม่มีสัญญาณเตือนใด ๆ เรารันซ้ำอีกรอบก็ผิดแบบเดียวกันเป๊ะ (6 กับ 6) ส่วน Sonnet และ Opus ได้ 18 ทั้งสองรอบ และเก็บเรื่องยกเลิกคุกกี้ไว้ใน note ถูกต้อง

นี่คือความหมายจริงของคำว่า “โมเดลถูกกว่า 13 เท่า”: ถูกกว่าในงานที่มันทำได้ และมีงานบางแบบที่มันทำไม่ได้โดยที่ไม่บอกคุณ เส้นแบ่งนั้นอยู่ตรงไหนสำหรับงานของคุณ ต้องรันถึงจะรู้ ไม่มีเบนช์มาร์กในข่าวไหนบอกได้

เห็นด้วยตาตัวเองว่ารุ่นถูกสุดผ่านหรือไม่ผ่านงานยากของคุณ (ถ้าผ่านทั้ง 3 รุ่นก็ยินดีด้วย ใช้รุ่นถูกได้อย่างสบายใจ) = ผ่าน ไปตัดสินใจ

ขั้นที่ 5: ตัดสินใจ แล้วจดเหตุผลไว้ในโค้ด 1 บรรทัด

ตอนนี้คุณมีข้อมูลครบสำหรับการตัดสินใจครั้งแรกแบบมีหลักฐาน กติกาง่าย ๆ ที่ใช้ได้กับทุกงาน: เลือกรุ่นถูกสุดที่ผ่านงานยากของคุณ ไม่ใช่รุ่นแพงสุดที่ “น่าจะปลอดภัย” และไม่ใช่รุ่นถูกสุดที่ผ่านแค่งานง่าย ของเราคือ Sonnet 5 ผ่านงานยากในราคาไม่ถึงครึ่งของ Opus แล้วจดไว้ในไฟล์เลย ให้ตัวเองในอีก 3 เดือนข้างหน้าอ่านเจอ:

# เลือก claude-sonnet-5 (2026-09-09): haiku พลาด "โหลครึ่ง" เป็น 6 ในงานหลายสินค้า 2/2 รอบ, opus ถูกเท่า sonnet แต่แพง 2 เท่า

ถ้าอยากรู้ว่ารุ่นแพงสุดในข่าวเป็นยังไง ก็แค่เติมบรรทัด "claude-fable-5-1": (10.00, 50.00) ในลิสต์ เราลองให้แล้ว: ทั้งสองงานตอบถูกเหมือน Opus แต่ 1,000 ครั้งอยู่ที่ราว 790-1,050 บาท และช้ากว่าเล็กน้อย (9-11 วินาที) สำหรับงานดึงข้อมูลแบบนี้จึงไม่มีเหตุผลต้องจ่าย แต่มันอยู่ห่างแค่บรรทัดเดียวเมื่อวันหนึ่งคุณเจองานที่ Opus เริ่มพลาด

กติกาดูแลสคริปต์นี้ต่อ: มีรุ่นใหม่ออก ให้เติมในลิสต์แล้วรันงานยากของคุณ ไม่ต้องอ่านข่าวก่อน ราคาเปลี่ยน ให้แก้ตัวเลขพร้อมวันที่ในคอมเมนต์ และเก็บข้อความทดสอบทั้งง่ายและยากไว้ในไฟล์ตลอด เพราะนั่นคือต้นกล้าของ eval set ที่คุณจะสร้างต่อ

มีบรรทัดเหตุผลอยู่ในไฟล์ พร้อมข้อความทดสอบ 2 ระดับ = ผ่านครบทุกด่าน จบ workshop

ไปต่อจากตรงนี้

วันนี้คุณได้เครื่องมือชิ้นเล็กที่ AI Engineer ใช้กันจริง: วิธีตัดสินใจเรื่องโมเดลด้วยผลบนงานตัวเองแทนตัวเลขในข่าว พร้อมสคริปต์ที่ทำให้การเทสรุ่นใหม่ใช้เวลาไม่ถึง 5 นาที สิ่งที่ยังขาดคือความน่าเชื่อถือ เพราะการเทสด้วยข้อความ 2 ก้อนแล้วอ่านด้วยตา บอกได้ว่า “รุ่นนี้พลาดได้” แต่บอกไม่ได้ว่า “พลาดบ่อยแค่ไหน” หรือจับได้ไหมเมื่อคุณแก้ prompt แล้วมันแย่ลงในเคสที่ไม่ได้ดู ขั้นถัดไปที่ให้ผลเร็วคือรุ่นถัดไปของสคริปต์นี้: ขยายเป็น 10 เคส ตรวจอัตโนมัติด้วยโค้ดแทนตา (เช่น เช็กว่า json.loads ผ่านและจำนวนตรง) และให้ AI อีกตัวเป็นกรรมการในข้อที่ตรวจด้วยโค้ดไม่ได้ ซึ่งเป็นเรื่องของบท Evals ในเล่มด้านล่าง เช่นเดียวกับวิธีบังคับให้ได้ JSON ตามโครงจริง ๆ โดยไม่ต้องลุ้นเรื่อง ```json ครอบอีก