ลำดับและความใหม่ของตัวอย่าง
ลำดับของตัวอย่างส่งผลต่อผลลัพธ์อย่างไร
ลำดับและความใหม่ของตัวอย่าง เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน
ลำดับคือตัวแปรแฝงของไฮเปอร์พารามิเตอร์
ลำดับ ของตัวอย่างแบบใช้ตัวอย่างไม่กี่ตัวอย่างอาจทำให้ความแม่นยำเปลี่ยนไปหลายจุด บางครั้งทำให้พรอมต์ที่เกือบสุ่มกลายเป็นพรอมต์ที่มีประสิทธิภาพ และในทางกลับกัน ความผันผวนนี้เกิดขึ้นได้แม้ชุดตัวอย่างจะคงเดิม
โปรดถือว่าการเรียงลำดับเป็นไฮเปอร์พารามิเตอร์ที่ต้องค้นหาโดยตรง ไม่ใช่เรื่องที่ค่อยนึกถึงภายหลัง การรายงานผลแบบใช้ตัวอย่างไม่กี่ตัวอย่างโดยไม่ควบคุมลำดับถือว่าไม่ถูกต้องตามหลักวิทยาศาสตร์
import itertools
def order_search(demos, eval_set, build, max_perms=24):
perms = list(itertools.permutations(demos))[:max_perms]
scored = [(p, evaluate(build(p), eval_set)) for p in perms]
return max(scored, key=lambda x: x[1])อธิบายการเอนเอียงตามความใหม่
ทรานส์ฟอร์เมอร์แบบตัวถอดรหัสเท่านั้นแสดง การเอนเอียงตามความใหม่ โทเคนที่อยู่ใกล้จุดสร้างผลลัพธ์มีอิทธิพลมากเกินสัดส่วน ตัวอย่างสาธิตสุดท้ายก่อนคำถามจึงมีแนวโน้มมากที่สุดที่จะกำหนดรูปแบบ ป้ายกำกับ และน้ำเสียง
ส่วนหนึ่งเป็นผลจากรูปแบบความสนใจและการเข้ารหัสตำแหน่ง ผลในทางปฏิบัติคือ สิ่งใดก็ตามที่วางไว้ท้ายสุดคือสิ่งที่โมเดลเลียนแบบได้ง่ายที่สุด
# Position weight intuition (illustrative, not exact)
# influence(example_i) roughly increases with proximity to the query
# => the FINAL demo disproportionately anchors the next generation
weights = [0.1, 0.15, 0.25, 0.5] # earlier ... latestหลงหายอยู่ตรงกลาง
การศึกษาบริบทขนาดยาวเผยให้เห็นรูปแบบความสนใจ รูปตัวยู โมเดลให้ความสนใจกับต้นและท้ายบริบทได้ดี แต่ให้ความสนใจกับตรงกลางน้อยลง ตัวอย่างสาธิตสำคัญที่ฝังอยู่กลางพรอมต์จึงถูกลดน้ำหนักในทางปฏิบัติ
วางตัวอย่างที่สำคัญที่สุดหรือยากที่สุดไว้ตอนต้น หรือวางไว้ใกล้ท้ายเนื่องจากการเอนเอียงตามความใหม่ และอย่าวางไว้โดดเดี่ยวกลางบล็อกตัวอย่างที่ยาว
def place_key_demos(key, filler):
# U-shape aware: key items at the edges, filler in the middle
head = key[: len(key)//2]
tail = key[len(key)//2 :]
return head + filler + tailป้ายกำกับส่วนใหญ่กับตำแหน่งสุดท้าย
การเอนเอียงตามความใหม่และการเอนเอียงไปยังป้ายกำกับส่วนใหญ่จะเสริมกัน หากตัวอย่างสาธิตสุดท้ายของคุณอยู่ในหมวดหมู่ A โมเดลจะโน้มเอียงไปทางการคาดการณ์ A เมื่อรวมกับชุดตัวอย่างที่มีหมวดหมู่ A มากกว่า ค่าความเชื่อก่อนหน้าจะยิ่งบิดเบือนไปอย่างมาก
สำหรับการจัดประเภทที่สมดุล โปรดสลับป้ายกำกับ และตรวจสอบว่าตัวอย่างสุดท้ายไม่ได้อยู่ในหมวดหมู่เดียวกันเสมอในพรอมต์รูปแบบต่าง ๆ
def alternate_labels(by_label, k):
labels = list(by_label)
out = []
i = 0
while len(out) < k:
lbl = labels[i % len(labels)]
if by_label[lbl]:
out.append(by_label[lbl].pop())
i += 1
return out # final element varies by constructionตัวอย่างสาธิตที่เรียงตามความคล้ายคลึง (จากน้อยไปมาก)
แนวทางฮิวริสติกที่มีความทนทานสำหรับการเรียนรู้แบบใช้ตัวอย่างน้อยที่เสริมด้วยการค้นคืน คือเรียงตัวอย่างที่ค้นคืนมาตาม ความคล้ายคลึงจากน้อยไปมาก กับคำค้น เพื่อให้ตัวอย่างสาธิตที่เกี่ยวข้องที่สุดอยู่ใกล้คำค้นที่สุดและได้รับประโยชน์จากความใหม่ล่าสุด
แนวทางนี้ผสานการเลือกแบบไดนามิกเข้ากับการใช้ประโยชน์จากความใหม่ล่าสุด บริบทที่เกี่ยวข้องจึงมีทั้งอยู่ในพรอมต์และถูกจัดวางในตำแหน่งที่โมเดลให้ความสนใจมากที่สุด
def order_by_similarity(query_emb, retrieved):
scored = [(d, cos(query_emb, d.emb)) for d in retrieved]
scored.sort(key=lambda x: x[1]) # ascending
return [d for d, _ in scored] # most similar last (near query)การจัดเรียงตามหลักสูตร
สำหรับการให้เหตุผลหรือการสร้างเนื้อหา การจัดเรียงแบบ curriculum (จากง่ายไปยาก) อาจช่วยให้โมเดลค่อย ๆ สร้างพฤติกรรมเป้าหมาย โดยจบด้วยตัวอย่างต้นแบบที่ซับซ้อนซึ่งแสดงการให้เหตุผลอย่างเต็มรูปแบบไว้ก่อนคำค้นพอดี
แนวทางนี้ขึ้นอยู่กับงาน จึงควรตรวจสอบกับการจัดเรียงแบบสุ่มและตามความคล้ายคลึง แทนที่จะสันนิษฐานว่าจะช่วยได้
def curriculum(demos, difficulty_fn):
return sorted(demos, key=difficulty_fn) # easiest first, hardest lastการวัดความไวต่อการจัดลำดับ
วัดความเปราะบางของพรอมต์ด้วยการสุ่มการจัดลำดับจำนวนมาก แล้วรายงาน ความแปรปรวนของความแม่นยำ ความแปรปรวนสูงบ่งชี้ว่าพรอมต์ไม่เสถียรและอาจทำให้ผลลัพธ์ในระบบใช้งานจริงถดถอยอย่างคาดเดาไม่ได้
ใช้ตัวชี้วัดนี้เพื่อเปรียบเทียบการออกแบบพรอมต์ พรอมต์ที่ทนทานต่อการจัดลำดับย่อมปลอดภัยกว่าพรอมต์ที่ได้คะแนนสูงกว่าเพียงเล็กน้อยแต่มีความผันผวน
import random
def order_sensitivity(demos, eval_set, build, trials=20):
accs = []
for _ in range(trials):
perm = random.sample(demos, len(demos))
accs.append(evaluate(build(perm), eval_set))
return mean(accs), stdev(accs) # report both; low stdev = robustการเลือกการจัดลำดับโดยไม่ต้องใช้ชุดตรวจสอบ
เมื่อไม่มีป้ายกำกับสำหรับให้คะแนนการจัดลำดับ คุณสามารถเลือกการจัดลำดับโดยใช้ เอนโทรปีของการคาดการณ์ของโมเดลบนชุดข้อมูลสำหรับตรวจสอบ การจัดลำดับที่ให้การคาดการณ์อย่างมั่นใจ มีเอนโทรปีต่ำ และกระจายตัวได้ดี มักถ่ายโอนไปใช้กับข้อมูลใหม่ได้ดีกว่า (Lu et al., 2022)
วิธีนี้ช่วยให้คุณเลือกการเรียงสับเปลี่ยนที่ดีได้โดยไม่ต้องมีชุดตรวจสอบที่ติดป้ายกำกับ
def select_order_by_entropy(perms, probe_inputs, build):
def score(perm):
ents = [entropy(model_probs(build(perm), x)) for x in probe_inputs]
return -mean(ents) # prefer confident, low-entropy orderings
return max(perms, key=score)การทำให้เสถียรด้วยการปรับเทียบ
ความไวต่อการจัดลำดับและอคติจากความใหม่ล่าสุดต่างก็ทำให้ป้ายกำกับบางรายการมีน้ำหนักสูงเกินไป การปรับเทียบตามบริบทช่วยลดปัญหานี้ด้วยการประมาณค่าก่อนหน้าของโมเดลจากข้อมูลนำเข้าที่ไม่มีเนื้อหา แล้วปรับแก้ความน่าจะเป็นที่คาดการณ์ไว้ เพื่อลดผลกระทบจากการจัดลำดับใดลำดับหนึ่ง
การปรับเทียบร่วมกับการจัดลำดับที่เหมาะสมช่วยให้พฤติกรรมในระบบใช้งานจริงเสถียรกว่าการพยายามค้นหาการเรียงสับเปลี่ยนที่ดีที่สุดเพียงรายการเดียว
p_prior = model_probs(build(perm), content_free='N/A')
def calibrate(probs):
return normalize(probs / p_prior) # cancels order-induced label skewการแคชและความเสถียรของการจัดลำดับ
หากใช้การแคชพรอมต์ คำนำหน้า (รวมถึงบล็อกตัวอย่างสาธิต) ต้องคงเดิมในระดับไบต์เพื่อให้แคชทำงาน การสลับลำดับตัวอย่างใหม่บ่อยครั้งในแต่ละคำขอจะทำให้ไม่สามารถใช้แคชซ้ำได้และเพิ่มต้นทุนกับเวลาแฝง
วิธีแก้คือกำหนดการจัดลำดับเดียวที่ผ่านการตรวจสอบแล้วสำหรับบล็อกตัวอย่างสาธิตคงที่และแคชไว้ จากนั้นสงวนการจัดลำดับใหม่แบบไดนามิกไว้เฉพาะส่วนท้ายที่ค้นคืนตามคำค้นเท่านั้น
# Stable cached prefix + dynamic tail
prefix = render(FIXED_ORDERED_DEMOS) # cache_control on this block
tail = render(order_by_similarity(q_emb, retrieved))
prompt = prefix + tail + queryรายการตรวจสอบกลยุทธ์การจัดลำดับ
ค่าเริ่มต้นที่ใช้ได้จริงคือ ทำให้ป้ายกำกับสมดุลและสลับป้ายกำกับ วางตัวอย่างสำคัญหรือตัวอย่างยากไว้ที่ปลายทั้งสองด้าน (หลีกเลี่ยงตรงกลาง) เรียงตัวอย่างที่ค้นคืนมาตามความคล้ายคลึงจากน้อยไปมากเพื่อให้ตัวอย่างที่ดีที่สุดอยู่ใกล้คำค้น วัดความแปรปรวนของการจัดลำดับ และใช้การปรับเทียบเพื่อลดความเบ้ที่ยังตกค้าง
จากนั้นตรึงการจัดลำดับไว้เพื่อใช้กับแคช และตรวจสอบความถูกต้องใหม่ทุกครั้งที่ชุดตัวอย่างเปลี่ยนแปลง
def final_order(demos, q_emb):
demos = alternate_labels(group(demos), len(demos))
return order_by_similarity(q_emb, demos) # validated, then cachedตรวจสอบอย่างรวดเร็ว
พิจารณาตำแหน่งของตัวอย่างสาธิตที่สำคัญ
สรุปทบทวน
ประเด็นสำคัญ:
- ลำดับของตัวอย่างเป็นไฮเปอร์พารามิเตอร์ที่อาจทำให้ความแม่นยำเปลี่ยนไปหลายจุดเปอร์เซ็นต์ ควรค้นหาและรายงานความแปรปรวน
- อคติจากความใหม่ล่าสุดทำให้ตัวอย่างสาธิตสุดท้ายมีอิทธิพลมากที่สุด ส่วนปรากฏการณ์ “หลงทางตรงกลาง” ทำให้ตัวอย่างตรงกลางได้รับน้ำหนักน้อยเกินไป
- ทำให้ป้ายกำกับสมดุลและสลับป้ายกำกับ เรียงตัวอย่างสาธิตที่ค้นคืนตามความคล้ายคลึงจากน้อยไปมาก และพิจารณาการจัดเรียงแบบ curriculum
- เลือกการจัดลำดับด้วยเอนโทรปีเมื่อมีป้ายกำกับจำกัด และใช้การปรับเทียบตามบริบทเพื่อลดความเบ้
- ตรึงการจัดลำดับที่เสถียรสำหรับการแคชพรอมต์ และจัดลำดับใหม่เฉพาะส่วนท้ายที่ค้นคืนแบบไดนามิก
คำถามที่พบบ่อย
บทเรียน “ลำดับและความใหม่ของตัวอย่าง” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ลำดับและความใหม่ของตัวอย่าง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “ลำดับและความใหม่ของตัวอย่าง” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม
ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- แบบไม่มีตัวอย่าง ตัวอย่างเดียว และไม่กี่ตัวอย่าง
- การออกแบบตัวอย่างที่มีประสิทธิภาพ
- ลำดับและความใหม่ของตัวอย่าง
- การเลือกตัวอย่างแบบไม่กี่ตัวอย่างแบบไดนามิก