JSON Toolkit

JSON จาก LLM ถูกตัดกลางคัน: ดูเหตุผลที่หยุดก่อน แล้วค่อยพูดถึงการซ่อม

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

สูตรปฏิบัติอ่านประมาณ 5 นาทีเผยแพร่ 2026-11-14อัปเดต 2026-11-14
การปิด JSON ที่ถูกตัดด้วยสแตกหลังการสแกนที่รู้จักสตริง

การถูกตัดไม่ใช่ข้อผิดพลาดทางไวยากรณ์ แต่คือข้อมูลที่หายไป ไวยากรณ์ซ่อมได้ ส่วนความตัดขาดกู้คืนได้เพียงบางส่วน วินาทีที่เครื่องมือปิดช่องว่าง ช่องว่างที่เหลือก็เลิกเป็นข้อผิดพลาดในการ 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 จริงโดยเผื่อที่ว่าง และลงแรงกับการกันเอาต์พุตที่เพี้ยน

แหล่งอ้างอิง

เครื่องมือที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง

คู่มือซ่อม JSON: กู้คืนเอาต์พุต LLM ที่พังโดยไม่เสียความเชื่อมั่น

เอาต์พุต LLM ที่ถูกห่อด้วย markdown fence มีจุลภาคท้ายและ literal ของ Python ตัว parser เข้มงวดจะปฏิเสธทั้งหมด — ไฟล์คอนฟิกที่แก้มือแล้วขาดเครื่องหมายคำพูดก็เช่นกัน บทความนี้ลากเส้นแบ่งที่แท้จริงระหว่างเก้าชนิดข้อผิดพลาดที่เครื่องมือซ่อมจัดการได้กับสี่ชนิดที่ไม่มีวันซ่อมได้ อธิบายว่าทำไมเครื่องสถานะจึงชนะ regex และส่งมอบห่วงโซ่ parse พร้อมใช้ใน production ด้วย jsonrepair และ json-repair

ระดับกลางอ่านประมาณ 6 นาทีอัปเดต 2026-11-08

คู่มือรูปแบบ TOON: ทำ JSON ให้เบาลงก่อนส่งให้ LLM

เมื่อคุณส่งอาร์เรย์ที่มีรูปร่างสม่ำเสมอให้โมเดลภาษาในรูปแบบ JSON ชื่อคีย์ที่ซ้ำกันและวงเล็บต่างก็กัดกินโทเคน TOON ประกาศโครงสร้างเพียงครั้งเดียวด้วยออบเจ็กต์แบบย่อหน้าและอาร์เรย์แบบตาราง แล้วเทข้อมูลออกทีละบรรทัด เบนช์มาร์กทางการแสดงให้เห็นโทเคนลดลงราว 40% พร้อมความแม่นยำในการแยกวิเคราะห์ที่สูงขึ้น คู่มือนี้ครอบคลุมไวยากรณ์ กรณีที่การประหยัดได้ผล กรณีที่ไม่ควรแปลง และวิธีเชื่อม encode กับ decode

ระดับกลางอ่านประมาณ 6 นาทีอัปเดต 2026-11-10

การทดสอบสัญญา JSON Schema: เชื่อมกฎการตรวจสอบเข้ากับ CI

สคีมาไม่จบเมื่อเขียนเสร็จ — ที่ตรงนั้นคือจุดเริ่มเสื่อมสภาพ การพิมพ์ผิดหนึ่งจุดทำให้การตรวจสอบหย่อนลงอย่างเงียบ ๆ การรีแฟกเตอร์หนึ่งครั้งทำลาย fixture ทั้งหมด คู่มือนี้ถอดโครงการทดสอบสัญญาที่ทำได้จริง: fixture บวก ลบ และ snapshot, lint ตัวสคีมาเอง คอมไพล์ครั้งเดียวใช้ซ้ำ และสี่ประตู CI ที่เปลี่ยนสัญญาแตกเป็นบิลด์แดง

ระดับกลางอ่านประมาณ 8 นาทีอัปเดต 2026-11-05