ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ
หากแยกวิเคราะห์ JSON ไม่ได้ ให้ส่งข้อผิดพลาดกลับไปยังโมเดลและขอให้แก้ไขผลลัพธ์
ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ เป็นบทเรียน AI Agents ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Agents และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Agents มีบทเรียนทั้งหมด 4 บทเรียน
บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ
แม้แต่โหมดเข้มงวดก็ล้มเหลวได้ในบางครั้ง
โมเดลรุ่นเก่า กรณีขอบเขต หรือผู้ให้บริการที่ไม่ใช้โหมดเข้มงวด อาจส่ง JSON ที่มีรูปแบบไม่ถูกต้องกลับมาเป็นครั้งคราว เอเจนต์ที่ทนทานจะกู้คืนโดยขอให้โมเดลซ่อมแซมเอาต์พุต
Basic Repair Loop
from pydantic import ValidationError
import json
def call_with_repair(messages, schema, max_attempts=3):
for attempt in range(max_attempts):
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=messages,
response_format={'type': 'json_object'}
)
raw = response.choices[0].message.content
try:
return schema.model_validate_json(raw)
except (json.JSONDecodeError, ValidationError) as e:
messages.append({'role': 'assistant', 'content': raw})
messages.append({
'role': 'user',
'content': f'That output failed to validate: {e}.\nReturn ONLY valid JSON that matches the schema. No prose, no markdown fences.'
})
raise RuntimeError('Could not get valid output after repair attempts.')เหตุผลที่วิธีนี้ได้ผล
โมเดลจะเห็นข้อความแสดงข้อผิดพลาดและมักแก้ไขได้ในการทำงานรอบถัดไป ควรเพิ่มคำสั่งที่ชัดเจน:
- "ห้ามมีข้อความบรรยาย"
- "ห้ามใช้กรอบมาร์กดาวน์"
- "ให้ตรงกับโครงสร้างนี้ทุกประการ: ..."
ตัดกรอบมาร์กดาวน์ออก
โมเดลมักครอบ JSON ไว้ใน ```json ... ``` ให้ตัดออกก่อนแยกวิเคราะห์:
import re
def extract_json(text):
m = re.search(r'```(?:json)?\s*(.*?)```', text, re.S)
if m:
return m.group(1).strip()
return text.strip()
sample = '```json\n{"name": "Alice"}\n```'
print(extract_json(sample))
การตัดตั้งแต่วงเล็บตัวแรก
หากมีข้อความบรรยายเกินมา ให้ตัดตั้งแต่ { ตัวแรกไปจนถึง } ที่ตรงกันตัวสุดท้าย:
def find_json_slice(text):
start = text.find('{')
if start == -1:
return None
depth = 0
for i, c in enumerate(text[start:], start):
if c == '{': depth += 1
if c == '}':
depth -= 1
if depth == 0:
return text[start:i+1]
return None
sample = 'Here is your answer: {"name": "Alice", "age": 30} - hope that helps!'
print(find_json_slice(sample))
เครื่องมือที่ทำสิ่งนี้ให้คุณ
- Instructor — ครอบ Pydantic เข้ากับลูปซ่อมแซมและการลองใหม่
- Outlines — เอาต์พุตแบบมีโครงสร้างที่รับประกันด้วยการถอดรหัสแบบมีแนวทาง
- jsonformer — บังคับใช้ JSON ทีละโทเค็น (โมเดล HF)
พรอมป์สำหรับการซ่อมแซมที่ได้ผล
ใส่ข้อความแสดงข้อผิดพลาดที่เฉพาะเจาะจงและคำเตือนสั้น ๆ เกี่ยวกับรูปแบบ:
repair_prompt = f'''
Your previous output had this error: {error}
Fix the output. Requirements:
- Valid JSON only
- Match this schema: {json.dumps(schema)}
- No prose, no markdown fences
'''ต้นทุนของลูปซ่อมแซม
การซ่อมแซมแต่ละครั้งคือการเรียกใช้ LLM อีกครั้งหนึ่ง ควรจำกัดจำนวนครั้งที่ลองใหม่ (2–3 ครั้งก็เพียงพอแล้ว เพราะหลังจากนั้นโมเดลมักกู้คืนไม่ได้) และบันทึกอัตราการซ่อมแซมเป็นตัวชี้วัดคุณภาพ
การซ่อมแซมเป็นสัญญาณคุณภาพ
หากอัตราการซ่อมแซมของคุณมากกว่า 5% แสดงว่ามีบางอย่างผิดปกติ เช่น พรอมป์ไม่ชัดเจน สคีมาซับซ้อนเกินไป หรือโมเดลมีขนาดเล็กเกินไป ควรตรวจสอบ
ทางเลือก: การถอดรหัสแบบมีข้อจำกัด
โมเดลโอเพนซอร์สรองรับการถอดรหัสที่จำกัดด้วยไวยากรณ์ ทำให้โมเดลไม่สามารถสร้างเอาต์พุตที่ไม่ถูกต้องได้เลย Outlines, jsonformer และไวยากรณ์ของ llama.cpp รองรับวิธีนี้
ทางเลือก: ใช้ฟังก์ชันแทนสคีมา
การบังคับเรียกใช้เครื่องมือด้วยโหมดเข้มงวดเป็นทางเลือกที่สะอาดกว่าการใช้โหมด JSON ร่วมกับการซ่อมแซม ควรใช้เมื่อผู้ให้บริการรองรับ
การบันทึกเอาต์พุตที่ไม่ถูกต้อง
บันทึกเอาต์พุตที่ผ่านการซ่อมแซมทุกครั้ง เพื่อให้คุณวิเคราะห์รูปแบบได้:
log.warning('Repaired output', extra={'raw': raw, 'error': str(e), 'attempt': attempt})เมื่อใดควรยอมแพ้
หากหลังจากพยายามซ่อมแซม N ครั้งแล้วเอาต์พุตยังไม่ถูกต้อง ให้ส่งข้อผิดพลาดกลับไปยังผู้ใช้ อย่าสร้าง fallback ขึ้นมาเอง ความล้มเหลวอย่างซื่อสัตย์ดีกว่าข้อมูลเสียหายที่ไม่แจ้งให้ทราบ
รูปแบบลูปซ่อมแซม
ขั้นตอนแรกที่ง่ายที่สุดในลูปซ่อมแซมคืออะไร
สรุป
ตรวจจับข้อผิดพลาดในการ parse แล้ว append ข้อผิดพลาดเหล่านั้นเป็นข้อความจากเครื่องมือหรือผู้ใช้ และขอให้โมเดลซ่อมแซม จำกัดจำนวนครั้งที่ลองใหม่ ควรใช้การเรียกใช้เครื่องมือในโหมดเข้มงวดเพื่อขจัดความจำเป็นนี้ทั้งหมด
เรียนรู้ AI Agents ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 60
- บทเรียน
- 239
คำถามที่พบบ่อย
บทเรียน “ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Agents ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Agents มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ”
หากแยกวิเคราะห์ JSON ไม่ได้ ให้ส่งข้อผิดพลาดกลับไปยังโมเดลและขอให้แก้ไขผลลัพธ์ คุณปฏิบัติ AI Agents ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Agents หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Agents บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน AI Agents นี้ได้ไหม
ได้ บทเรียน AI Agents ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- โหมด JSON และผลลัพธ์จากการเรียกใช้เครื่องมือ
- การตรวจสอบโครงร่างด้วย Pydantic
- ลูปซ่อมแซมผลลัพธ์ผิดรูปแบบ
- Instructor / Outlines สำหรับโครงสร้างที่รับประกัน