בלוג

איך להשתמש ב-LLM-as-a-Judge

Markdown

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

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

מהו LLM-as-a-judge?

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

הפרדיגמה נוסחה באופן רשמי על ידי Zheng ואחרים בשנת 2023. הם מצאו שמודל חזק הסכים עם העדפות של בני אדם ביותר מ-80% מהמקרים — שיעור דומה בקירוב לזה שבו שני בני אדם מסכימים זה עם זה. זו ההבטחה: שיפוט דמוי-אנושי בהיקף ובעלות של מכונה.

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

מתי להשתמש בו ומתי לא

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

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

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

Pointwise לעומת pairwise

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

מצבהשאלהמתאים במיוחד ל-חולשה
Pointwise"דרגו את הפלט הזה מ-1 עד 5 לפי המחוון."ציונים מוחלטים ללוח מחוונים או לשער CIהכיול משתנה; קשה להשוות ציונים בין הרצות
Pairwise"מה עדיף, A או B?"השוואה בין שני פרומפטים או שני מודליםמחזיר מנצח ולא ציון מוחלט; רגיש לסדר

בדרך כלל, pairwise תואם יותר את שיפוטם של בני אדם, כי קל יותר לבצע השוואה יחסית מאשר לכייל ציון מוחלט. השתמשו בו כשאתם בודקים שינוי באמצעות A/B, וב-pointwise כשאתם זקוקים למספר עצמאי.

כתבו את הפרומפט לשופט

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

You are evaluating an answer to a user question. Judge ONLY against the rubric.
Rubric:
- Correctness: does the answer match the reference facts?
- Completeness: does it cover what the question asked?
- Groundedness: are claims supported, with no invented details?
Question: {question}
Reference: {reference}
Answer: {answer}
First, reason step by step about each rubric criterion in 1-2 sentences.
Then output a JSON verdict: {"correctness": 0-1, "completeness": 0-1,
"groundedness": 0-1, "pass": true/false}. Do not reward length or style.

שני פרטים חשובים. בקשה לנמק שלב אחר שלב לפני מתן פסק הדין (פרומפט של שרשרת מחשבה) משפרת את מידת ההסכמה עם בני אדם. וההנחיה המפורשת "do not reward length or style" מתמודדת ישירות עם הטיה שנדונה בהמשך.

ארבע ההטיות שחייבים להתמודד איתן

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

הטיהמה קורהדרך מיתון
הטיית מיקוםב-pairwise, התשובה במשבצת A מנצחת לעיתים קרובות יותר מאשר במקרההריצו את שני הסדרים (A/B ו-B/A) וסמכו רק על פסק דין זהה בשניהם
הטיית אורךתשובות ארוכות מקבלות ציונים גבוהים יותר, גם כשהאיכות שווההענישו על אורך במחוון או השתמשו בשיעורי ניצחון תחת בקרת אורך
העדפה עצמיתשופט מעדיף פלטים ממשפחת המודלים שלוהשתמשו בשופט ממשפחה אחרת מזו של המודל הנבדק
הטיית פורמטהשופט מעדיף את הפורמט שהוא עצמו מעדיף (פרוזה על פני JSON וכדומה)ציינו במחוון את הפורמט הנדרש ודרגו את התוכן, לא את הצורה

הטיית המיקום היא החשובה ביותר, כי קל לזהות אותה בקוד והיא משבשת בשקט כל השוואת pairwise שאתם מריצים.

שלטו בהטיית מיקום בקוד

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

# debias.py
def pairwise_debiased(x: str, y: str, judge) -> str:
    """Run the judge in both orderings. Trust the result only if it agrees."""
    first = judge(x, y)    # x in slot A
    second = judge(y, x)   # y in slot A
    x_wins = first == "A" and second == "B"
    y_wins = first == "B" and second == "A"
    if x_wins:
        return "x"
    if y_wins:
        return "y"
    return "tie/uncertain (verdict flipped on order)"
# A deliberately position-biased judge stub: it always picks slot A.
# Real judges show a smaller version of this; we exaggerate to prove the control works.
def biased_judge(a: str, b: str) -> str:
    return "A"
# A fair judge that decides on a real signal (here, conciseness) regardless of slot.
def fair_judge(a: str, b: str) -> str:
    return "A" if len(a) <= len(b) else "B"
print("biased:", pairwise_debiased("short answer", "a much longer answer", biased_judge))
print("fair:  ", pairwise_debiased("short answer", "a much longer answer", fair_judge))

הדביקו את הקוד הזה בקובץ debias.py והריצו python debias.py. תקבלו בדיוק:

biased: tie/uncertain (verdict flipped on order)
fair:   x

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

בדקו את השופט שלכם

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

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

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

התבנית ההיברידית

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

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

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

טעויות נפוצות

לרוב השופטים הלא-אמינים יש כמה גורמים משותפים.

הנפוצים שבהם:

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

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

מקורות

Zheng ואחרים, Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (NeurIPS 2023). הפרדיגמה של LLM-as-judge, הסכמה של יותר מ-80% עם העדפות אנושיות, וההטיות של מיקום, אורך ושיפור עצמי.

שאלות נפוצות

מהו LLM-as-a-judge?

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

האם אפשר להשתמש באותו מודל ליצירה ולשיפוט?

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

איך עוצרים הטיית מיקום?

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

יישמו את המדריך הזה עם Ailoot

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