AI Prompt Engineering · บทเรียน

การชี้นำด้วยพรอมต์แบบห่วงโซ่ความคิด

การกระตุ้นการให้เหตุผลทีละขั้นตอน

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

การให้เหตุผลในฐานะงบประมาณโทเค็น

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

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

# Direct: model must compute everything before the first token
DIRECT = 'Q: ' + q + '\nA:'
# CoT: model can use tokens as scratch space
COT = 'Q: ' + q + '\nA: Let us reason step by step.'

CoT แบบไม่มีตัวอย่าง

วลีเรียกใช้ที่มีชื่อเสียงว่า “มาลองคิดทีละขั้นตอน” (Kojima et al., 2022) ชักนำให้เกิดการให้เหตุผลโดย ไม่ต้องมีตัวอย่าง วิธีนี้ได้ผลเพราะโมเดลที่ปรับแต่งด้วยคำสั่งได้ซึมซับรูปแบบที่วลีลักษณะนี้มักอยู่ก่อนวิธีแก้โจทย์ที่แสดงขั้นตอน

CoT แบบไม่มีตัวอย่างมีต้นทุนต่ำและได้ผลดีอย่างน่าประหลาดใจ แต่คุณภาพการให้เหตุผลควบคุมได้น้อยกว่า CoT แบบใช้ตัวอย่างน้อยที่มีตัวอย่างต้นแบบคัดสรรแล้ว

def zero_shot_cot(question):
    stage1 = llm('Q: ' + question + '\nA: Let us think step by step.')
    # Extract the final answer in a second, constrained call
    stage2 = llm(stage1 + '\nTherefore, the final answer is:')
    return parse_answer(stage2)

CoT แบบใช้ตัวอย่างน้อย

CoT แบบใช้ตัวอย่างน้อย (Wei et al., 2022) ให้ตัวอย่างต้นแบบที่มีร่องรอยการให้เหตุผล ไม่ใช่เพียงคำตอบ วิธีนี้สอนทั้ง วิธีให้เหตุผลและรูปแบบที่ต้องการ จึงสร้างลำดับการให้เหตุผลที่น่าเชื่อถือและสม่ำเสมอกว่าแบบไม่มีตัวอย่าง

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

FS_COT = (
    'Q: Roger has 5 balls, buys 2 cans of 3. How many balls?\n'
    'A: 5 + 2*3 = 5 + 6 = 11. The answer is 11.\n\n'
    'Q: ' + question + '\nA:'
)

การแยกการให้เหตุผลออกจากคำตอบ

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

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

import re

def extract(chain):
    m = re.search(r'[Tt]he answer is\s*(.+?)[.\n]', chain)
    if not m:
        raise ValueError('no answer marker found')
    return m.group(1).strip()

ไม่รับประกันความสอดคล้องกับการให้เหตุผลจริง

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

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

# Faithfulness probe: perturb an irrelevant cue (e.g., always make
# option A correct in the few-shot). If the chain still 'justifies'
# choosing A, the stated reasoning is unfaithful to the real cause.

การตั้งค่าการถอดรหัสสำหรับ CoT

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

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

single = llm(COT, temperature=0.0)            # one stable chain
paths  = [llm(COT, temperature=0.7) for _ in range(10)]  # diverse

การให้เหตุผลแบบมีโครงสร้างและแบบตาราง

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

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

PAL = (
    'Solve by writing Python. Q: ' + q + '\n'
    'A:\ndef solve():\n'
    '    # the model writes code here, then we exec() it\n'
)
# Offload arithmetic to a deterministic interpreter

ความยาว ต้นทุน และเวลาแฝง

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

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

def adaptive(question):
    direct = llm('Q: ' + question + '\nA (answer only):', temperature=0)
    if confidence(direct) > 0.85:
        return direct
    return zero_shot_cot(question)  # escalate to reasoning only if needed

CoT บนโมเดลที่มีการให้เหตุผลในตัว

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

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

# Reasoning-native model: let it think, just constrain the output
resp = reasoning_model(
    prompt=question,
    reasoning_effort='medium',
    output_format='Final answer on the last line as: ANSWER=<x>'
)

เมื่อ CoT กลับให้ผลเสีย

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

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

def should_use_cot(task_acc_cot, task_acc_direct, cot_cost_mult):
    gain = task_acc_cot - task_acc_direct
    # Only adopt CoT if accuracy gain justifies the token multiplier
    return gain > MIN_GAIN and gain / cot_cost_mult > MIN_EFFICIENCY

การนำ CoT ไปใช้ในระบบจริง

CoT สำหรับระบบจริงควรคัดสรรตัวอย่างประกอบที่สอดคล้องกัน (หรืออาศัยการให้เหตุผลในตัวโมเดล) กำหนดเครื่องหมายคำตอบที่แยกวิเคราะห์ได้ สุ่มสายการคิดหลายสายสำหรับรายการที่ยาก ตรวจสอบการคำนวณด้วยการเรียกใช้โค้ดเมื่อทำได้ และเปิดใช้การให้เหตุผลโดยอิงจากการประเมินความยากเพื่อควบคุมต้นทุน

บันทึกสายการคิดไว้สำหรับการวิเคราะห์แบบออฟไลน์ แต่อย่าเปิดเผยสายการคิดเหล่านั้นในฐานะคำอธิบายที่เป็นข้อเท็จจริงอ้างอิง

def production_solve(q):
    if easy(q):
        return extract(llm(DIRECT_PROMPT.format(q=q), temperature=0))
    chains = [llm(FS_COT.format(q=q), temperature=0.7) for _ in range(8)]
    return majority_vote([extract(c) for c in chains])

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

อธิบายว่าเหตุใด CoT จึงช่วยได้ และในกรณีใดที่ไม่ช่วย

ทบทวน

ประเด็นสำคัญ:

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

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

บทเรียน “การชี้นำด้วยพรอมต์แบบห่วงโซ่ความคิด” ฟรีหรือไม่

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