לעיון במאמר בנושא בינה מלאכותית גנרטיבית

הפעלה ב-Google Colab

הצגת המקור ב-GitHub

לומדים ב-Codelabs

מבוא

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

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

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

יעדי למידה:

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

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

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

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

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

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

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

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

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

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

כדי להוריד את המודל הבסיסי תצטרכו גרסה עדכנית של 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, תוכלו לאחסן את קובץ פרטי הכניסה של kaggle.json ב-~/.kaggle/kaggle.json או להריץ את הפקודה הבאה בסביבה של Colab. למידע נוסף, אפשר לעיין במשאבי העזרה של kagglehub.

import kagglehub

kagglehub.login()

הקפידו לאשר גם את הסכם הרישיון של Gemma.

הגדרת LIT עבור Gemma

הגדרת מודלים של 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. ה-framework של 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)

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

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

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

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

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

אתם יכולים גם לטעון בקלות נתונים משלכם, כקובץ .jsonl שמכיל רשומות עם השדות prompt ואפשר גם target ([example][jsonl-example]), או מכל פורמט באמצעות 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
  ),
}

הגדרת ממשק המשתמש של 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)

<IPython.core.display.Javascript object>

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

lit_widget.render(open_in_new_tab=True)

<IPython.core.display.Javascript object>

Analyzing Few Shot Prompts for Gemma ב-LIT

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

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

שתיים מהטכניקות החשובות ביותר ליצירת אבות טיפוס ואפליקציות מבוססות 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 תוכלו לבדוק את ההנחיה באמצעות מודול LMS.

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

המודול הזה מדגיש חלקים מההנחיה שהמודל מתייחס אליו כשהוא יוצר את התשובה. השכיחות מחושבת ברמה הקטנה ביותר האפשרית (כלומר, עבור כל אסימון קלט), אבל ב-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])

<IPython.core.display.Javascript object>

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

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.

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

עכשיו נתקן את ה "המלצה" שבדוגמה הראשונה ל-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')}])

<IPython.core.display.Javascript object>

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

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.

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

בוחנים את ההשערות כדי לשפר את ההתנהגות של המודל

עם 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')}])

<IPython.core.display.Javascript object>

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

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

לאחר מכן אפשר לבחון מחדש את החשיבות של ההנחיה כדי להבין למה השינוי הזה מתרחש:

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

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

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

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

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

Recap

לסיכום:

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

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

לסיום: Lit משתפר כל הזמן! כאן אפשר לקרוא מידע נוסף על התכונות שלנו ולשתף את ההצעות.

נספח: איך מערכת LIT מחשבת את שכיחות הרצף

טכנולוגיית LIT מחשבת את ההבלטה של רצף בתהליך רב-שלבי.

1. בהינתן מחרוזת קלט (הנחיה וגם יצירת המודל או רצף יעד מסוג 'זהב'), אפשר להמיר אותה לאסימונים לצורך קלט המודל.
2. מחשבים רצף "target" על ידי גלילת אסימוני הקלט מיקום אחד שמאלה.
3. מחלצים את ההטמעות עבור הרצפים של ה-"target", של היצירה וחישוב האובדן לכל אסימון.
4. מסתירים את האובדן כדי לבודד את האסימונים שרוצים להסביר.
5. משתמשים בפונקציה tf.GradientTape.gradient() כדי לחשב את ההדרגתיות של הטמעות הקלט ביחס לאובדן המסכה.
6. מעבדים את ההדרגות כדי לתת ציון אחד לכל אסימון קלט. לדוגמה, באמצעות שימוש בנורמת L2 של ההדרגתיות בכל מיקום.

נספח: חישוב חשיבות באופן פרוגרמטי

אפשר לחשב את ציוני החשיבות ישירות מ-Python, באמצעות אותם השלבים שמפורטים למעלה בכלי ה-LIT שמריצים באופן פנימי. יש שלושה שלבים:

1. הכינו דוגמה והפעילו את כלי ההמרה לאסימונים,
2. הכינו מסכה שבוחרת אילו אסימונים (חזויים) להסביר,
3. קוראים ל-wrapper של slience.

יצירת דוגמה לקלט עבור LIT

example = {
    'prompt': 'Keras is a',
    'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'
}
example

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**'}

הערה לגבי מוסכמות בקריאה: גם כלי ההמרה לאסימונים וגם wrapper משתמשים ב-Model API של LIT, שבו הפונקציה .predict() לוקחת רשימה של דוגמאות (דיקים) ומחזירה מחולל של תגובות (קריאות). האפשרות הזו הרבה יותר גמישה כשעובדים עם מערכי נתונים גדולים יותר או עם מודלים איטיים יותר. עם זאת, אם רוצים לקבל חיזויים רק בדוגמה אחת, עכשיו צריך להגדיר הכול בנוסח הבא: list(model.predict([example])[0]

קבלת אסימונים כדי לבחור יעדי הסברים

tokenizer = models[f"_{model_name}_tokenizer"].predict
tokens = list(tokenizer([example]))[0]['tokens']
tokens

array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
       '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
       '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
       '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
       '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')

כדי לחשב את הבולטות, צריך ליצור מסכת יעד שמציינת אילו אסימונים (חזויים) להסביר. מסכת היעד תהיה מערך באורך זהה לזה של אסימונים, עם 1s במיקום של האסימונים שברצונך להסביר. נשתמש ב-▁training וב-▁evaluating בתור היעד שלנו:

הכנה של מסכת היעד

import numpy as np

target_start = list(tokens).index("▁training")
target_end = list(tokens).index("▁evaluating")

# Prepare our mask
target_mask = np.zeros(len(tokens), dtype=np.float32)
target_mask[target_start:target_end+1] = 1
target_mask

# Add to our LIT input
example_for_salience = example | {'target_mask': target_mask}
example_for_salience

{'prompt': 'Keras is a',
 'target': ' deep learning library for Python that provides a wide range of tools and functionalities for building, training, and evaluating deep learning models.\n\n**',
 'target_mask': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
        0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
       dtype=float32)}

קוראים למודל הבולט

compute_salience = models[f"_{model_name}_salience"].predict
salience = list(compute_salience([example_for_salience]))
salience[0]

{'grad_l2': array([45.75, 36.75, 61, 5.40625, 4.09375, 5.625, 6.46875, 7.3125, 3.375,
        5.03125, 3.23438, 4.5625, 2.375, 3.40625, 2.75, 1.97656, 3.95312,
        3.42188, 14.125, 4.53125, 11.375, 12.625, 18.5, 4.5625, 6.5, 0, 0,
        0, 0, 0, 0, 0], dtype=bfloat16),
 'grad_dot_input': array([-4.03125, 3.04688, -7.03125, -0.800781, 0.769531, -0.679688,
        -0.304688, 2.04688, 0.275391, -1.25781, -0.376953, -0.0664062,
        -0.0405273, -0.357422, 0.355469, -0.145508, -0.333984, 0.0181885,
        -5.0625, 0.235352, -0.470703, 2.25, 3.90625, -0.199219, 0.929688,
        0, 0, 0, 0, 0, 0, 0], dtype=bfloat16),
 'tokens': array(['<bos>', 'K', 'eras', '▁is', '▁a', '▁deep', '▁learning',
        '▁library', '▁for', '▁Python', '▁that', '▁provides', '▁a', '▁wide',
        '▁range', '▁of', '▁tools', '▁and', '▁functionalities', '▁for',
        '▁building', ',', '▁training', ',', '▁and', '▁evaluating', '▁deep',
        '▁learning', '▁models', '.', '\n\n', '**'], dtype='<U16')}

זהו זה! הציונים בשדות grad_l2 ו-grad_dot_input תואמים ל-tokens, והם זהים לאלה שמופיעים בממשק המשתמש של LIT.

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