Self-Consistency Prompting: הצבעת רוב על תשובות

Self-consistency prompting פירושו לשאול מודל את אותה שאלת היסק כמה פעמים ולשמור את התשובה שחוזרת הכי הרבה. כל הרצה כותבת את ההיסק שלה, כמו בchain of thought prompting, ומכיוון שהמודל דוגם את המילים שלו עם מידה של אקראיות, ההרצות הולכות בנתיבים שונים. נתיבים נכונים נוטים להגיע לאותה תשובה. טעויות נוטות להתפזר על פני תשובות שגויות שונות. הצבעת רוב מנצלת את ההבדל הזה.

הטכניקה מגיעה מ-Wang et al. 2022, "Self-Consistency Improves Chain of Thought Reasoning in Language Models". המאמר השווה בין דגימה של נתיבי היסק רבים והצבעה לבין לקיחת תשובה חמדנית אחת, ומצא שההצבעה שיפרה את הדיוק במבחני ביצועים של חשבון ושל היסק מבוסס שכל ישר.

הבלוק שלמטה מראה שלוש הרצות של אותו פרומפט. כל לשונית היא הרצה אחת עם התשובה שלה. שתי הרצות סופרות נכון; אחת עושה טעות שקל לעשות.

הרצה 1הרצה 2הרצה 3

EditCopy

כמה פעמים מופיעה הספרה 7 כשכותבים את כל המספרים השלמים מ-1 עד 100? חשוב על זה שלב אחר שלב, ואז תן את התשובה הסופית בשורה האחרונה בצורה "תשובה: N".

Try it

Example replyReplies vary between models and runs.

נספור את ה-7 לפי מיקום.

• ספרת האחדות: 7, 17, 27, 37, 47, 57, 67, 77, 87, 97. אלה 10 שביעיות.
• ספרת העשרות: 70 עד 79. אלה עוד 10 שביעיות.
• ספרת המאות: רק ל-100 יש שלוש ספרות, ואין בו 7.

77 מופיע בשתי הרשימות, וזה נכון, כי יש בו שתי ספרות 7.

תשובה: 20

הרצה 2 ענתה על שאלה קצת אחרת: כמה מספרים מכילים 7, ולא כמה פעמים הספרה מופיעה. ההיסק שלה נשמע בטוח בדיוק כמו של השתיים האחרות, ולבדה לא הייתה לכם שום סיבה לפקפק בה. על פני שלוש הרצות, ההצבעה היא 20, 19, 20, ותשובת הרוב היא הנכונה.

איך self-consistency עובד

1. כתבו פרומפט chain of thought עם שורת תשובה קבועה. בקשו קודם היסק ובסוף את התשובה הסופית, בצורה שאפשר למצוא, כמו "תשובה: N". בלי שורה קבועה, תצטרכו לקרוא כל הרצה כדי למצוא את התשובה שלה.
2. דגמו כמה הרצות כשהאקראיות פעילה. כל הרצה צריכה את החופש ללכת בנתיב אחר. ב-API, temperature מעל 0 עושה את זה. ב-temperature 0 רוב ההרצות יחזרו על אותו היסק, ולחזור על טעות חמש פעמים זו לא ראיה.
3. חלצו את התשובה הסופית מכל הרצה. התעלמו מההיסק בשלב הזה. שתי הרצות שהגיעו ל-20 בדרכים שונות נספרות כשני קולות בעד 20.
4. קחו את התשובה הנפוצה ביותר. נרמלו לפני הספירה, כך ש-"20", "20." ו-"עשרים" ייספרו כאותה תשובה.

ההסכמה עצמה היא מידע שימושי. כשכל חמש ההרצות מסכימות, טעות אקראית לא סבירה. כשהקולות מתפצלים לשלושה כיוונים, השאלה קשה למודל, וזה סימן לבדוק את התשובה בעצמכם או לשכתב את הפרומפט. המאמר גם דיווח ששאלות עם הסכמה חזקה יותר בין הדגימות נענו נכון בסבירות גבוהה יותר.

Self-consistency ידנית

אפשר ליישם את הטכניקה בכל אפליקציית צ'אט. שלחו את הפרומפט, רשמו את השורה האחרונה, ואז קבלו עוד הרצה עצמאית: לחצו על יצירה מחדש, או הדביקו את אותו פרומפט בצ'אט חדש. חזרו על זה עד שיש לכם שלוש או חמש תשובות.

אל תשאלו שוב באותה שיחה "אתה בטוח?" או "נסה שוב". המודל רואה את התשובה הקודמת שלו, ולכן התשובה החדשה לא עצמאית: היא נוטה לחזור על התשובה הראשונה או לשנות אותה רק כי נראה שהטלתם בה ספק. אף אחד מהשניים הוא לא הצבעה.

הפרומפט הזה מוכן להצבעה. הכניסו שאלה ופורמט תשובה משלכם, ואז הריצו אותו כמה פעמים.

פרומפט מוכן להצבעה

EditCopy

Fill inשאלהצורה

PartsTaskFormat

Task

חנות מוכרת עטים בחבילות של 3 ב-$2. מאיה קונה 12 עטים ומשלמת בשטר של $10. כמה עודף היא מקבלת?

Format

חשוב על זה שלב אחר שלב. אחר כך תן את התשובה הסופית לבדה בשורה האחרונה בצורה "תשובה: סכום בדולרים".

Try it

Example replyReplies vary between models and runs.

12 עטים הם 12 ÷ 3 = 4 חבילות.

4 חבילות עולות 4 × $2 =$8.

עודף מ-$10:$10 פחות $8 =$2.

תשובה: $2

חלק הפורמט הוא מה שמאפשר את ההצבעה. כבו אותו, וההרצות נוטות לנסח את התשובות שלהן אחרת, לעתים קרובות אי שם באמצע הטקסט, מה שהופך ספירה פשוטה לקריאה מדוקדקת.

Self-consistency בקוד

בקוד, הלולאה קצרה: מריצים את אותו פרומפט N פעמים, שולפים את שורות התשובה וסופרים אותן. הגרסה הזו משתמשת ב-OpenAI Python SDK; כל API שמאפשר לקבוע temperature עובד באותה צורה.

import re
from collections import Counter
from openai import OpenAI

client = OpenAI()
MODEL = "your-model-id"  # e.g. from your provider's model list

PROMPT = (
    "How many times does the digit 7 appear when you write out all the whole "
    "numbers from 1 to 100? Think it through step by step, then give the final "
    'answer on the last line in the form "Answer: N".'
)

def final_answer(text):
    # Also matches "**Answer: 20**", since chat models often bold the last line.
    lines = re.findall(r"^\**Answer:\**\s*(.+)$", text, re.MULTILINE)
    return lines[-1].strip(" *.") if lines else None

answers = []
for _ in range(5):
    response = client.chat.completions.create(
        model=MODEL,
        temperature=0.8,
        messages=[{"role": "user", "content": PROMPT}],
    )
    answers.append(final_answer(response.choices[0].message.content))

votes = Counter(a for a in answers if a is not None)
if votes:
    best, count = votes.most_common(1)[0]
    print(f"{best} ({count} of {len(answers)} runs agree)")
else:
    print("No run gave an answer line.")

ההרצות עצמאיות, ולכן בפרודקשן שולחים אותן במקביל ולא אחת אחרי השנייה. חלק ממודלי ההיסק מקבלים רק את ה-temperature ברירת המחדל שלהם ומחזירים שגיאה אם קובעים ערך; אצלם, השמיטו את temperature. ההרצות שלהם עדיין משתנות, כי ברירת המחדל כבר דוגמת.

מתי להשתמש בזה, ומה זה עולה

Self-consistency שווה את זה כששלושה דברים נכונים: התשובה קצרה וניתנת להשוואה (מספר, תווית, בחירה), תשובה שגויה עולה יותר מכמה קריאות נוספות, והמודל עוד לא אמין במשימה. בעיות מילוליות במתמטיקה, סיווג עם מקרי קצה מסובכים ושאלות אמריקאיות מתאימים היטב.

זה עולה בערך פי N טוקנים מתשובה בודדת, וזה לא עוזר כשלמודל יש אותה תפיסה שגויה בכל הרצה. אם כל חמש ההרצות עושות אותה טעות, ההצבעה פה אחד ושגויה. הצבעה מפחיתה טעויות אקראיות, לא שגיאות שיטתיות, ולכן היא לא תחליף לבדיקה של התשובות מול תוצאה ידועה מדי פעם.

מודלים שחושבים באופן פנימי לפני שהם עונים כבר עובדים על הבעיה לעומק בכל הרצה, מה שנוטה לצמצם את הרווח מההצבעה. היא עדיין יכולה להשתלם בשאלות קשות שבהן ההרצות שלהם לא מסכימות.

Self-consistency מצביע רק על תשובות גמורות. Tree of thought prompting הולך צעד אחד קדימה ומשווה היסק חלקי בזמן שהבעיה עדיין נפתרת, שומר ענפים מבטיחים וזונח חלשים לפני שהם מגיעים לתשובה.