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

Parser เข้มงวดไม่ให้ส่วนลดใด ๆ แก่อินพุตที่พัง: หนึ่งข้อความผิดพลาด หนึ่งเลขบรรทัด — และไม่ให้ไบต์ของข้อมูลคุณกลับมาแม้แต่ไบต์เดียว เครื่องมือซ่อมมีอยู่เพื่อเปลี่ยน "ล้มเหลวทั้งหมด" ให้เป็น "ดีพอที่จะรันได้" — แต่สิ่งที่มันเติมเต็มเป็นเพียงการเดาที่ดีที่สุดเกี่ยวกับเจตนาเสมอ ไม่ใช่การรับประกันความถูกต้อง
หนึ่ง: JSON ที่พังมาจากไหน
การซ่อมไม่ใช่เวทมนตร์ — เริ่มจากดูอินพุตก่อน ในโปรเจกต์จริง JSON ที่ไม่ได้มาตรฐานมาจากสามแหล่งที่กระจุกกัน:
- เอาต์พุตของ LLM โมเดลภาษาสร้างข้อความทีละโทเค็น ไม่ได้รัน JSON serializer แม้จะสั่ง "ขอ JSON อย่างเดียว" โมเดลก็ห่อคำตอบด้วย fence
```jsonแทรก "นี่คือข้อมูลของคุณ" ไว้ข้างหน้า ทิ้งจุลภาคท้าย หรือชนเพดานโทเค็นแล้วหยุดกลางออบเจ็กต์ - คัดลอกมาจากภาษาอื่น ออบเจ็กต์ JavaScript ที่พิมพ์ผ่าน
console.logมีเครื่องหมายคำพูดเดี่ยวและคีย์ไม่มีเครื่องหมายคำพูด, dictionary ของ Python พิมพ์ออกมาเป็นTrue/False/Noneข้อความที่ "หน้าตาเหมือน JSON" เหล่านี้ระเบิดทันทีที่เจอJSON.parse - คอนฟิก JSON5/JSONC ไฟล์อย่าง tsconfig ยอมรับคอมเมนต์และจุลภาคท้ายอย่างถูกต้องตามกฎเกณฑ์ เอาไฟล์นั้นไปวางใน parser เข้มงวด — ทั้งไฟล์ถูกปฏิเสธ
สามแหล่งต้องการการจัดการต่างกัน แต่เครื่องมือซ่อมรับได้หมด — ตราบใดที่ข้อผิดพลาดอยู่ในรายการซ่อมได้ที่มันประกาศไว้
สอง: เก้าชนิดข้อผิดพลาดที่เครื่องมือซ่อมซ่อมได้จริง
รวมเอกสารของไลบรารี jsonrepair กับรายการความสามารถที่ผู้ให้บริการเครื่องมือเผยแพร่ ข้อผิดพลาดที่ซ่อมอัตโนมัติได้แบ่งเป็นเก้าชนิด:
| ชนิด | อินพุตที่พัง | ผลหลังซ่อม |
|---|---|---|
| จุลภาคท้าย | [1, 2, 3,] |
[1, 2, 3] |
| เครื่องหมายคำพูดเดี่ยว / โค้ง | {'a': 'b'}、{"a": "b"} |
{"a": "b"} |
| คีย์ไม่มีเครื่องหมายคำพูด | {name: 'Ada'} |
{"name": "Ada"} |
| คอมเมนต์ | {"a": 1 /* หมายเหตุ */} |
{"a": 1} |
| literal ของ Python | {"ok": True, "v": None} |
{"ok": true, "v": null} |
| markdown fence | ```json {...} ``` |
{...} |
| จุลภาคขาดหาย | [1 2] |
[1, 2] |
| วงเล็บ / เครื่องหมายคำพูดไม่ปิด | {"a": [1, 2 |
{"a": [1, 2]} |
| JSONP / การเชื่อมสตริง | cb({...})、"x" + "y" |
{...}、"xy" |
จุดร่วมของเก้าชนิดนี้คือ ข้อมูลอยู่ครบทุกอย่าง พังแค่ไวยากรณ์ เครื่องมือซ่อมปรับวรรคตอนและบรรจุภัณฑ์เท่านั้น ไม่แตะค่าใดเลย มีรายละเอียดบางอย่างควรจำแยกไว้:
- ตัวเลขที่ขึ้นต้นด้วยศูนย์จะกลายเป็นสตริง
007ถูกซ่อมเป็น"007"ไม่ใช่7เพื่อไม่ให้หลักหาย ถ้าฟิลด์นั้นเป็นโค้ดข้อความอยู่แล้ว พฤติกรรมนี้ถูกต้อง ถ้าเป็นตัวเลขจริง ๆ การตัดสินเป็นของคุณ - คำเปล่า ๆ จะกลายเป็นสตริง
NaNซ่อมเป็นตัวเลขไม่ได้ — บางเจ้าให้"NaN"บางเจ้าให้nullพฤติกรรมต่างกันตามไลบรารี ทดสอบของคุณก่อนเสียบเข้าไปป์ไลน์ - อินพุตที่ถูกต้องจะผ่านไปโดยไม่ถูกแตะ เครื่องมือซ่อมที่จริงจังทุกตัวรันเส้นทางเร็วของการ parse เข้มงวดก่อน JSON ที่ถูกต้องไม่เคยเข้าลอจิกการซ่อม จึง "ซ่อมเอกสารดีให้พัง" ไม่ได้
สาม: สี่อย่างที่เครื่องมือซ่อมซ่อมไม่ได้
เส้นแบ่งอีกฝั่งชัดเจนพอ ๆ กัน อย่าหวังการซ่อมสำหรับ:
- หน้าข้อผิดพลาด HTML หรือร้อยกรองล้วน ในอินพุตไม่มีโครงสร้าง JSON เลย และไม่มีเครื่องมือใดสร้างข้อมูลจากความว่างเปล่าได้
- ข้อมูลที่ถูกต้องตามไวยากรณ์แต่เนื้อหาผิด คีย์สะกดผิด ค่าวางผิดที่ ตัวเลขเก็บเป็นสตริง — นี่เป็นปัญหาเชิงความหมายที่ parser ทุกตัวรวมถึงเครื่องมือซ่อมปล่อยผ่านไปเงียบ ๆ
- ข้อมูลที่หายไปเพราะถูกตัดขาด การเติมให้สมบูรณ์เปลี่ยน
{"items": [{"id": 1}, {"naเป็น JSON ที่ถูกต้องได้ แต่ค่าของฟิลด์nameไม่มีวันกลับมา สิ่งที่ได้คือออบเจ็กต์ "ถูกต้องแต่ไม่ครบ" ใน production ตรวจstopReason === "max_tokens"ก่อนตัดสินใจว่าจะเติมให้สมบูรณ์หรือลองใหม่ - คีย์ซ้ำและโครงสร้างกำกวม คีย์ชื่อเดียวกันสองตัวตัวไหนชนะขึ้นกับการใช้งานของ parser เครื่องมือซ่อมที่มีความรับผิดชอบมีโหมด strict ที่โยนข้อผิดพลาด แทนที่จะเลือกข้างหนึ่งเงียบ ๆ
สรุปเส้นแบ่งความเชื่อมั่นในหนึ่งประโยค: การซ่อมคือการเดาที่ดีที่สุด ไม่ใช่การรับประกันความถูกต้อง ปล่อยให้ผลการซ่อมที่ยังไม่ได้ตรวจย้อนไหลต่อไปด้านล่าง เท่ากับแลกข้อผิดพลาดไวยากรณ์ที่ดังกับข้อผิดพลาดข้อมูลที่เงียบ
สี่: สองสำนักการใช้งาน — URL เดียวปิดข้อถกเถียง
เครื่องมือซ่อมในตลาดมีสองแบบ และช่องว่างปรากฏทันทีในอินพุตชนิดเฉพาะ
สำนักแทนที่ด้วย regex ใช้ค้นหาและแทนที่แบบทั่วโลกกับรูปแบบที่พัง ดูอินพุตนี้:
{"url": "http://example.com", 'note': 'fine'}
regex ที่เปลี่ยนเครื่องหมายคำพูดเดี่ยวเป็นคู่จะเคี้ยวเนื้อหาข้างใน URL ด้วย, regex ล้างคอมเมนต์ที่ลบทุก // จะตัด http:// ขาดกลาง ข้างในสตริงกับข้างนอกโครงสร้าง ตัวอักษรหน้าตาเหมือนกัน — regex แยกไม่ออก
สำนักเครื่องสถานะทีละอักขระ ติดตามสถานะการ parse: อยู่ในสตริงเครื่องหมายคำพูดคู่, เดี่ยว, อยู่ในคอมเมนต์บรรทัด, คอมเมนต์บล็อก, หรือกำลังรอค่า เห็น ' มันถามก่อน "ตอนนี้อยู่ในสตริงหรือเปล่า?" แล้วจึงตัดสินใจว่าจะเปลี่ยนเครื่องหมายคำพูดหรือข้าม http://example.com อยู่ในสตริงเครื่องหมายคำพูดคู่ ดังนั้นเครื่องสถานะรู้ว่า // ตรงนั้นเป็นข้อมูล ไม่ใช่คอมเมนต์ จึงเก็บไว้เหมือนเดิม jsonrepair และ json-healer อยู่ในสำนักนี้ และคำสวดของชุมชนที่ว่า "เครื่องมือซ่อมไม่ใช่ค้นหาและแทนที่" หมายถึงเรื่องนี้เป็นหลัก
ลำดับเต็มของไปป์ไลน์ซ่อม (ตามที่การใช้งาน devkits เปิดเผย) ก็น่าดู: ลอก fence → ทำเครื่องหมายคำพูดโค้งให้เป็นมาตรฐาน → สกัดบล็อกสมดุลแรก → เอาคอมเมนต์ออก → ห่อคีย์เปล่าด้วยเครื่องหมายคำพูด → เอาจุลภาคท้ายออก → แปลง literal → สุดท้าย serial ใหม่ด้วย JSON.stringify การ serial ใหม่ขั้นสุดท้ายนี่แหละคือก้าวสำคัญ: ไม่ว่าขั้นก่อนหน้าทำอะไร เอาต์พุตถูกสร้างใหม่จากผลการ parse ดังนั้น parser เข้มงวดใด ๆ ปลายน้ำก็กลืนได้
ห้า: ต่อเข้าโค้ด — ห่วงโซ่ parse ตามลำดับ
เมื่อต่อการซ่อมเข้าโค้ด ลำดับสำคัญกว่าการเลือกไลบรารี ตามรูปแบบที่ json2toon และ aijsonmedic เผยแพร่ ลำดับควรเป็น: ตรวจการตัดขาด → สกัดช่วง JSON → parse เข้มงวด → ซ่อมเป็นตัวสำรอง → ตรวจสอบด้วย schema
import { jsonrepair } from "jsonrepair";
export function parseModelJson(text, stopReason) {
if (stopReason === "max_tokens") {
// เอาต์พุตที่ถูกตัดถ้าซ่อมก็ยังขาดข้อมูล — ลองใหม่แทน
throw new Error("Truncated output: retry with a higher max_tokens");
}
// สกัดช่วง JSON: LLM ชอบคุยเก่งทั้งหน้าและหลัง
const start = text.search(/[[{]/);
const end = Math.max(text.lastIndexOf("}"), text.lastIndexOf("]"));
const candidate = start >= 0 && end > start ? text.slice(start, end + 1) : text;
try {
return JSON.parse(candidate); // เส้นทางเร็วสำหรับอินพุตที่ถูกต้อง
} catch {
return JSON.parse(jsonrepair(candidate)); // ซ่อมเป็นตัวสำรอง
}
}
ฝั่ง Python แพ็กเกจ json-repair (กว่า 4,700 ดาว) มี loads() ที่คืนออบเจ็กต์โดยตรง:
from json_repair import repair_json
import json
broken = "{name: 'Ada', tags: ['x',], active: True}"
data = json.loads(repair_json(broken))
# {'name': 'Ada', 'tags': ['x'], 'active': True}
รายละเอียดทางวิศวกรรมอีกสองข้อ:
- จัดสแตกให้ตรงกัน ถ้าทั้ง frontend และ backend ต้องซ่อม เลือกการใช้งานที่มีความหมายร่วมกัน — Python json-repair กับพอร์ต TypeScript
@yarmu/json-repair, หรือ jsonmend ที่เวอร์ชัน Python และ JS ผ่านคลังความสม่ำเสมอ 485 เคสเดียวกัน ไม่อย่างนั้นเอาต์พุตชุดเดียวจะซ่อมเป็น A ฝั่งไคลเอนต์และ B ฝั่งเซิร์ฟเวอร์ การดีบักกลายเป็นฝันร้าย - เปิดล็อกการซ่อม
@yarmu/json-repairกับlogging: trueคืนอาร์เรย์ของทุกการดำเนินการซ่อม อัตราการซ่อมพุ่งขึ้นฉับพลันมักแปลว่าพรอมป์หรือเวอร์ชันโมเดลเปลี่ยนไป — สัญญาณที่มาก่อนรายงานข้อผิดพลาดใด ๆ
มีอีกหนึ่งก้าวหลังการซ่อมที่ต่อรองไม่ได้: การตรวจสอบด้วย schema ถูกต้องตามไวยากรณ์ไม่ได้แปลว่าใช้ได้ ฟิลด์ขาด ประเภทผิด คีย์เกินมา — schema จับได้หมด แนวคิดการทดสอบสัญญาใช้ได้ตรงนี้เลย ดูคู่มือการทดสอบสัญญา JSON Schema ของเรา
หก: เช็กลิสต์การป้องกัน — การซ่อมที่ถูกที่สุดคืออันที่ไม่ต้องซ่อม
การซ่อมคือตัวสำรอง ชัยชน์ที่แท้จริงคือให้เกิด JSON พังน้อยลงตั้งแต่ต้นทาง เรียงตามลำดับความสำคัญ:
- Structured Outputs (โหมด json_schema) การถอดรหัสถูกบังคับด้วย schema จุลภาคท้ายจึงสร้างขึ้นไม่ได้เลย โหมด strict ของ OpenAI ล้มเหลวประมาณ 0.1% — แลกกับข้อกำหนดเข้มอย่าง
additionalProperties: false - โหมด JSON (json_object) รับประกันแค่ไวยากรณ์ถูกต้อง — ไม่รวมรูปทรง — และการตัดขาดเพราะเพดานโทเค็นยังเกิดอยู่
- คำสั่งที่ชัดเจน ปลายทางที่ไม่มีโหมด JSON การเขียนว่า "ห้าม fence ห้ามคอมเมนต์ ห้ามจุลภาคท้าย ให้แค่ออบเจ็กต์" ลดอัตราข้อผิดพลาดลง 70–80%
- ลด temperature เพิ่มเพดานโทเค็น อย่างแรกลดการเลื่อนไปเป็นร้อยแก้ว อย่างหลังลดการตัดขาด
- ลองใหม่โดยแนบข้อผิดพลาด เมื่อการตรวจสอบล้มเหลว เอาเอาต์พุตที่พักบวกกับ "พาธ JSON + ข้อความผิดพลาด" ใส่คืนบทสนทนาแล้วขอใหม่ โมเดลมักแก้ตัวเองได้เมื่อได้ข้อผิดพลาดที่แม่นยำ
- ล็อกเวอร์ชันไลบรารีซ่อมในไฟล์ล็อก พฤติกรรมกรณีเส้นขอบของเครื่องมือซ่อมเปลี่ยนได้ระหว่างเวอร์ชัน การอัปเดตอัตโนมัติโดยไม่รีวิวเท่ากับเปลี่ยนกลไกการเดาของไปป์ไลน์โดยไม่มีใครรู้ — อัปเดตได้ แต่ให้เป็นการตัดสินใจที่มีบันทึกและมีชุดทดสอบรองรับ
ในทางปฏิบัติการซ้อนกันสามชั้น "structured outputs + ซ่อมเป็นตัวสำรอง + ตรวจสอบ schema" ครอบคลุมแทบทุกสถานการณ์
เจ็ด: การแบ่งงาน — การแปลงภาษาถิ่นไม่ใช่การซ่อม
ในกล่องเครื่องมือของเว็บนี้มีสองจุดหมาย ครอบคลุมช่วงต่างกันของไปป์ไลน์นี้:
- ปัญหาพวกภาษาถิ่น (คอมเมนต์ เครื่องหมายคำพูดเดี่ยว จุลภาคท้าย) ไปตรงที่ ตัวแปลง JSON5 การแปลงกลับไปมาระหว่าง JSON5 ↔ JSON มาตรฐานครอบคลุมพอดีสามชนิดนี้ ด้วยความหมายที่ชัดเจน ไม่เดา ถ้าอินพุตทั้งหมดเป็นไฟล์ JSONC/JSON5 การแปลงจะคาดเดาได้กว่าการซ่อม เรื่องการเลือกของภาษาถิ่นเอง ดูคู่มือ JSON5 และ JSONC
- หลังซ่อมแล้ว ส่งผลผ่าน เครื่องมือ parse JSON เพื่อตรวจสอบและจัดรูป — ข้อผิดพลาดระบุถึงบรรทัดและคอลัมน์ ยืนยันว่า parser เข้มงวดยอมรับเอาต์พุตจริง ๆ
- ปัญหาระดับไลบรารี (literal Python การเติมที่ถูกตัด ห่อ JSONP markdown fence) ยังต้องพึ่ง jsonrepair / json-repair ฝั่งโค้ด — การซ่อมคลิกเดียวที่เทียบเท่าในเบราว์เซอร์ยังไม่มี เพราะการซ่อมพวกนี้ต้องอนุมานเจตนา และไลบรารีในเครื่องเป็นที่ที่ปลอดภัยกว่าสำหรับมันกว่าเครื่องมือแปลงสากล
ถ้าที่มือถือคือข้อความผิดพลาด ไม่ใช่ข้อมูลที่พัง เริ่มจากคู่มือแก้ข้อผิดพลาดการ parse JSON เพื่อแปลข้อความเป็นพิกัด แล้วจึงตัดสินใจ: แก้มือหรือซ่อมด้วยเครื่องมือ
คำตัดสินใจทั้งหมดข้างบนพับลงได้เป็นหนึ่งคำถามก่อนแตะเครื่องมือใด: อินพุตนี้มีข้อมูลครบแค่ไหน? ครบทุกไบต์แต่ไวยากรณ์พัง — เครื่องมือซ่อมช่วยได้จริง ขาดหายไปแล้ว — ไม่มีเครื่องมือใดช่วยได้ ให้ลองใหม่หรือยอมรับข้อมูลบางส่วนอย่างชัดเจน ส่วนครบแต่ผิดความหมาย — เครื่องมือซ่อมยังผ่านไปได้เงียบ ๆ ตรวจ schema เป็นด่านเดียวที่จับมันได้ สามคำตอบนี้ครอบคลุมแทบทุกสถานการณ์ที่คุณจะเจอกับ JSON ที่พัง จำเส้นแบ่งนี้ไว้ แล้วคุณจะใช้เครื่องมือซ่อมได้ตรงจุดที่มันดีที่สุด และหลีกเลี่ยงจุดที่มันเงียบ ๆ ทำร้ายข้อมูลของคุณ เมื่อเครื่องมือและเส้นแบ่งความเชื่อมั่นพร้อมแล้ว ตัวแปรที่เหลือเพียงตัวเดียวคือวินัยในการตรวจสอบของคุณเอง — ระบบซ่อมที่ดีที่สุดก็แพ้ความละเลยได้เสมอ ตรวจทุกผลลัพธ์ ตัดสินใจด้วยข้อมูล และเก็บต้นฉบับไว้เสมอ จำไว้ว่าการซ่อมคือทางเลือกสุดท้าย ไม่ใช่ทางลัด
แปด: กับดักที่พบบ่อยเมื่อซ่อมด้วยมือ
ก่อนพึ่งเครื่องมือซ่อมอัตโนมัติ นักพัฒนาจำนวนมากยังเลือกแก้ด้วยมือ ซึ่งไม่ผิดตัวใด — แต่มีกับดักที่กลายเป็นตั๋วบัตรเข้าโหมดดีบักกลางดึกซ้ำแล้วซ้ำเล่า:
- ค้นหาและแทนที่แบบทั่วโลกในโปรแกรมแก้ไขข้อความ การแทนที่
'ทั้งหมดด้วย"หรือลบคอมเมนต์ทั้งหมดด้วย regex ในโปรแกรมแก้ไข เหมือนกับสำนัก regex ที่กล่าวถึงข้างต้นทุกประการ — และรับผิดชอบข้อผิดพลาดรูปแบบเดียวกันด้วย อย่างน้อยควรตรวจผลลัพธ์ด้วย parser เข้มงวดหนึ่งรอบก่อนบันทึกไฟล์ - ลืมตัวหนีตัวอักษรหลังแก้เครื่องหมายคำพูด เมื่อเปลี่ยนเครื่องหมายคำพูดเดี่ยวเป็นคู่ด้วยมือ ข้อความภายในที่มีเครื่องหมายคำพูดคู่ฝังอยู่กลายเป็นสตริงที่ปิดก่อนเวลาอันควร รูปแบบที่ถูกต้องคือ
\"— การแก้ด้วยมือพลาดขั้นตอนนี้ง่ายที่สุดเมื่อสตริงมีเนื้อหายาว - ถือว่าข้อผิดพลาดตัวแรกคือต้นเหตุทั้งหมด parser หยุดที่ข้อผิดพลาดแรกที่เจอ แต่ไฟล์คอนฟิกที่แก้ด้วยมือมักสะสมข้อผิดพลาดหลายจุด แก้จุดหนึ่งแล้ว parse ต่อไปเจอจุดถัดไปเป็นเรื่องปกติ วางใจว่าข้อผิดพลาดตัวสุดท้ายจะมาทีละตัว จึงเป็นเหตุผลที่ห่วงโซ่ parse อัตโนมัติชนะการแก้ด้วยมือในงานประจำ
- ซ่อมแล้วแต่ไม่เก็บต้นฉบับไว้เทียบ เมื่อการซ่อมเปลี่ยนพฤติกรรมของข้อมูล (เช่น
007กลายเป็นสตริง) ถ้าไม่มีต้นฉบับเทียบ จะยากมากที่จะรู้ทีหลังว่าค่าใดถูกเครื่องมือปรับเปลี่ยน เก็บอินพุตดิบไว้ในบันทึกหรือในที่เก็บข้อมูลชั่วคราวเสมอ
กับดักทั้งสี่มีทางแก้เดียวกัน: ให้เครื่องสถานะทำงานที่ซ้ำซาก ให้คนตัดสินใจที่ต้องใช้วิจารณญาณ — นี่คือหลักการที่ไปป์ไลน์ซ่อมที่ดีทุกตัวยึดถือ
เก้า: ติดตามหลังเสียบเข้าระบบ — ตัวเลขที่ควรดู
การต่อเครื่องมือซ่อมเข้า production ไม่ใช่จุดจบของเรื่อง ต้องมีตัวชี้วัดคอยเฝ้าดู ไม่เช่นนั้นจะไม่มีใครรู้เลยว่าคุณภาพของเอาต์พุตโมเดลเปลี่ยนไปในทิศทางใด:
- อัตราการเข้าเส้นทางซ่อม สัดส่วนของคำขอที่
JSON.parseล้มเหลวแล้วต้องพึ่ง jsonrepair ถ้าตัวเลขนี้พุ่งจาก 5% เป็น 30% ภายในคืนเดียว แปลว่าพรอมป์ถูกแก้ โมเดลถูกสลับเวอร์ชัน หรือข้อจำกัดโทเค็นถูกลดลง — รู้ก่อนผู้ใช้จะรายงาน - อัตราการล้มเหลวหลังตรวจ schema เอาต์พุตที่ซ่อมแล้วแต่ตรวจ schema ไม่ผ่าน เป็นตัวชี้วัดที่ตรงที่สุดว่า "การซ่อมได้ผลจริงแค่ไหน" ถ้าตัวเลขนี้สูง แปลว่าปัญหาอยู่ที่โครงสร้างไม่ใช่วรรคตอน และควรย้ายแรงงานไปเขียนพรอมป์และ schema ให้เข้มขึ้น
- การกระจายเหตุผลการตัดขาด นับ
stopReasonทุกครั้ง ถ้าmax_tokensกินสัดส่วนมากขึ้น เพิ่มเพดานโทเค็นก่อนที่จะเพิ่มความซับซ้อนของลอจิกการซ่อมเติมให้สมบูรณ์ - เวลาที่เสียไปกับการซ่อม การซ่อมไม่ฟรี ทั้ง CPU ทั้งเวลาแฝง ถ้าอัตราการเข้าเส้นทางซ่อมสูงถาวร ลงทุนกับ structured outputs ถูกกว่าการเลี้ยงเครื่องมือซ่อมตลอดชีวิตของระบบ
หลักการเดียวกับการทำงานวิศวกรรมชิ้นใหญ่ทุกชิ้น: ตัวเลขที่มองไม่เห็น ปรับปรุงไม่ได้ — และการซ่อมที่เฝ้าดูไม่ได้ ก็เท่ากับเป็นท่อระบายข้อผิดพลาดเงียบ ๆ ที่โตขึ้นทุกวัน
ข้อควรระวังขั้นสุดท้ายของหัวข้อนี้: เก็บตัวอย่างอินพุตที่พักไว้หลายชุดจริง ๆ ไว้เป็นชุดทดสอบถดถอย ทุกครั้งที่เปลี่ยนเวอร์ชันไลบรารีซ่อม เปลี่ยนโมเดล หรือแก้พรอมป์ รันชุดทดสอบนี้เทียบผลซ่อมกับครั้งก่อน ความไม่สอดคล้องที่จับได้ในชุดทดสอบมีราคาถูกกว่าความไม่สอดคล้องที่จับได้จากคำร้องเรียนของผู้ใช้หลายเท่า ชุดทดสอบสามสิบตัวอย่างที่ครอบคลุมเก้าชนิดข้อผิดพลาดรวมถึงสี่ชนิดที่ซ่อมไม่ได้ ใช้เวลาเขียนไม่ถึงหนึ่งชั่วโมง และคืนทุนตั้งแต่การดีบักครั้งแรกที่มันช่วยกันไว้
คำถามที่พบบ่อย
การซ่อม JSON ทำให้ข้อมูลผมเสียหายไหม?
สำหรับเก้าชนิดที่ซ่อมได้ เปลี่ยนแค่วรรคตอนและบรรจุภัณฑ์ — ค่ายังอยู่ครบ และ //, จุลภาค, ปีกกาข้างในสตริงถูกเครื่องสถานะรู้จักและเก็บไว้ แต่การเติมที่ถูกตัดขาดให้ออบเจ็กต์ที่ขาดข้อมูล ตัวเลขขึ้นศูนย์กลายเป็นสตริง และการจัดการ NaN ต่างกันตามไลบรารี การตรวจฟิลด์สำคัญหลังซ่อมเป็นสิ่งจำเป็น
การซ่อมกับการตรวจสอบเกี่ยวข้องกันอย่างไร?
การตรวจสอบบอกว่าอินพุตผิดกฎ ตรงไหน; การซ่อมส่ง เอกสารที่ชอบด้วยกฎหมาย ให้โดยตรง วิธีทำงานที่เชื่อถือได้ทำทั้งสองอย่าง: ซ่อมก่อน แล้วตรวจ — schema จับประเภทและฟิลด์จำเป็น การตรวจไวยากรณ์ยืนยันว่า parser เข้มงวดยอมรับผล ซ่อมโดยไม่ตรวจ เท่ากับแลกข้อผิดพลาดไวยากรณ์ที่ดังกับข้อผิดพลาดข้อมูลที่เงียบ
LLM ห่อเอาต์พุตด้วย fence ```json ตลอด — ทำอย่างไร?
ระยะสั้น: สกัดออกมา เอาข้อความจาก { หรือ [ ตัวแรกถึง } หรือ ] ตัวสุดท้ายแล้ว parse เครื่องมือซ่อมที่ลอก fence ได้ก็กลืนทั้งข้อความได้ ระยะยาว: ใช้ structured outputs หรือคำสั่งชัดว่า "ห้าม markdown fence" เพื่อไม่ให้ fence เกิดขึ้นเลย
jsonrepair หรือ json-repair เลือกตัวไหน?
JavaScript ใช้แพ็กเกจ npm jsonrepair (รองรับ transform แบบสตรีม), Python ใช้ json-repair จาก PyPI ถ้าสองฝั่งต้องซ่อม เลือกคู่ที่ความหมายตรงกัน — เช่น json-repair กับพอร์ต TS — เพื่อให้อินพุตเดียวกันซ่อมได้ผลเหมือนกันทั้งสองฝั่ง
เครื่องมือซ่อมจัดการภาษาไทยและเครื่องหมายคำพูดโค้งได้ไหม?
ได้ เครื่องหมายคำพูดที่มาจากคีย์บอร์ดไทย (“ ”), เว้นวรรคเต็มความกว้าง และ BOM หัวไฟล์ อยู่ในรายการซ่อมมาตรฐานทั้งหมด เครื่องหมายคำพูดโค้งถูกทำให้เป็นเครื่องหมายตรง ส่งผลผ่านตัวตรวจสอบหนึ่งรอบก็จบ
ควรซ่อมทุกคำขอเลยไหม หรือซ่อมเฉพาะเมื่อ parse ล้มเหลว?
ซ่อมเฉพาะเมื่อ parse ล้มเหลวเสมอ — เส้นทางเร็วของการ parse เข้มงวดต้องมาก่อนทุกครั้ง การเรียกเครื่องมือซ่อมกับ JSON ที่ถูกต้องอยู่แล้วเป็นการเปลือง CPU โดยไม่จำเป็น และในกรณีเส้นขอบที่หาได้ยาก เพิ่มความเสี่ยงให้อินพุตที่ดีถูกแตะโดยไม่ตั้งใจ ห่วงโซ่ try/catch ในโค้ดตัวอย่างข้างบนจัดเรื่องนี้ให้อยู่แล้ว
ทำไมเครื่องมือซ่อมออนไลน์บางตัวให้ผลต่างกันกับไลบรารี?
เพราะพฤติกรรมของกรณีเส้นขอบ (ตัวเลขศูนย์นำหน้า, NaN, คีย์ซ้ำ) ขึ้นกับการตัดสินใจของผู้ใช้งานแต่ละรายไม่มีมาตรฐานกลาง ก่อนเสียบไลบรารีเข้าไปป์ไลน์จริง ทดสอบกับอินพุตขยะที่ระบบของคุณเจอจริงหลายตัวอย่าง แล้วล็อกเวอร์ชันของไลบรารี — การอัปเดตเวอร์ชันใหญ่ของไลบรารีซ่อมเป็นอีกจุดที่พฤติกรรมเปลี่ยนได้โดยไม่แจ้งล่วงหน้า
เอาต์พุตที่ตัดขาดควรเติมให้สมบูรณ์หรือขอโมเดลใหม่?
ดู stopReason ก่อนเป็นอย่างแรก ถ้าเป็น max_tokens แปลว่าโมเดลยังไม่ได้พูดจบ — การเติมวงเล็บให้ปิดได้แค่ให้เอกสารผ่านไวยากรณ์ แต่ฟิลด์ที่โมเดลกำลังจะเขียนหายไปทั้งหมด เลือกลองใหม่ด้วยเพดานโทเค็นที่สูงขึ้นหรือย่อขนาดเอาต์พุตที่ขอ ยกเว้นกรณีที่ความสมบูรณ์ไม่สำคัญ (เช่น คำขอชุดและขาดหางปนเป็นเรื่องปกติ) การเติมให้สมบูรณ์จึงคุ้มกว่าการรอขอใหม่ ตั้งกฎให้ชัดในโค้ด อย่าให้ลอจิกการซ่อมตัดสินใจแทนธุรกิจ