AI Prompt Engineering · บทเรียน

วงจรการซ่อมแซมและตรวจสอบ

การแก้ไขผลลัพธ์ที่มีรูปแบบไม่ถูกต้อง

บทเรียน 4 จาก 413 ขั้นตอน

วงจรการซ่อมแซมและตรวจสอบ เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่ต้องมีลูปซ่อมแซม

แม้มีสคีมาแล้ว ผลลัพธ์ก็ยังผิดพลาดได้ เช่น ข้อมูลเจสันถูกตัดเนื่องจากถึงขีดจำกัดโทเค็น มีช่องข้อมูลเกินที่รุ่นสร้างขึ้นเอง ใช้ข้อความในตำแหน่งที่ต้องเป็นตัวเลข หรือฝ่าฝืนกฎทางธุรกิจ ลูปซ่อมแซมจะตรวจจับความผิดพลาดและส่งข้อมูลกลับไปให้รุ่นแก้ไข

ลูปนี้คือเครือข่ายความปลอดภัยที่ช่วยยกระดับอัตราความสำเร็จจาก 98% เป็น 99.9%

วงจร validate-ซ่อมแซม

วงจรมาตรฐานคือ สร้าง, validate และหากไม่ถูกต้อง ให้ส่งพรอมป์ใหม่พร้อมข้อผิดพลาดที่เฉพาะเจาะจง โดยจำกัดจำนวนครั้งที่พยายาม

def generate_valid(prompt, schema, max_tries=3):
    msgs = [{'role': 'user', 'content': prompt}]
    for _ in range(max_tries):
        out = call_model(msgs)
        ok, err = validate(out, schema)
        if ok:
            return out
        msgs.append({'role': 'assistant', 'content': out})
        msgs.append({'role': 'user',
                     'content': 'Invalid. Fix this error and resend JSON only: ' + err})
    raise ValueError('repair budget exhausted')

ข้อผิดพลาดที่เฉพาะเจาะจงดีกว่าข้อผิดพลาดทั่วไป

คุณภาพของการซ่อมแซมขึ้นอยู่กับความแม่นยำของข้อมูลป้อนกลับ «เจสันไม่ถูกต้อง» ช่วยได้น้อย แต่ «ช่อง rating ต้องเป็นจำนวนเต็มระหว่าง 1 ถึง 5 แต่ได้รับค่า 7» มักแก้ปัญหาได้ในรอบเดียว

ส่งข้อความข้อผิดพลาดที่ตรงตามจริงจากตัวตรวจสอบ ซึ่งประกอบด้วยเส้นทางและเหตุผล กลับไปยังรุ่น

def validate(obj, schema):
    v = jsonschema.Draft202012Validator(schema)
    errs = sorted(v.iter_errors(obj), key=lambda e: e.path)
    if not errs:
        return True, None
    msg = '; '.join(f"{list(e.path)}: {e.message}" for e in errs)
    return False, msg

การตรวจสอบแบบหลายชั้น

การตรวจสอบมีหลายระดับ ให้ check รายการที่มีต้นทุนต่ำที่สุดก่อน:

เชิงไวยากรณ์ — แยกวิเคราะห์เป็นข้อมูลเจสันได้หรือไม่
เชิงโครงสร้าง — ตรงตามสคีมาหรือไม่
เชิงความหมาย — ค่าต่าง ๆ เป็นไปตามกฎทางธุรกิจและเงื่อนไขที่เชื่อมโยงระหว่างช่องข้อมูลหรือไม่

ส่วนลดต้องไม่เกินยอดรวมย่อย แม้ทั้งสองค่าจะเป็นตัวเลขที่ถูกต้อง นั่นคือการตรวจสอบเชิงความหมาย

def semantic_ok(o):
    return o['discount'] <= o['subtotal'] and o['total'] == o['subtotal'] - o['discount']

การซ่อมแซมเบื้องต้นแบบกำหนดแน่นอน

ก่อนเสียค่าใช้จ่ายกับการเรียกใช้รุ่น ให้ลองแก้ข้อบกพร่องทั่วไปด้วยวิธีราคาถูกและให้ผลแน่นอนก่อน:

ใช้ strip รั้วโค้ดมาร์กดาวน์ออก
ดึงออบเจ็กต์เจสันชั้นนอกสุดออกจากข้อความบรรยายโดยรอบ
ลบจุลภาคท้ายรายการ

ให้ยกระดับไปใช้การซ่อมแซมโดยรุ่นก็ต่อเมื่อการล้างข้อมูลแบบกำหนดแน่นอนล้มเหลว

def extract_json(text):
    text = text.strip().removeprefix('json').strip()
    start, end = text.find('{'), text.rfind('}')
    if start != -1 and end != -1:
        return text[start:end + 1]
    return text

การจัดการผลลัพธ์ที่ถูกตัด

หาก finish_reason == 'length' ข้อมูลเจสันถูกตัดกลางคัน การซ่อมแซมชิ้นส่วนที่เหลือย่อมไม่เกิดประโยชน์ แต่ให้เพิ่ม max_tokens ลดขนาดข้อมูลที่ร้องขอ หรือสตรีมแล้วขอให้ดำเนินการต่อ แยกแยะผลลัพธ์ที่ถูกตัดออกจากผลลัพธ์ที่ผิดรูปแบบ เพราะทั้งสองกรณีต้องใช้การตอบสนองตรงข้ามกัน

if resp.choices[0].finish_reason == 'length':
    # do NOT feed truncated JSON back; regenerate with more room
    return retry_with(max_tokens=resp_max * 2)

จำกัดขอบเขตของลูป

การซ่อมแซมที่ไม่จำกัดจำนวนครั้งเป็นความเสี่ยงด้านต้นทุนและเวลาแฝง และรุ่นที่ติดขัดอาจวนซ้ำไม่รู้จบ ให้จำกัดจำนวนครั้งที่พยายามเสมอ เพิ่มงบประมาณต่อคำขอ และกำหนดทางเลือกสำรอง เช่น ลดความสามารถลงอย่างเหมาะสม เข้าคิวให้มนุษย์ตรวจสอบ หรือส่งคืนค่าเริ่มต้นที่ปลอดภัย

try:
    data = generate_valid(prompt, schema, max_tries=3)
except ValueError:
    log_for_review(prompt)
    data = SAFE_DEFAULT

การซ่อมแซมภายในการเรียกใช้เครื่องมือ

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

msgs.append({'role': 'tool', 'tool_call_id': call.id,
  'content': json.dumps({'error': 'amount must be positive', 'got': args['amount']})})
# next model turn will re-issue the call with a corrected argument

การทำงานซ้ำและผลข้างเคียง

เมื่อลูปซ่อมแซมครอบการกระทำหนึ่งไว้ ไม่ใช่เพียงการสร้างผลลัพธ์ ให้ตรวจสอบว่าการลองใหม่สามารถทำซ้ำได้โดยไม่ก่อผลซ้ำ ใช้คีย์ป้องกันการทำซ้ำ เพื่อให้การเรียกใช้ที่ส่งใหม่ไม่เรียกเก็บเงินซ้ำหรือสร้างระเบียนซ้ำ ให้ดำเนินการ validate ก่อนยืนยันผลข้างเคียง และอย่าตรวจสอบหลังจากนั้น

สังเกตอัตราการซ่อมแซม

อัตราการซ่อมแซมเป็นสัญญาณคุณภาพล่วงหน้า หากอัตรานี้เพิ่มขึ้น อาจหมายถึงพรอมป์ถดถอย สคีมาเข้มงวดเกินไป หรือรุ่นเปลี่ยนแปลงไป ใช้ log จำนวนครั้งที่พยายามต่อความสำเร็จและเส้นทางข้อผิดพลาดที่พบบ่อยที่สุด พร้อมแจ้งเตือนเมื่อค่าเหล่านี้พุ่งสูงขึ้น

metrics.histogram('llm.repair.attempts', tries)
metrics.increment('llm.repair.error', tags={'path': top_error_path})

ผสานข้อจำกัดเข้ากับการซ่อมแซม

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

ตรวจสอบอย่างรวดเร็ว

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

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

กระบวนการซ่อมแซมที่ทนทาน:

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

คุณเรียนจบเรื่องการสร้างผลลัพธ์แบบมีโครงสร้างแล้ว หลักสูตรถัดไป: กลไกป้องกันและการตรวจสอบผลลัพธ์

เริ่มต้นได้ฟรี

เรียนรู้ AI Prompt Engineering ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 53
บทเรียน: 199

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “วงจรการซ่อมแซมและตรวจสอบ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “วงจรการซ่อมแซมและตรวจสอบ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Prompt Engineering ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “วงจรการซ่อมแซมและตรวจสอบ”

การแก้ไขผลลัพธ์ที่มีรูปแบบไม่ถูกต้อง คุณปฏิบัติ AI Prompt Engineering ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Prompt Engineering หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Prompt Engineering บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “วงจรการซ่อมแซมและตรวจสอบ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม

ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ AI Prompt Engineering