AI Prompt Engineering · บทเรียน

การสุ่มตัวอย่างเพื่อความสอดคล้องในตนเอง

การลงคะแนนระหว่างแนวทางการให้เหตุผลหลายแบบ

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

สายการคิดเดียวเปราะบาง

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

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

def self_consistency(prompt, n=20, temperature=0.7):
    answers = []
    for _ in range(n):
        chain = llm(prompt, temperature=temperature)
        answers.append(extract_answer(chain))
    return majority_vote(answers)

เหตุใดการหาค่ารวมเหนือเส้นทางจึงได้ผล

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

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

from collections import Counter

def majority_vote(answers):
    norm = [normalize_answer(a) for a in answers]
    counts = Counter(norm)
    answer, votes = counts.most_common(1)[0]
    confidence = votes / len(norm)
    return answer, confidence

สร้างความหลากหลายด้วยอุณหภูมิ

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

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

def tune_temperature(prompt, val_set, temps=(0.4, 0.6, 0.8, 1.0)):
    best = max(
        temps,
        key=lambda t: ensemble_accuracy(prompt, val_set, temp=t, n=20)
    )
    return best

การปรับรูปแบบคำตอบเป็นสิ่งสำคัญอย่างยิ่ง

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

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

def normalize_answer(a):
    a = a.strip().lower().rstrip('.')
    a = a.replace(',', '').replace('$', '').replace('%', '')
    try:
        return str(round(float(a), 6))   # numeric canonical form
    except ValueError:
        return a

ควรสุ่มตัวอย่างกี่รายการ

ความแม่นยำจะเพิ่มขึ้นตามจำนวนตัวอย่าง n แต่มี ผลตอบแทนลดลง และมักเริ่มคงที่เมื่อมีประมาณ 10 ถึง 40 ตัวอย่าง ขึ้นอยู่กับความยากของงาน ตัวอย่างแต่ละรายการจะเพิ่มต้นทุนและเวลาแฝงเป็นเส้นตรง

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

def sweep_n(prompt, val, ns=(1,3,5,10,20,40)):
    return {n: ensemble_accuracy(prompt, val, n=n) for n in ns}
# Choose n at the accuracy/cost knee, not the maximum

การหยุดก่อนเวลาแบบปรับตามสถานการณ์

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

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

def adaptive_sc(prompt, max_n=40, margin=0.6, min_n=5):
    answers = []
    for i in range(max_n):
        answers.append(extract_answer(llm(prompt, temperature=0.7)))
        if i + 1 >= min_n:
            ans, conf = majority_vote(answers)
            if conf >= margin:
                return ans, conf, i + 1
    return majority_vote(answers)

การลงคะแนนแบบถ่วงน้ำหนักและมีตัวตรวจสอบช่วย

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

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

def weighted_vote(chains):
    scores = {}
    for c in chains:
        a = normalize_answer(extract_answer(c))
        scores[a] = scores.get(a, 0.0) + verifier_score(c)
    return max(scores, key=scores.get)

ความมั่นใจจากความเห็นพ้อง

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

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

def route(prompt):
    ans, conf = adaptive_sc(prompt)[:2]
    if conf < 0.5:
        return escalate_to_stronger_model(prompt)
    return ans

ข้อจำกัด: งานต่อเนื่องและงานปลายเปิด

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

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

def semantic_consistency(samples):
    clusters = cluster_by_embedding(samples)
    biggest = max(clusters, key=len)        # largest agreement cluster
    return representative(biggest)            # medoid of the cluster

การนำไปใช้โดยคำนึงถึงต้นทุน

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

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

def tiered(prompt, q):
    if easy(q):
        return extract_answer(llm(prompt, temperature=0))
    return adaptive_sc(prompt, max_n=20)[0]   # SC only when needed

ความสอดคล้องในตนเองตั้งแต่ต้นจนจบ

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

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

def solve(prompt):
    chains = sample_until_decisive(prompt, max_n=20, temp=0.7)
    ans, conf = weighted_majority(chains)
    if conf < THRESH:
        return escalate(prompt)
    return {'answer': ans, 'confidence': conf, 'paths': len(chains)}

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

วิเคราะห์สาเหตุที่การตั้งค่าความสอดคล้องในตนเองให้ผลต่ำกว่าที่คาด

ทบทวน

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

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

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

บทเรียน “การสุ่มตัวอย่างเพื่อความสอดคล้องในตนเอง” ฟรีหรือไม่

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

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

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

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

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

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

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