AI Prompt Engineering · บทเรียน

เหตุผลที่ควรใช้ผลลัพธ์แบบมีโครงสร้าง

ผลลัพธ์ที่เครื่องอ่านได้อย่างน่าเชื่อถือ

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

ปัญหาของข้อความอิสระ

ผลลัพธ์ภาษาธรรมชาติจาก LLM คลุมเครือเมื่อแยกวิเคราะห์ แบบจำลองอาจตอบ The price is $42 ครั้งหนึ่ง และ It costs forty-two dollars ในครั้งถัดไป โค้ดปลายทางที่คาดว่าจะได้รับตัวเลขจะทำงานผิดพลาด

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

การแยกวิเคราะห์คือต้นทุนแฝง

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

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

การสร้างผลลัพธ์แบบมีโครงสร้างย้ายสัญญานี้ไปไว้ ตั้งแต่ต้นทาง ในคำขอ

สามระดับของโครงสร้าง

การบังคับใช้มีหลายระดับตามความเข้มงวด:

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

แต่ละระดับแลกเปลี่ยนความยืดหยุ่นกับความน่าเชื่อถือ

กลไกภายในของการถอดรหัสแบบจำกัด

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

วิธีนี้ทำให้ JSON ที่มีรูปแบบไม่ถูกต้อง เป็นไปไม่ได้ในเชิงโครงสร้าง แทนที่จะเพียงห้ามปราม

# Conceptual: logit masking against a grammar FSM
def masked_sample(logits, fsm_state, grammar):
    allowed = grammar.allowed_token_ids(fsm_state)
    mask = full_like(logits, NEG_INF)
    mask[allowed] = 0.0
    return sample(logits + mask)

ผลลัพธ์แบบมีโครงสร้างในตัวของผู้ให้บริการ

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

client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Extract the invoice fields.'}],
    response_format={
        'type': 'json_schema',
        'json_schema': {
            'name': 'invoice',
            'strict': True,
            'schema': {
                'type': 'object',
                'properties': {
                    'total': {'type': 'number'},
                    'currency': {'type': 'string'}
                },
                'required': ['total', 'currency'],
                'additionalProperties': False
            }
        }
    }
)

ความน่าเชื่อถือในฐานะสัญญา

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

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

การแลกเปลี่ยนระหว่างความแน่นอนกับความสร้างสรรค์

โครงสร้างจำกัด รูปแบบ ไม่จำเป็นต้องจำกัด เนื้อหา โครงร่างที่มีช่องข้อมูล summary: string แบบอิสระยังคงอนุญาตให้เขียนร้อยแก้วอย่างสร้างสรรค์ภายในช่องนั้นได้

แนวทางปฏิบัติที่ดีคือกำหนด กรอบข้อมูล (ช่องข้อมูล ชนิดข้อมูล ค่าแจกแจง) ให้รัดกุม และเปิดพื้นที่ให้สร้างสรรค์เฉพาะภายในช่องข้อความที่กำหนดไว้

ค่าแจกแจงช่วยกำจัดประเภทความล้มเหลวทั้งกลุ่ม

การจำแนกประเภทด้วยข้อความอิสระ (sentiment: 'kind of positive') ไม่สามารถแยกวิเคราะห์ได้ ส่วน ค่าแจกแจงจะบังคับให้เลือกค่าจากชุดที่กำหนดไว้ จึงกำจัดข้อบกพร่องจากการปรับรูปแบบได้ทั้งประเภท

{
  'type': 'object',
  'properties': {
    'sentiment': {
      'type': 'string',
      'enum': ['positive', 'neutral', 'negative']
    }
  },
  'required': ['sentiment'],
  'additionalProperties': False
}

การตรวจสอบการทำงานและการกำหนดรุ่นโครงร่าง

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

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

เมื่อไม่ควรบังคับโครงสร้าง NOT

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

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

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

การพิจารณาค่าใช้จ่ายและเวลาแฝง

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

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

เทคนิคใดทำให้ JSON ที่มีรูปแบบไม่ถูกต้องเป็นไปไม่ได้ในเชิงโครงสร้าง แทนที่จะเพียงห้ามปราม

ทบทวน

ขณะนี้คุณเข้าใจแล้วว่า เหตุใดผลลัพธ์แบบมีโครงสร้างจึงสำคัญ:

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

ถัดไป: วิธีแสดงสัญญานี้อย่างแม่นยำด้วยโครงร่าง JSON ในคำสั่ง

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

บทเรียน “เหตุผลที่ควรใช้ผลลัพธ์แบบมีโครงสร้าง” ฟรีหรือไม่

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

บทเรียน “เหตุผลที่ควรใช้ผลลัพธ์แบบมีโครงสร้าง” ใช้เวลานานแค่ไหน

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

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

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

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

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