close menu

על הכוח הלא הגיוני של דיברטה (DEBERTA)

נכון לרגע זה – אימון של כל מודל שפה ששמו אינו מתחיל בD ונגמר ב"יברטה" זאת פשוט טעות. [1][2]
יש רק מודל שפה אחד – דיברטה. גרסה 3.

וכמה שיותר גדול – יותר טוב. (DeBERTa – microsoft/deberta-v3-large)

למה המודל הזה כל כך חזק?
ומאיפה מיקרוסופט הביאה אלינו בכלל את כל הקסם הזה?

רקע נחוץ על טרנספורמרים

בשלב הזה, כמעט ולאף אחד אין אומץ להודות שהוא לא סגור עד הסוף על איך טרנספורמרים עובדים.
רובנו יודעים שזה "משהו עם אטנשן ושלושה טנזורים (V Q K) כשחלק מהחישוב קורה במקביל (Multi-Head) מכל הטוקנים לכל הטוקנים בכל בלוק."
הסיבה לכך היא שהמאמר החלוץ בנושא Attention Is All You Need, Vaswani. et al.[3] כתוב איום ונורא. למרות זאת למזלנו הוא התקבל פורסם ושינה את עולם. כל טכנולוגיות השפה (כולל אלו היוצרים תמונה משפה) המודניות לא היו קיימות היום אם המאמר היה נשכח.
למה אטנשן עובד?
לא. לא איך אטנשן עובד.

ל-מ-ה אטנשן עובד?

ולמי שמתעניין בא-י-ך אטנשן עובד, יכול למצוא סיכום שלי כאן [4].

נניח שאנו עובדים על בעיית תרגום מאנגלית לעברית, שבה רצף לדוגמה הוא "הכדור האדום". והמטרה היא "The red ball".
רצף הטקסט מועבר תחילה דרך שכבת Embedding וPosition Encoding (עוד רגע נדבר על זה), אשר יוצרת וקטורי יצוג עבור כל מילה (מדובר בטוקן. נשתמש ב"מילה" בשביל קריאות.) ברצף. היצוג מועבר ל-Encoder שם הוא מגיע לראשונה לבלוק האטנשן.
בתוך האטנשן, רצף היצוג עובר דרך שלוש שכבות ליניאריות המייצרות שלוש מטריצות שונות. שאילתה Q, מפתח K וערך V. אלו שלושת המטריצות המשמשות לחישוב ציון האטנשן. ציון זה הוא מספר המכמת "כמה המילה חשובה" או "כמה חשוב לשים לב למילה זו" ברצף. מכאן מגיע גם השם אטנשן – תשומת לב.
עד כאן, שיעור Deep Learning בגן חובה.
מכאן מתחיל להיות מעניין.
חשוב לזכור מהכפלת המטריצות והאורתוגונליות של האמבדינגס שכל וקטור שורה במטריצות הללו מתאימה למילה אחת (ויחידה) ברצף המקור.
כדי להבין איך כל מילה ברצף המקורי ורצף התוצאה מקיימת אינטראקציה עם מילים אחרות ברצף המקורי ורצף התוצאה נתרכז באילו פעולות מבוצעות על כל מילה, וכיצד כל וקטור ממופה למילת הקלט המקורית ונתעלם מהפרטים הטכנים. נתעלם למשל מממד האמבדינגס, הסופטמקס, הנרמול וכל הסיבובים והחלוקות שעוברים הטנזורים כדי שכל המימדים יסתדרו. נתמקד רק ב"למה?" כל זה עובד. ולא ב"איך".
כי אחרי שמבינים "למה?", להוסיף נרמול אם חסר או לסובב את הטנזורים בצורה קצת אחרת כדי שיתאימו.
עבור מילה בודדת:
  • כל מילה עוברת סדרה של טרנספורמציות נלמדות.
  • כל שורה במטריצה (לכל עומק המודל) נוצרה ממילת מקור מתאימה על ידי סדרה של טרנספורמציות: קידוד מילה, קידוד מיקום ושכבה לינארית.
האטנשן מבצע מספר שלבים – נתמקד רק בשכבה הליניארית ובציון באטנשן ("כמה חשוב "לשים לב" ") (מרכאות בתוך מרכאות – כי אני עד כדי כך מנפנף בידיים).
  • הצעד הראשון בתוך הוא כפל מטריצה בין מטריצת השאילתה (Q) לבין מטריצת המפתחות (K).
  • אנו מקבלים מטריצה (מטריצת ביניים) שכל תא בה הוא תוצאה של כפל מטריצות בין שתי מילים שונות. לדוגמה, כל עמודה בשורה הרביעית תואמת לתוצאת הכפל בין מילת השאילתה הרביעית ל-כ-ל מילות מפתח.
  • ציון האטנשן תוצאת חישוב בין המפתחות ו"הערך": כפל מטריצה בין מטריצת הביניים לבין מטריצת "הערך" (V) ונקבל את תוצאת האטנשן. נזכור מאיפה כל שורה הגיעה: למשל השורה הרביעית מגיעה מטריצת השאילתה הרביעית כפולה עם כל שאר מילות המפתח והערך.
עוד פעם: לכל מילה, הוקטור מטריצת "הערך" משוקלל עם מטריצת הביניים שהיא תוצאת חישוב השאילתה של אותה המילה עם המפתח של כל המילים.
עוד פעם: לכל מילה, היצוג של אותה המילה, משוקלל עם זוג יצוגים – יצוג האחראי על "קריאת מידע מיצוגי המילים האחרות" ו "שליחת מידע אל יצוגי מילים אחרות" המשוקללים ביחד.
עוד פעם: לכל מילה, משמעות המילה בנפרד ומשמעות המילה בשילוב עם משמעות כל אחת מהמילים האחרות יתנו לנו את משמעות המילה במשפט כולו.
  • שורות במטריצת השאילתה (Q): המילה (w) עבורה נרצה לחשב את האטנשן.
  • שורות במטריצת המפתח (K): עד כמה המילה הזו (לא w) רלוונטית למילה שעבורה נרצה לחשב את האטנשן (w).
  • שורות במטריצת הערך (V): משמעות המילה הזו "בנפרד" מהמילה שעבורה נרצה לחשב את האטנשן (w).
  • ושורות V – "משמעות כל מילה" (V) ממושקלות לפי רלוונטיות המחושבת לכל מילה על פי "משמעות" אותה המילה (Q) בשילוב עם "משמעות" כל אחת מהמילים האחרות (K) (שגם הן נלמדות בנפרד לכל מילה).
עכשיו יותר קל להבין איך לסדר את כל הפרטים הטכנים.
  • רצינו שכל מילה "תשלח" יצוג למילים האחרות? נכפיל בK Transpose במקום K.
  • רצינו שיצוג V "ישוקלל" לפי חשיבות? ננרמל הכפלת QK^T.
לדוגמה, עבור המשפט "הכדור האדום", שורת המילה "אדום" תכיל את תוצאת החישוב "אדום" עם כל אחת מהמילים האחרות במשפט כאשר "אדום" היא מילת השאילתה, והמילים האחרות יהיו ה"מפתח/ערך".
אטנשן לוכד את האינטראקציה בין מילה מסוימת, לבין כל מילה אחרת במשפט. אבל למה כפל מטריצות קובע את הרלוונטיות בין שתי מילים?
במכפלה פנימית בין וקטורים, מכפילים זוגות מספרים ואז סוכמים אותם.
• אם שני המספרים חיוביים או שניהם שליליים, התוצאה תהיה חיובית – תגדיל את הסכום הכולל.
• אם מספר אחד חיובי והשני שלילי, התוצאה תהיה שלילית – תקטין את הסכום הסופי.
• ועבור תוצאה חיובית, ככל ששני המספרים גדולים יותר – כך הם תורמים יותר לסכום הסופי.
ובהכללה לאטנשן:
אם וקטורים של שתי מילים קרובים יותר, ציון האטנשן בניהן יהיה גבוה יותר. ציון האטנשן יהיה גבוה עבור שתי מילים הרלוונטיות זו לזו במשפט. והניקוד יהיה נמוך עבור שתי מילים שאינן קשורות זו לזו.
לדוגמה:
"החתול השחור שתה חלב", המילה "חלב" רלוונטית מאוד ל"שתה" ואולי קצת פחות רלוונטית ל"חתול", ולא רלוונטית בכלל ל"שחור". אבל שחור כן תהיה רלוונטית ל"חתול".
האטנשן ילמד:
– החתול X השחור: מעניין.
– החתול X שתה: מעניין.
– החתול X חלב: פחות מעניין.
– החתול X החתול: מעניין.
– השחור X החתול: מעניין.
– השחור X שתה: לא מעניין.
– השחור X חלב: לא מעניין.
– השחור X השחור: מעניין.
– שתה X החתול: מעניין.
– שתה X השחור: לא מעניין.
– שתה X חלב: מעניין.
– שתה X שתה: מעניין.
– חלב X החתול: לא מעניין.
– חלב X השחור: לא מעניין.
– חלב X שתה: מעניין.
– חלב X חלב: מעניין.
האטנשן ילמד את יצוג המילים כך שאם שתי מילים במשפט רלוונטיות זו לזו, אז וקטורי המילים שלהן יהיו קרובים יותר. ומכאן ציון האטנשן יהיה גבוה יותר. עבור מילים שאינן רלוונטיות זו לזו, וקטורי המילים יהיו שונים יותר ויפיקו ציון אטנשן נמוך יותר.
לכן יצוגי האטנשן של "חלב" ו"שתה" יתאימו ויניבו ציון אטנשן גבוה בשילובם.
לסיכום:
  • החישוב בין השאילתה למפתח לומד את הרלוונטיות בין כל זוג מילים.
  • רלוונטיות הזו משמשת עבור סכום משוקלל של כל מילות הערך. הסכום המשוקלל הזה הוא ציון האטנשן.
  • טרנספורמרים לומדים יצגוים כך שמילים רלוונטיות אחת לשנייה דומות יותר.
  • זו הסיבה להפרדה המשולשת באטנשן: עבור כל מילה נלמד את – "היצוג שלי". "היצוג שאני שולח למילים האחרות". "היצוג שאני מקבל מהמילים האחרות". בנפרד.
הבאג הגדול בטרנספורמרים: Positional Encoding.
מההסבר הקודם עולה בעיה: טרנספורמרים לא יכולים ללמוד סדר. הם רק לומדים אינטרקציה בין "דברים" ל"כל שאר הדברים".
אם נבלגן את המילים במשפט הטרנספורמר עדיין ילמד את אותו היצוג.
כדי לפתור את הבעיה הזו משתמשים בקידוד מיקום Positional Encoding: פשוט מוסיפים sin/cos לקלט כדי שהמודל יידע מאיפה בדיוק במשפט מגיעה המילה.
מודל הטרנספורמר המלא (BERT) מתחיל כשרצף הקלט מוזן לשכבת האמבדינגס ו-Position Encoding אשר מייצר ייצוג עבור כל מילה ברצף הקלט ומכאן היצוג עובר אל כל שלושת המטריצות: שאילתה, מפתח וערך וכך נוצר ייצוג לכל מילה.
אחרי BERT:
קצת לאחר שחרור BERT, כשעולם עיבוד השפה כולו היה במערבולת "הצעות לשיפורי BERT", פורסם המאמר הטוען כי: ארכיטקטורת BERT המקורית חזקה יותר מכל מודל משופר אחר שפורסם אחריה.
הכותבים הצליחו להגיע לתוצאה זו באמצעות חיפוש היפרפרמטרים כבד והרבה טריקים אחרים הקשורים לשיטת האימון.
הם כינו את השיטה שלהם R-obustly O-ptimized BERT pretraining A-pproach או פשוט RoBERTa.

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

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

מדריך: לאמן טרנספורמרים זה איום ונורא

על הקשיים באימון טרנספורמרים לא צריך להרחיב אבל חשוב לציין חלק מהם כי הם הבסיס לשיפורים שהגיעו עם דיברטה.
רוברטה (וכל מודלי BERT למניהם) רגישים ב-ט-י-ר-ו-ף לאורך הרצף ומיקום במילים בטקסט.
ואם לא ברור עד כמה זה חמור:
  • המשפט: "היי, מה נשמע?"
  • והמשפט: " היי, מה נשמע?"
יקודדו שונה לחלוטין (!!) בחלק מהמודלים.
ומכאן המצב רק הולך ומחמיר: רוברטה (הגדול ביותר) אומן על רצפים באורך 1024. מיותר לציין שאינו תומך ברצפים ארוכים יותר (הוא דווקא מכליל לא ע-ד כ-ד-י כ-ך נורא. שפצרו בעצמם את הקוד הממש ידידותי למשתמש ולא מסורבל סתם של Huggingface כך שהוא לא יקפיץ לכם שגיאות ונסו בעצמכם).
ואם יצא לכם פעם להסתכל על כמה טקסט נכנס בתכלס ב1024 טוקנים כנראה ששמתם לב בעצמכם שמדובר בכמה משפטים ולא יותר.
ואם פשוט נרצה לאמן אחד יותר גדול?
אם נקח בחשבון שעלות אימון RoBERTa Base (אפילו לא Large) משוערכת לכרבע מיליון דולר (ל512 טוקנים) נקבל שעיבוד מילת טקסט אחת היא עניין מאד יקר. את רוב הבעיות המשמעותיות ביותר עדיין אי אפשר לפתור במחיר סביר (וגם לא להפוך למוצר).
דרך אגב: התחושה הלא נוחה הזאת שמודלי שפה מבינים אותנו בערך כמו Bag-of-words: מצליחים להבין מילות מפתח אבל מתקשים במשפט עצמו?
הבעיה הזו נובעת ממודלי שפה עם Positional Encoding ישן. המודלים באמת מתקשים ללמוד את סדר המילים ולומדים בעיקר את משמעות המילים. ההתנהגות הזו גורמת להם "להתפס" על מילות מפתח ולא על משמעות המשפט כולו.

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

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

שיפורים לPositional Encoding:

שני שיפורים קלים לPositional Encoding של BERT (ורוברטה):
  • אמבדינגס נלמד, הגיע עם GPT: במקום להוסיף sin/cos. פשוט נלמד בשכבת אמבדינגס נפרדת יצוג לכל אחד מתאי האינדקס (ממש range(len(x)) תסתכלו להם בקוד). זה אמנם משפר משמעותית את תוצאות המודל אבל המודל עדיין יתבלבל מ"ה י י מ ה , ק ו ר ה ?".
  • אמבדינגס רלטיבי, הגיע עם TransformerXL: לכל מילה, נלמד את יצוג המילה כך שבחישוב האינטרקציה עם כל אחת משאר המילים נוסיף יצוג נלמד נוסף של המרחק (ממש ממש המרחק באינדקסים שלמים. הכי פשוט שאתם יכולים לדמיין) בין המילים.
משום מה, המאמר TransformerXL שהציג לראשונה מודל שמכליל לאורכי רצפים ארוכים יותר מאלה שהוא אומן עליהם נשכח ולא זכה לפופולריות הרבה שהוא ראוי לה. בניגוד לBigBird "הטרנספורמר הארוך" שגם לא מכליל לאורכי רצפים ארוכים יותר וגם לא עובד.

חוץ מOpenAI. הם כן שמו לב.

בשקט בשקט בחלק מהגרסאות הכי חדשות של GPT3 הם שילבו את האטנשן של TransformerXL במקום האטנשן של GPT.

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

השינוי מוזכר כהערת שוליים שולית ולא חשובה באחד מהמאמרים. הסיבה: Slightly better performance.

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

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

טרנספורמרים שמכלילים בין אורכי רצפים

גרסה ראשונה – DeBERTa V1

בניגוד לגוף פופולרי אחר שחרט על דגלו להעתיק כמה שיותר קוד סתם, הקוד של מיקרוסופט באמת ממש טוב. השתמשתי בהרבה חלקים ממנו והם "פשוט עובדים".
קחו לעצמכם דקה להציץ בקוד המקורי, קל הרבה יותר להבין את המוטיבציה מאחורי ההחלטות במודל מתוך הקוד המקורי. כנראה שהמודל הזה כנראה והולך להשאר איתנו עוד הרבה זמן.
מודל DeBERTa בנוי כמו RoBERTa בשילוב כמה שיפורים חשובים:
  • פתרון לבעיות הPositional Encoding שהוצעו במאמר
ב DeBERTa אנו לומדים כמו בGPT גם יצוג למיקום (אמבדינגס על וקטור אינדקסים -range(len(x))) רק שכאן אנו לומדים יצור נפרד בכל בלוק בכל עומק ברשת.
כך שלכל טוקן נלמדים שני יצוגים – תוכן ומיקום.
  • וגם האינטרקציה בין הטוקנים השונים מחושבת קצת אחרת
על מנת לחשב את ציון האטנשן, משתמשים בשלוש מטריצות שונות.
  • אינטרקצית "תוכן לתוכן" הלומדת לחשב את מעבר האינפורמציה בין משמעויות המילים השונות.
  • אינטרקצית "תוכן למיקום" הלומדת לחשב את השפעת משמעות המילים על משמעות המיקומים במשפט.
  • אינטרקצית "מיקום לתוכן" הלומדת לחשב את השפעת המיקום על משמעות המילים.
בגלל שדיברטה עובדת (עובדת? עובד?) כ-ל כ-ך יותר טוב מכל דבר אחר, DeBERTa xsmall הקטנה פי כמה וכמה מרוברטה עוקפת אותה בביצועים.
מה שמוריד את עלות האימון של מודל מאפס (לא Pretrained) מרבע מיליון דולר ל.. "לא יותר מידי?"..

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

מפה לשם אימנתי כמה מודלים כאלה מאפס (גם בעברית כי למה לא) ואני יודע לספר לכם על עוד כמה שיפורים שאפשר לעשות למודלים.
שיפורים פיראטיים לDeBERTa
  • החלפת האטנשן באטנשן רלטיבי (כמו בTransformerXL). אפס מאמץ. שיפור ענקי בביצועים.
  • הוספת יצוג מיקום "הפוך" הלומד את המרחק מסוף המשפט ולא רק מתחילת המשפט. כך היצוגים יכולים ללמוד רק היכן הם במשפט. גם כמה המשפט ארוך.
  • עוד שיפור קטן בביצועים (כנראה שלא שווה את כוח החישוב) תקבלו מלהוסיף אמבדינגס שסופר גם לאמצע המשפט ולא רק לסוף וההתחלה.
  • שיפור ענק בביצועים גם תקבלו אם תוסיפו את כל הטריקים שיש באטנשן של LongT5. לא אכנס לפרטים אבל הוא תוצאה של "כל הטריקים האפשריים" ועוד שיפורים למאמרים אחרים שמנסים ללמוד יצוגי טקסט ארוך.
המודל דיברטה הוא המודל הראשון שעקף את ביצועי בני האדם בSuperGLUE.

ולמי שלא מכיר את המשימות בSuperGLUEs: זה חולני.

רגע.
לא סיימנו.

גרסה 2 – DeBERTaV2

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

דרך אגב: כך למשל המודלים של AI21 עוקפים את GPT3 כמעט בהכל. (כמעט בהכל: 16 מתוך 19 דאטהסטים)

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

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

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

השיפור הסודי ולא מתועד: "גרסה 2.5"

שיפור שקט שהופיע בקוד בין הגרסאות ומשום מה לא מדברים עליו:

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

מגיע מהתחום המדעי:
"דברים שאפשר סתם להעתיק לקוד בלי להבין והם משפרים ביצועים בחינם" או בשמו הרישמי Adversarial Learning.
מיקרוסופט גם הלכו צעד אחד קדימה ושיפרו גם כאן את השיטות החזקות ביותר (החזקות ביותר למשל FGM[4]).
התוצאה היא השיטה: Scale Invariant Fine-Tuning או SiFT.
משום מה כמעט ולא מדברים על השיטה הזו למרות שהיא מעניקה לכל דורש "ביצועים בחינם".
ובגלל שהקוד שלהם באמת טוב: פשוט תלשתי אותה משם, זרקתי על המודל וזה עבד.

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

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

גרסה 3 – DeBERTaV3

מודלי שפה מאומנים "להשלים" מילים. בכל שלב "מסתירים" מהמודל מילה במשפט ועליו לנחש מה היתה אותה המילה במשפט המקורי.
נקרא Masked-Language-Modeling או MLM.
טריקים פשוטים לשיפור MLM: (לא במאמר)
  • במקום מילים קחו רצפים באורך N (היפרפרמטר), במקום להשלים מילה ספציפית על המודל להשלים חלקים ארוכים מהמשפט. יותר קשה: יותר ביצועים.
  • להסתיר מהמודל עוד מילים גם בקלט וגם בפלט (זה גם סוג של Dropout ברמת הCPU למי מאיתנו שקצר בזכרון GPU)
  • פשוט Focal Loss
השיפור העיקרי במאמר: במקום להסתיר משפטים, נשתמש במודל נוסף שילמד "איך לדפוק" את המודל שלנו בצורה הטובה ביותר.
השיטה הוצגה לראשונה לפני כמה שנים במאמר של אלקטרה (ELECTRA), המודל ש"דופק" את המודל שלנו מחליף בכל שלב מילה במשפט במילה אחרת ועל המודל שלנו להחליף את המילה בחזרה למילה המקורית.
למה זה עובד?
במקום ללמוד ממילה אחת (כמו בMLM) אנחנו לומדים מכל המילים במשפט (כי כל מילה יכולה להיות "השקר") ובנוסף, המודל המאמן לומד לאורך האימון להחליף מילים במשפט בצורה כזו שקשה מאד (גם לבן אדם) לשים לב אילו מילים הוחלפו.
שיטה זו דוחפת את המודל ללמוד יצוגים עדינים הרבה יותר כמו "סטייל כתיבה" כי חלק מהחלפות המילים מבוצעות על מילים בעלות אותה המשמעות אבל במשלב לשוני אחר שאינו מתאים למשפט.
המשימה הזו נקראת היום Replaced Token Detection (RTD) ונחשבת להרבה יותר איכותית מMLM.

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

שיפור השיטה RTD:

הם לא נרגעים שם במיקרוסופט..

הכותבים גילו שבמימוש \ מאמר המקורי של אלקטרה הכותבים השתמשו בשיתוף משקולות בחלק מהשכבות בין הגנרטור לדיסקרימינטור.
הם "חצי" שחררו אותן: אם משחררים אותן לגמרי המודלים מתבזרים. במקום: הם משתפים אותן אבל מעדכנים את המשקולות המשותפות רק באימון הדיסקרימינטור.
התוצאה היא המודל החזק בהיסטוריה: DeBERTaV3.
כשמודל אחד בודד משפיל אנסמבל ענקי ודאטהסט ענק בסדרי גודל
כל מי שהסתובב לאחרונה בקאגל שם לב שאת כל תחרויות הNLP ניצחו DeBERTaV3-large. כל אחד בשילוב עם הטריקים שלו.
עד כאן כנראה שכבר ניחשתם.
אני רוצה להסב את תשומת לבכם לתחרות אחת ספציפית: AI4Code.
מבלי להכנס לפרטים יותר מידי קטנים, בתחרות המשתתפים קיבלו מחברות Jupyter מקאגל כשקטעי הקוד והטקסט בהן מבולגנים והיה עליהם לסדר מחדש את המחברות.
הקונספט עצמו מגניב מאד כי כדי למדוד מי הכי מדויק פשוט חיכו שלושה חודשים ומדדו את התוצאה על המחברות "מהעתיד" שעלו לקאגל בתקופה הזו.
אתם רוצים לנחש בעצמכם מה עשה המנצח?
אתם רוצים לנחש מה הוא לא עשה?
אנסמבל.
אנסמבל הוא לא עשה.
מודל אחד
המנצח אימן מודל דיברטה אחד (אפילו בלי Foldים!), הטוויסט: הוא פשוט אימן אותו באורך וקטור ענקי. ככה שהמודל רואה (כמעט תמיד) את כל המחברת במכה כוקטור אחד.
באותה הנשימה חשוב להוסיף: לאורך כל התחרות שלטו בטבלה מודלים שאומנו מראש על קוד כמו CodeBERT, GraphCodeBERT CodeBERTa, CodeT5.

שחלקם אומנו על כל (!!!) גיטהאב.

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

בנושא אחר: למישהו יש קצת זכרון GPU שהוא לא צריך?

_____
רפרנסים:
[1] אם אינכם צריכים לייצר טקסט. כמובן. האופציות ליצירת טקסט הן: T5 (ועדיף longT5 כי יש בו הרבה שיפורים מעבר לתמיכה באורך ארוך) או GPT להשלמת טקסטים.
[2] שחרור דיברטה גרסה 1 – ונצחון ב SuperGLUE מול בני אדם: https://www.microsoft.com/…/microsoft-deberta…/
[3] – המאמר הראשון על טרנספורמרים – https://arxiv.org/abs/1706.03762
[4] – איך אטנשן עובד https://machinelearning.co.il/…/tweet-sentiment…/
[5] – שיטות שעובדות אם סתם תזרקו אותן על המודל: https://arxiv.org/pdf/1710.06081
עוד בנושא: