JSON จาก LLM ถูกตัดกลางคัน: ดูเหตุผลที่หยุดก่อน แล้วค่อยพูดถึงการซ่อม
สรุปสำคัญ: โมเดลคืน JSON ที่ขาดกลางค่า แล้ว parser บอกแค่เลขคอลัมน์ การปิดวงเล็บทำให้ parse ผ่านอีกครั้ง แต่ทุกฟิลด์ที่หายไปตอนนี้ซ่อนอยู่ในข้อมูล บทความนี้ขีดเส้นระหว่างสิ่งที่การซ่อมความตัดขาดกู้คืนได้อย่างซื่อสัตย์ กับสิ่งที่ต้องขอใหม่

การถูกตัดไม่ใช่ข้อผิดพลาดทางไวยากรณ์ แต่คือข้อมูลที่หายไป ไวยากรณ์ซ่อมได้ ส่วนความตัดขาดกู้คืนได้เพียงบางส่วน วินาทีที่เครื่องมือปิดช่องว่าง ช่องว่างที่เหลือก็เลิกเป็นข้อผิดพลาดในการ parse แล้วกลายเป็นสิ่งที่ไม่มีใครรู้ว่ามีอยู่
หน้าตาของการถูกตัด: เลขคอลัมน์เดียวไม่พอ
โมเดลเขียน JSON ตามสคีมาของคุณ ชนเพดานเอาต์พุต แล้วข้อความก็หยุด ส่งสิ่งนี้ให้โมดูล json ของ Python 3.11:
{"scores": {"clarity": 8, "depth": 7}, "items": [{"name": "a", "qty": 2}, {"name": "b", "qty"
json.loads โยน Expecting ':' delimiter, col 94 คอลัมน์ชี้ไปที่คีย์ "qty" ที่ไม่มีค่า แต่สาเหตุจริงคือเอกสารไม่มีที่สิ้นสุด regex แบบโลภที่เติม "} ล้มเหลว การปิดด้วยสแตกที่รู้จักสตริง (ภาคที่หก) parse ผ่าน แต่ items เหลือสองระเบียน และระเบียนที่สามที่เขียนค้างอยู่หายไป เลขคอลัมน์บอกว่าข้อความหยุดตรงไหน ไม่เคยบอกว่าหายไปเท่าไร
นี่คือความต่างจริงข้อแรกจากข้อผิดพลาด JSON ทั่วไป ลูกน้ำเกินมามีสภาพสิ้นสุดที่ชัดเจน: ลบออกแล้วเอกสารสมบูรณ์ ความตัดขาดไม่มีสภาพนั้น ซ่อมแล้วก็ยังเป็นเศษ
ความตัดขาดไม่ใช่ไวยากรณ์เสีย: จุดบอดของเครื่องมือซ่อม
เครื่องมืออย่าง jsonrepair เปลี่ยน JSON ที่ไวยากรณ์เสียให้เป็น JSON ที่ถูกต้อง: ลบรั้ว markdown, ลูกน้ำท้าย, แปลงคำพูดเดี่ยว ที่นั่นเจตนายังครบ การซ่อมเป็นแค่การทำความสะอาด อินพุตที่ถูกตัดดูเหมือน JSON เสียสำหรับเครื่องมือเดียวกัน มันจึงปิดสตริง อาร์เรย์ และออบเจกต์ที่เปิดค้างไว้ แล้วคืนสิ่งที่ parse ได้ จาก 83 รายงาน Claude ที่ถูกตัด เครื่องมือ "ซ่อม" ได้ 79 เหลือล้มเหลวหนักแค่ 4 การเฝ้าระวังข้อผิดพลาดเห็นอัตราต่ำกว่าความจริงยี่สิบเท่า
เอาต์พุตหลังซ่อมหน้าตาเป็นอย่างไร คำตอบข้อ 6 หยุดกลางประโยค ข้อ 7 ถึง 9 ไม่มีอยู่เลย อาร์เรย์ next_steps หายไป Pydantic ยังตรวจผ่าน เพราะ next_steps มีค่าเริ่มต้น [] และลิสต์ไม่มีขีดจำกัดความยาว แต่ละชั้นทำงานของตัวเองถูกต้อง สินค้าปล่อยรายงานที่มั่นใจแต่ผิดออกไป
วางการซ่อมไวยากรณ์บนเส้นทางของความตัดขาด แล้วมันเปลี่ยนจากทำความสะอาดเป็นการแต่งเรื่องอย่างเงียบ ๆ ดังนั้นต้องขีดเส้นก่อน: เครื่องมือซ่อมจัดการแค่ความสกปรกด้านรูปแบบของคำตอบที่ครบถ้วน คำตอบที่ถูกตัดไม่ควรไปถึงมันเลย สำหรับความสกปรกด้านรูปแบบ ดูคู่มือซ่อม JSON
ก้าวแรกคือเหตุผลที่หยุดเสมอ
API หลักทุกเจ้าแจ้งในเมทาดาทาว่าทำไมการสร้างจึงหยุด ฟรี และนี่คือบรรทัดโค้ดที่ถูกละเลยมากที่สุดในการต่อ LLM Anthropic เปิด stop_reason ส่วน API แชตของ OpenAI เปิด finish_reason: max_tokens หมายถึงถูกตัด end_turn หรือ stop หมายถึงโมเดลจบเอง
resp = client.messages.create(model=MODEL, max_tokens=4096, ...)
if resp.stop_reason != "end_turn":
raise TruncatedOutput(
f"stop_reason={resp.stop_reason}, "
f"output_tokens={resp.usage.output_tokens}"
)
data = json.loads(resp.content[0].text)
เมื่อความตัดขาดกลายเป็นข้อยกเว้นที่ชัดเจน เส้นทางการลองใหม่ก็มีตัวกระตุ้น และการเฝ้าระวังก็มีแหล่งเตือน 83 รายงานนั้นถูกพบทีหลังด้วยคิวรีเดียวบนฟิลด์ stop_reason ในล็อกที่ถูกเก็บตลอดแต่ไม่เคยถูกอ่าน Gemini รายงาน length และ incomplete ด้วยความหมายเดียวกัน เมื่อเพิ่มผู้ให้บริการใหม่ ให้ดูตารางแมป อย่าเดา
max_tokens คือรั้วนิรภัย ไม่ใช่งบประมาณ
สาเหตุตรง ๆ มักเป็นเพดานที่ตั้งไว้สำหรับเวอร์ชันผลิตภัณฑ์เก่า: 1500 โทเคน ที่ตัดรายงานยาว 39% ทันทีที่เซสชันยาวเข้ามา การขึ้นเพดานนั้นฟรี การคิดเงินอิงโทเคนที่สร้างจริง เพดาน 4096 กับรายงาน 1100 โทเคนจึงมีราคาเท่ากับ 1500 เพดานมีไว้หยุดเอาต์พุตที่เพี้ยน ไม่ใช่ประหยัดเงิน
ตั้งจากข้อมูล: ดูการกระจายจริงหนึ่งสัปดาห์ เอา p99 แล้วเผื่อที่ว่าง ทีมในเหตุการณ์นั้นเลือก 4096 เพราะ p99 หลังซ่อมคือ 2350 อีกทางคือทำให้เอาต์พุตเล็กลงเอง คีย์ซ้ำในอาร์เรย์ที่เหมือนกันกินโทเคนจำนวนมาก การเข้ารหัสแบบตารางก่อนเรียก (ดูคู่มือรูปแบบ TOON) ลดปริมาณที่ต้องอยู่ใต้เพดาน
ลำดับฟิลด์ในสคีมากำหนดว่าอะไรถูกตัด
โมเดลเขียน JSON จากบนลงล่าง เมื่องบหมด สมาชิกท้ายสุดของรายการ properties หายก่อน สคีมาที่เรียงเป็น summary, per_question_feedback, scores, next_steps เสีย scores ก่อน ซึ่งเป็นส่วนที่ผู้ใช้แคปจอมาเทียบทุกสัปดาห์พอดี วิธีแก้คือเรียงใหม่: ฟิลด์สั้นที่สำคัญไว้หน้า รายละเอียดยาวที่สร้างใหม่ได้ไว้หลัง ข้อความอิสระไว้ท้ายสุด
พฤติกรรมของผู้ให้บริการยังเปลี่ยนผลของความตัดขาดเดียวกัน:
| ผู้ให้บริการ | กลไก structured output | พฤติกรรมเมื่อถูกตัด |
|---|---|---|
| OpenAI | response_format พร้อม strict: true |
รับประกันที่ระดับการสุ่มตัวอย่าง แต่ภาษาย่อยแคบที่สุด มักปฏิเสธการสร้าง |
| Anthropic | input_schema ใน tool use |
ไม่มีการรับประกันตอนถอดรหัส อาจคืนวงเล็บที่ไม่ปิด |
| Gemini | responseSchema พร้อม MIME JSON |
ตัวถอดรหัสบังคับแค่ enum และชนิด ความตัดขาดยังเกิดได้ |
"เปิด structured output แล้ว ไม่ต้องตรวจ" เป็นภาพลวง ยิ่งการรับประกันของผู้ให้บริการหลวมเท่าไร คุณยิ่งต้องตรวจสคีมาเองและมีลูปลองใหม่มากขึ้นเท่านั้น วิธีสร้างการทดสอบสัญญานั้นอยู่ในการทดสอบสัญญา JSON Schema
เมื่อใดการกู้คืนบางส่วนจำเป็นจริง: การปิดด้วยสแตกที่รู้จักสตริง
มีกรณีที่บังคับให้ต้องรีดอะไรจากเศษ: พรีวิวแบบสตรีม คำตอบที่ลดระดับ หรือคิวให้คนตรวจ ที่นั่นการปิดคือขั้นสุดท้ายของบันไดซ่อม และต้องมีสองเงื่อนไข หนึ่ง การสแกนวงเล็บต้องรู้จักสตริง: ติดตามสถานะคำพูดและ escape ทีละอักขระ ไม่งั้น { ในค่าจะทำสแตกพัง สอง ลบคู่คีย์-ค่าที่ไม่ครบก่อนปิด คีย์ "qty" ที่ไม่มีค่าปิดเป็น {"qty"} ไม่ได้ ต้องทิ้งทั้งคู่
def close_truncated(s: str) -> str:
# 1) สแกนที่รู้จักสตริง ปิดสตริงที่เปิดค้างก่อน
out, in_str, esc = [], False, False
for ch in s:
out.append(ch)
if esc: esc = False; continue
if ch == '\\' and in_str: esc = True; continue
if ch == '"': in_str = not in_str
text = ''.join(out) + ('"' if in_str else '')
# 2) ทิ้งคู่ที่ไม่ครบและโคลอนหรือลูกน้ำที่ค้าง
text = re.sub(r',\s*"[^"]*"\s*$', '', text)
text = re.sub(r'[{,]\s*"[^"]*"\s*:\s*$', '}', text)
text = re.sub(r':\s*$', '', text)
text = re.sub(r',\s*$', '', text)
# 3) สแกนสแตกใหม่แล้วปิดแบบ LIFO
stack, in_str, esc = [], False, False
for ch in text:
if esc: esc = False; continue
if ch == '\\' and in_str: esc = True; continue
if ch == '"': in_str = not in_str; continue
if not in_str:
if ch in '{[': stack.append(ch)
elif ch in '}]' and stack: stack.pop()
return text + ''.join('}' if c == '{' else ']' for c in reversed(stack))
กับอินพุตตอนต้นบทความ โค้ดนี้คืน {"scores": {...}, "items": [{"name": "a", "qty": 2}, {"name": "b"}]} ด้วย Python 3.11 และไลบรารีมาตรฐานเท่านั้น มัน parse ได้ และระเบียนที่สามหายไป ฝั่งโมเดลโลคัล ไลบรารีเฉพาะอย่าง partial-json-parser ทำงานเดียวกัน: ปิดด้วยสแตก ตัดตามความครบถ้วน
สิ่งสำคัญคือการเปิดเผย ฟังก์ชันปิดต้องรายงานว่าผลมาจากขั้นไหน ทุกอย่างที่ออกจากขั้น truncation คือผลบางส่วนและต้องติดป้าย: ขอส่วนที่หายไปใหม่ ลองใหม่ด้วยเพดานที่ใหญ่ขึ้น หรือบอกผู้ใช้ว่าข้อมูลไม่ครบ การแสร้งว่าไม่มีอะไรเกิดขึ้นคือการสร้างภาพลวงด้วยโค้ดที่กำหนดได้
ซ่อมหรือลองใหม่: ตารางขีดเส้น
| รูปอินพุต | การกระทำที่ถูก | เหตุผล |
|---|---|---|
| รั้ว ลูกน้ำท้าย คำพูดเดี่ยว | เครื่องมือซ่อม | เจตนาครบ แค่ไวยากรณ์สกปรก |
| ขาดกลางสตริง | ลองใหม่หรือกู้บางส่วนพร้อมเปิดเผย | ค่านั้นเองหายไป |
| ขาดกลางโครงสร้าง | กู้บางส่วนพร้อมเปิดเผย | ฟิลด์ที่ครบยังอยู่ คู่ที่ไม่ครบต้องทิ้ง |
| Parse ได้แต่ดูผิด | ตรวจระดับธุรกิจ | ไม่ใช่ความตัดขาด แต่มักมาด้วยกัน |
ทีมการเงินทีมหนึ่งวัดต้นทุน รายการใบแจ้งหนี้ยาวถูกตัด การปิดวงเล็บทำให้ได้ JSON ที่ถูกต้อง ฟิลด์ total ที่หายไปรับค่าเริ่มต้น 0 และระบบที่ความสอดคล้องรูปแบบ 98.2% ออกใบแจ้งหนี้ผิดราว 200 ใบต่อเดือน หลังจากถือว่าความตัดขาดเป็นการลดระดับแบบแข็งและเพิ่มการตรวจอัตลักษณ์ (total == ผลรวมบรรทัด) อัตราข้อผิดพลาดด้านเงินลดจาก 0.8% เหลือ 0.02% ขณะที่ความสอดคล้องรูปแบบขึ้นแค่ 99.1% สามเดือนของการปรับ "ความสอดคล้องรูปแบบ" เล็งตัวชี้วัดผิด ผ่าน parser ไม่ได้แปลว่าผ่านธุรกิจ
รายการสี่ข้อ: ดูเหตุผลที่หยุดก่อน parse ตั้งเพดานตาม p99 ไม่ใช่เป็นงบประมาณ วางฟิลด์สำคัญของสคีมาไว้หน้า ให้เครื่องมือซ่อมเห็นแค่ความสกปรกด้านรูปแบบของคำตอบที่ครบ เมื่อครบสี่ข้อ ความตัดขาดก็กลับจากความเสียหายเงียบ ๆ เป็นความล้มเหลวที่ส่งเสียงและลองใหม่ได้
ปิดวงเล็บแล้วใช้ผลได้เลยไหม
ไม่ได้ การปิดรับประกันแค่ความถูกต้องทางไวยากรณ์ ข้อมูลยังเป็นเศษที่มีประโยคครึ่งเดียว ระเบียนท้ายหาย และค่าเริ่มต้นมาแทนค่าจริง ติดป้ายว่าบางส่วน เปิดการลองใหม่หรือการลดระดับ และล็อกอัตราการกู้คืน
แยกความตัดขาดจากไวยากรณ์เสียจริงอย่างไร
อ่านเหตุผลที่หยุดในเมทาดาทา: max_tokens, length หรือ incomplete คือถูกตัด end_turn หรือ stop ที่ parse ล้มเหลวคือไวยากรณ์เสียจริง ถ้าไม่มีเมทาดาทา ให้ดูตอนท้าย: หยุดกลางคำพูดหรือกลางวงเล็บโดยโครงสร้างนอกยังไม่ปิด เกือบทุกครั้งคือถูกตัด
ทำไมความตัดขาดที่ถูกซ่อมอันตรายกว่าความล้มเหลวที่ส่งเสียง
เครื่องมือซ่อมปรับ "ความสามารถในการ parse" และความตัดขาดที่ปิดแล้ว parse ได้จริง การเฝ้าระวังจึงเงียบ และการตรวจปลายทางผ่านเพราะค่าเริ่มต้น นั่นคือเหตุผลที่ 83 รายงานถูกตัดสร้างข้อผิดพลาดแค่ 4 เครื่องมือไม่มีความคิดเรื่องเจตนาและไม่รู้ว่าอะไรหาย จึงต้องกันความตัดขาดที่ต้นทาง
ขึ้น max_tokens เพิ่มค่าใช้จ่ายไหม
ไม่ การคิดเงินอิงโทเคนที่สร้างจริง เพดานเป็นแค่รั้ว 4096 กับ 1100 โทเคนที่สร้างมีราคาเท่ากับ 1500 ตั้งตาม p99 จริงโดยเผื่อที่ว่าง และลงแรงกับการกันเอาต์พุตที่เพี้ยน