שימוש ב-LIT לניתוח מודלים של אבני חן ב-Keras

1. מבוא

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

הכלי להבנת הפרשנות (LIT), אתר, GitHub) הוא פלטפורמה לניפוי באגים ולניתוח של מודלים של למידת מכונה, במטרה להבין למה הם מתנהגים ואיך הם מתנהגים.

ב-Codelab הזה תלמדו איך להשתמש ב-LIT כדי להפיק יותר ממודל Gemma של Google. ה-Codelab הזה מדגים איך להשתמש בבליטות רצף, שיטה לחיזוי תוצאות, כדי לנתח גישות שונות של הנדסת פרומפטים.

יעדי למידה

1. הבנת בולטות הרצף והשימושים שלו בניתוח מודל.
2. הגדרת LIT ל-Gemma כדי לחשב את הפלט של ההנחיות ואת מידת הבולטוּת של הרצף.
3. שימוש בחשיבות לרצף באמצעות מודול LM Salience כדי להבין את ההשפעה של עיצובי הנחיות על הפלט של המודל.
4. בדיקת השערות של שיפורי הנחיות ב-LIT ובדיקת ההשפעה שלהם.

הערה: ה-Codelab הזה משתמש בהטמעה של KerasNLP של Gemma, וב-TensorFlow v2 בשביל הקצה העורפי. מומלץ מאוד להשתמש בליבה (kernel) של GPU כדי לעקוב אחרי ההתקדמות.

2. רצף רצף והשימושים שלו בניתוח מודלים

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

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

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

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

מידע נוסף על השיטות המדעיות של בולטוּת זמין במבוא הזה, שבו ניתן לחקור לעומק את מידת הבולטוּת.

3. ייבוא, סביבה וקוד הגדרה אחר

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

הערה: יכול להיות שיופיעו אזהרות מסוימות בטופס

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.
bigframes 0.21.0 requires scikit-learn>=1.2.2, but you have scikit-learn 1.0.2 which is incompatible.
google-colab 1.0.0 requires ipython==7.34.0, but you have ipython 8.14.0 which is incompatible.

אפשר להתעלם מההנחיות האלה.

התקנת LIT ו-Keras NLP

עבור ה-Codelab הזה יש צורך בגרסה עדכנית של keras (3) keras-nlp (0.8.0) ו-lit-nlp (1.1), וחשבון Kaggle כדי להוריד את המודל הבסיסי.

!pip install -q -U lit-nlp
!pip uninstall -y umap-learn
!pip install -q -U keras-nlp
!pip install -q -U keras

גישה לקגל

כדי להתחבר ל-Kaggle, אפשר לאחסן את קובץ פרטי הכניסה של kaggle.json ב-~/.kaggle/kaggle.json או להריץ את הפקודה הבאה בסביבת Colab. פרטים נוספים זמינים במסמכי התיעוד של חבילת kagglehub.

import kagglehub

kagglehub.login()

חשוב לאשר גם את הסכם הרישיון של Gemma.

4. הגדרת מודלים של LIT

import os

os.environ["KERAS_BACKEND"] = "tensorflow"

import keras
import keras_nlp

# Run at half precision.
keras.config.set_floatx("bfloat16")

model_name = 'gemma_instruct_2b_en'
gemma_model = keras_nlp.models.GemmaCausalLM.from_preset(model_name)

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

from lit_nlp.examples.models import instrumented_keras_lms

batch_size = 1
max_sequence_length = 512
init_models = instrumented_keras_lms.initialize_model_group_for_salience
models = init_models(model_name, gemma_model,
                     batch_size=batch_size,
                     max_length=max_sequence_length)

5. הגדרת מערכי נתונים של LIT

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

• prompt: הקלט לKerasGenerationModel.
• target: רצף יעד אופציונלי, כמו 'ground truth' תשובה (זהב) או תשובה שנוצרה מראש מהמודל.

LIT כולל קבוצה קטנה של sample_prompts עם דוגמאות מכמה מקורות שונים, כגון:

• GSM8K: פתרון בעיות במתמטיקה עם תלמידי בית ספר באמצעות דוגמאות משוטפות.
• נקודת השוואה של Gigaword: יצירת כותרות לאוסף של מאמרים קצרים.
• הנחיות חוקתיות: יצירת רעיונות חדשים לשימוש באובייקטים עם הנחיות/גבולות.

תוכלו גם לטעון בקלות את הנתונים שלכם, כקובץ .jsonl שמכיל רשומות עם השדות prompt ואופציונלית target (דוגמה), או מכל פורמט באמצעות Dataset API של LIT.

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

from lit_nlp.examples.datasets import lm as lm_data

datasets = {
  'sample_prompts': lm_data.PromptExamples(
      lm_data.PromptExamples.SAMPLE_DATA_PATH
  ),
}

6. הגדרת ממשק המשתמש של LIT

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

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

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

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

from lit_nlp.api import layout
modules = layout.LitModuleName

LM_SALIENCE_LAYOUT = layout.LitCanonicalLayout(
    left={
        'Data Table': [modules.DataTableModule],
        'Datapoint Editor': [modules.DatapointEditorModule],
    },
    upper={  # if 'lower' not specified, this fills the right side
        'Salience': [modules.LMSalienceModule],
    },
    layoutSettings=layout.LayoutSettings(leftWidth=40),
    description='Custom layout for language model salience.',
)

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

from lit_nlp import notebook as lit_notebook

lit_widget = lit_notebook.LitWidget(
    models=models,
    datasets=datasets,
    layouts={'default': LM_SALIENCE_LAYOUT},
    default_layout='default',
)

עכשיו אפשר להציג את ממשק המשתמש:

lit_widget.render(height=800)

אפשר גם לפתוח את LIT כדף מלא בכרטיסייה חדשה. מריצים את הקוד הבא ולוחצים על הקישור שמופיע:

lit_widget.render(open_in_new_tab=True)

הערה: אם משתמשים ב-LIT בסקריפט .py רגיל, יש להשתמש ב-lit_nlp.dev_server.Server() במקום ב-LitWidget כדי לפתוח שרת עצמאי. מידע נוסף זמין במסמכי התיעוד של LIT.

7. אנחנו מנתחים כמה הנחיות שוטפות ל-Gemma ב-LIT

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

זיהוי שגיאות בהנחיות מורכבות

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

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

def analyze_menu_item_template(food_likes, food_dislikes, menu_item):
  return f"""Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: {food_likes}
Taste-dislikes: {food_dislikes}
Suggestion: {menu_item}
Analysis:"""

נתקלת בבעיות בהנחיה הזו? התכונה LIT תעזור לכם לבחון את ההנחיה באמצעות מודול LM Salience.

8. שימוש בחשיבות לרצף לניפוי באגים

ההתאמה מחושבת ברמה הקטנה ביותר האפשרית (כלומר, לכל אסימון קלט), אבל LIT יכול לצבור את הנתונות לאסימונים למרווחי זמן גדולים יותר לפירוש, כמו שורות, משפטים או מילים. מידע נוסף על מידת הבולטוּת ועל אופן השימוש בה כדי לזהות הטיות לא מכוונות ב-Saliency Explorable.

נתחיל בהזנה של ההנחיה כקלט חדש לדוגמה עבור המשתנים של תבנית ההנחיות:

food_likes = """Cheese"""
food_dislikes = """Can't eat eggs"""
menu_item = """Quiche Lorraine"""

prompt = analyze_menu_item_template(food_likes, food_dislikes, menu_item)
print(prompt)

fewshot_mistake_example = {'prompt': prompt}  # you'll use this below

Analyze a menu item in a restaurant.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: You have to try it.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Baguette maison au levain
Analysis: Home-made leaven bread in france is usually great
Recommendation: Likely good.

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Macaron in france
Analysis: Sweet with many kinds of flavours
Recommendation: You have to try it.

## Now analyze one more example:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis:

אם ממשק המשתמש של LIT פתוח בתא שלמעלה או בכרטיסייה נפרדת, אפשר להוסיף את ההנחיה הבאה באמצעות Datapoint Editor של LIT:

דרך נוספת היא לעבד מחדש את הווידג'ט ישירות בהתאם לבקשה הרלוונטית:

lit_widget.render(data=[fewshot_mistake_example])

שימו לב להשלמת המפתיעה של המודל:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: A savoury tart with cheese and eggs
Recommendation: You might not like it, but it's worth trying.

למה המודל מציע שאתם אוכלים משהו שאמרת בבירור שאתם לא יכולים לאכול?

מידת הבולטוּת של הרצף יכולה לעזור להדגיש את בעיית השורש, כפי שהיא מופיעה בדוגמאות של כמה דוגמאות. בדוגמה הראשונה, נימוקי שרשרת המחשבה בקטע it has cooked onions in it, which you don't like לא תואמים להמלצה הסופית You have to try it.

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

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

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

def get_fewshot_example(source: str) -> str:
  for example in datasets['sample_prompts'].examples:
    if example['source'] == source:
      return example['prompt']
  raise ValueError(f'Source "{source}" not found in the dataset.')

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-fixed')}])

עכשיו השלמת המודל הופכת:

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish contains eggs and cheese, which you don't like.
Recommendation: Avoid.

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

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

9. בדקו את ההיפותזה כדי לשפר את התנהגות המודל

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

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

Analyze a menu item in a restaurant.

* The analysis should be brief and to the point.
* The analysis and recommendation should both be clear about the suitability for someone with a specified dietary restriction.

## For example:

Taste-likes: I've a sweet-tooth
Taste-dislikes: Don't like onions or garlic
Suggestion: Onion soup
Analysis: it has cooked onions in it, which you don't like.
Recommendation: Avoid.

...

lit_widget.render(data=[{'prompt': get_fewshot_example('fewshot-constitution')}])

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

Taste-likes: Cheese
Taste-dislikes: Can't eat eggs
Suggestion: Quiche Lorraine
Analysis: This dish contains eggs, which you can't eat.
Recommendation: Not suitable for you.

לאחר מכן ניתן לבדוק מחדש את מידת הבולטוּת של ההנחיות כדי להבין את הסיבה לשינוי:

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

10. לכלול צוותים לא טכניים בבדיקה ובניתוח של מודלים

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

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

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

11. Recap

לסיכום:

• ממשק המשתמש של LIT מספק ממשק לביצוע אינטראקטיבי של מודל, המאפשר למשתמשים ליצור פלט באופן ישיר ולבדוק "מה יקרה אם" במקרים מסוימים. האפשרות הזו שימושית במיוחד לבדיקת וריאציות שונות של הנחיות.
• המודול LM Salience מספק ייצוג חזותי של מידת הבולטוּת ומספק רמת פירוט של נתונים שניתנת לשליטה, כדי שאפשר יהיה לתקשר על מבנים ממוקדי אדם (למשל, משפטים ומילים) במקום על מבנים שמתמקדים במודל (למשל אסימונים).

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

לסיום: שיפור הדפים ב-Lt. כאן תוכלו לקבל מידע נוסף על התכונות שלנו ולשתף את ההצעות שלכם.