AI Prompt Engineering · บทเรียน

แบบไม่มีตัวอย่าง ตัวอย่างเดียว และไม่กี่ตัวอย่าง

การเลือกจำนวนตัวอย่าง

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

สเปกตรัมของจำนวนช็อต

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

นี่คือ การเรียนรู้ในบริบท (ICL): ทรานส์ฟอร์เมอร์ถือว่าตัวอย่างเป็นส่วนหนึ่งของลำดับ และทำการถดถอยรูปแบบหนึ่งที่เรียนรู้ด้วยเมตาโดยปริยายจากตัวอย่างเหล่านั้น การเลือก k (จำนวนช็อต) เป็นไฮเปอร์พารามิเตอร์ที่ต้องปรับจากการทดลองเชิงประจักษ์ ไม่ใช่แนวปฏิบัติที่ดีที่สุดตายตัว

from dataclasses import dataclass

@dataclass
class ICLConfig:
    k: int           # number of demonstrations
    selection: str   # 'static' | 'dynamic'
    order: str       # 'random' | 'similarity' | 'curriculum'

# Zero-shot is simply k=0
cfg = ICLConfig(k=0, selection='static', order='random')

เมื่อการทำงานแบบไม่ใช้ตัวอย่างให้ผลดีกว่า

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

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

# Zero-shot with explicit schema beats vague few-shot
PROMPT = (
    'Classify sentiment as POSITIVE, NEGATIVE, or NEUTRAL.\n'
    'Respond with only the label.\n\n'
    'Text: ' + user_text + '\nLabel:'
)

การใช้ตัวอย่างเดียวเป็นจุดยึดรูปแบบ

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

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

ONE_SHOT = (
    'Extract entities as JSON.\n\n'
    'Input: Apple released the iPhone in Cupertino.\n'
    'Output: {"org": ["Apple"], "product": ["iPhone"], "loc": ["Cupertino"]}\n\n'
    'Input: ' + query + '\nOutput:'
)

การใช้ตัวอย่างไม่กี่ตัวอย่างกับเส้นโค้ง k

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

ในทางปฏิบัติ โปรดทดลองค่า k ใน {1, 2, 4, 8, 16} กับชุดข้อมูลที่กันไว้ตรวจสอบ ค่า k ที่เหมาะสมที่สุดขึ้นอยู่กับความซับซ้อนของงาน ความยาวตัวอย่าง และการใช้บริบทจริงของโมเดล ซึ่งโดยปกติต่ำกว่าหน้าต่างบริบทที่ประกาศไว้มาก

def sweep_k(eval_set, candidates, ks=(1,2,4,8,16)):
    results = {}
    for k in ks:
        acc = evaluate(build_prompt(candidates[:k]), eval_set)
        results[k] = acc
    return max(results, key=results.get)

เหตุผลที่ ICL ใช้ได้ผล: การอนุมานโดยนัย

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

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

# Min, Lyu et al. (2022): label correctness matters less than
#   - the input distribution
#   - the label space (which classes exist)
#   - the format / structure
# Implication: invest in representative inputs + valid label set

งบประมาณโทเคนกับการแลกเปลี่ยนด้านค่าใช้จ่าย

การใช้ตัวอย่างแต่ละครั้งใช้ทั้งบริบทและค่าใช้จ่าย เมื่อตัวอย่างสาธิตยาว ตัวอย่างสี่รายการอาจมีขนาดใหญ่กว่าคำถามมาก โปรดคำนวณตัวชี้วัด ค่าใช้จ่ายต่อจุดความแม่นยำ หาก k=8 เพิ่มความแม่นยำจาก k=4 ได้ 0.5% แต่ใช้โทเคนเพิ่มเป็นสองเท่า k=4 ย่อมเหมาะกว่าสำหรับการใช้งานจริง

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

def cost_efficiency(acc_by_k, tokens_by_k, price_per_1k):
    return {
        k: acc_by_k[k] / (tokens_by_k[k] / 1000 * price_per_1k)
        for k in acc_by_k
    }
# Pick the k maximizing accuracy per dollar, not raw accuracy

การเอนเอียงจากป้ายกำกับส่วนใหญ่และตำแหน่ง

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

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

# Contextual calibration (Zhao et al. 2021)
p_cf = model_probs(prompt_with_input('N/A'))  # content-free prior
W = 1.0 / p_cf                                  # diagonal correction
def calibrated(probs):
    return normalize(W * probs)

การทำให้ชุดตัวอย่างสาธิตสมดุล

เพื่อแก้การเอนเอียงไปยังป้ายกำกับส่วนใหญ่ โปรด ทำให้ หมวดหมู่ต่าง ๆ ในตัวอย่างสาธิตมีสัดส่วนสมดุล และเปลี่ยนลำดับของตัวอย่าง สำหรับการจัดประเภทแบบทวิภาคเมื่อ k=4 ให้ใช้ตัวอย่างเชิงบวก 2 รายการและเชิงลบ 2 รายการ แล้วสลับลำดับ แทนการใช้สัดส่วน 3:1

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

import random

def balanced_demos(pool, k, label_fn):
    by_label = {}
    for ex in pool:
        by_label.setdefault(label_fn(ex), []).append(ex)
    per = k // len(by_label)
    picks = [e for lst in by_label.values() for e in random.sample(lst, per)]
    random.shuffle(picks)
    return picks

การใช้ตัวอย่างไม่กี่ตัวอย่างเทียบกับการปรับแต่งโมเดล

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

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

# Decision heuristic
if num_labeled < 500 or task_volatility == 'high':
    strategy = 'few-shot ICL'
elif latency_budget_ms < 200 or prompt_token_cost_dominant:
    strategy = 'fine-tune + zero-shot'
else:
    strategy = 'few-shot now, distill later'

งานให้เหตุผลต้องการมากกว่าจำนวนตัวอย่าง

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

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

COT_SHOT = (
    'Q: A shop had 23 apples, used 20, bought 6 more. How many now?\n'
    'A: Start 23, minus 20 leaves 3, plus 6 is 9. Answer: 9\n\n'
    'Q: ' + question + '\nA:'
)

โครงทดสอบ harness สำหรับ k

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

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

def harness(pool, val, ks, seeds=5):
    report = {}
    for k in ks:
        accs = []
        for s in range(seeds):
            demos = balanced_demos(pool, k, label_fn)
            accs.append(evaluate(build_prompt(demos), val))
        report[k] = (mean(accs), stdev(accs))
    return report

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

ทดสอบความเข้าใจเกี่ยวกับการเลือกจำนวนตัวอย่างและการเอนเอียงของ ICL

สรุป

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

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

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

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

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