475 Jamba with Hofit from AI21

רברס עם פלטפורמה

[קישור לקובץ mp3]

פרק 475 של רברס עם פלטפורמה, שהוקלט ב-23 ביולי 2024, שיא הקיץ. אורי ורן מארחים את חופית מחברת AI21 Labs, כדי לדבר על מודלי-שפה גדולים עם Context ממש-ממש ארוך (וגם להסביר מה זה).

00:40 חופית ו-AI21

(רן) אבל קצת לפני זה - עליך, חופית, ועל החברה. מי את? מה עשית עד היום? מה עושים אצלכם בחברה?

• (חופית) אז אני חופית, ואני כרגע חוקרת ומפתחת מודלי-שפה בחברת AI21 Labs.
• נולדתי וגדלתי ברמלה, אם נחזור ממש להתחלה.
• בגיל 14 כבר התחלתי לתכנת - בבית הספר הכניסו אותנו לזה יחסית מוקדם - והבנתי שזה מה שאני הולכת לעשות כבר אחרי יומיים.
• אז הגעתי למודיעין, ליחידה צבאית, יחידה מודיעינית - דווקא לא תכנתתי שם, אבל ישר אחרי הצבא התחלתי תואר במדע המחשב באוניברסיטה העברית.
• מהר מאוד הבנתי שאני רוצה לשלב עם מתמטיקה. התאהבתי במתמטיקה - מתמטיקה תיאורטית, חשוב לציין, כי בתיכון לא כל כך אהבתי . . .
• אז עשיתי תואר משולב עם מתמטיקה.
• (רן) אז אם אני אבקש ממך עכשיו את הנוסחא של דטרמיננטה, את לא תדעי לשלוף לי . . .
• (חופית) ממש לא . . .
• (רן) . . . אבל תורת החבורות - בכיף . . .
• (חופית) תורת החבורות - אני מקווה שזה יהיה הדוקטורט שלי יום אחד . . . [ד”ש לגלואה].
• (חופית) ולקראת סוף התואר השני התחלתי לעבוד ב-Mobileye, בתור חוקרת - אבל בעולם ה-Vision.
• בעצם, כל עולם הראייה ממוחשבת וזיהויים, ופיתוח המכונית האוטונומית של Mobileye.
• וגם החלטתי שאני ממשיכה לתואר שני.
• בתואר השני, בהתחלה לא הייתי בטוחה מה אני רוצה לעשות - ידעתי שזה יהיה Machine Learning, ידעתי שאני רוצה לשלב גם תיאוריה.
• זאת אומרת, לא רציתי להתנתק מהתיאוריה.
• ובעצם התחלתי את את התזה שלי אצל פרופסור אמנון שעשוע.
• (רן) שמענו עליו . . .
• (חופית) כן . .
• (רן) נזכיר - אחד המייסדים של Mobileye, וגם של החברה, של AI21 . . .
• (חופית) נכון, ועוד כמה חברות כאלה ואחרות.
• וביום שהגעתי, המעבדה של אמנון עד אז התעסקה יותר ב-Vision, בקוונטים, בדברים כאלה ואחרים.
• כן בהקשרים כמובן של Machine Learning.
• וביום שהגעתי, אמנון פשוט החליט שעושים העברה לטרנספורמרים (Transformers) ול-NLP, כי יצאה עכשיו הארכיטקטורה.
• זה היה ב-2018, כשזה עוד לא התפוצץ - אבל אמנון ראה שזה הולך להתפוצץ.
• (רן) ימי BERT העליזים . . .
• (חופית) בדיוק, ימי BERT העליזים, לגמרי - זה היה הדבר הראשון באמת שהתעסקתי איתו.
• וככה הגעתי לתחום - זו הייתה הפעם הראשונה שבה בעצם נחשפתי לתחום בכלל.
• אפילו לא לקחתי קורסים ב-NLP לפני זה - אז זה באמת היה ממש כניסה שהייתה מאוד מפתיעה מצד אחד, ומצד שני הרגשתי שלא חסר לי יותר מדי רקע.
• כי טרנספורמרים היה משהו מאוד חדשני ושונה מהכלים שהיו קיימים לפני זה . . .
• (רן) . . . כולם פחות או יותר זינקו באותו זמן, זה היה איזשהו Equator, שהשווה את הסיכויים לכולם
• (חופית) נכון - אבל גם אם נסתכל על זה מבחינת מודל מתמטי, זה מאוד שונה מ-RNN ומ-LSTM, מה שהיה לפני, אז לא הרגשתי שיש לי יותר מדי פער, אפשר להגיד.

(אורי) כמו לכולם . . .

(רן) כן . . . . אז למי שזוכר את הרובוטריקים, כן היו שם טרנספורמרים - אבל לא עליהם אנחנו מדברים . . . . Transformer זה ייצור מתמטי, שמשתמשים בו ברשתות-ניורונים. למעשה, הוא ה-Building-Block המשמעותי בתוך מנועי-שפה גדולים. והזכרנו מקודם את BERT - זה היה אחד ממנועי-השפה הראשונים שהשתמשו ב-Transformer, אם לא הראשון בכלל . . . . זה הראשון או אחד הראשונים?

• (חופית) אני חושבת שהוא הראשון . . . . הוא היה Encoder-Only.

(רן) כן, Attention Is All You Need . . . . אוקיי, אז היית במעבדה של פרופסור אמנון שעשוע . . .

• (חופית) . . . . ושם נכנסתי לתחום.
• ביליתי שם בערך שנתיים - הוצאנו תזה שיש בה גם פן תיאורטי וגם פן טכני
• בעצם, דיברנו שם וחקרנו את ה-Tradeoff שבין עומק ורוחב של רשת
• “עומק” זה אומר כמה שכבות יש לה, וכשאנחנו מדברים על “רוחב” זה לרוב מימד-ההטלה (Projection), “הגבוה” שאנחנו מגיעים אליו כשאנחנו מטילים את הוקטורים של האינפוטים (Input vectors) שנכנסים למודל, שתיכף נדבר גם על זה יותר.
• בגדול, חקרנו את זה כי הבנו וראינו - גם הבנו תיאורטית, לשם אני פחות אכנס - אבל גם בעצם עשינו ניסויים ממש פרקטיים, שמראים את זה.
• שמה שהתרגלנו עד היום במודלי Vision, בכל הרשתות-קונבולוציה (But what is a Convolution?), זה שבעצם הרבה פעמים היא הייתה יחסית “צרה” ומאוד מאוד “עמוקה”.
• אנחנו מדברים על איזה 90, 120 אפילו 150 שכבות.
• ובטרנספורמרים (Transformers) פתאום זה קצת משתנה.
• אז באמת חקרנו את כל ה-Tradeoff הזה, הגענו למסקנות כאלו ואחרות ולכל מיני סוג-של-נוסחאות, שבעצם מראות מתי עדיף שרחב יותר, מתי עדיף שיהיה צר יותר
• יותר רדוד או עמוק יותר.

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

הרשת היא עמוקה או רחבה. זאת אומרת, הגעתם לאיזושהי נוסחה של מה ה-Tradeoff העדיף בהינתן Use Case.

• (חופית) נכון, ובעצם AI21, החברה שאז לא הכרתי בשלב הזה, אימצה את השיטה שלנו - וככה גם לראשונה נחשפתי אליהם.
• למה אימצה? כי AI21 מאמנת מודלי-שפה מאפס בעצם, Foundation Models, את כל שלב ה-Pre-Train, ממש ממש מאפס, משקולות מאותחלים ראנדומית (Random Initialization) לגמרי, כבר המון שנים.
• וזו החברה היחידה שעושה את זה בארץ.
• אז ככה הגעתי אליהם - כי ידעתי שזה מה שאני רוצה לעשות.

(אורי) אז רגע רגע - אולי תספרי לנו שנייה מה עושה AI21? חוץ מלאמן מודלים “לצורכי שעשוע” . . . זה משחק מילים, . . .

• (חופית) אז באמת, כל הפן של חדשנות טכנולוגית מאוד מאוד חשוב לנו, שעל זה גם ניכנס גם עם Jamba וניגע בזה ולמה ואיך.
• אבל היא בעצם מנגישה מודלים לעסקים כאלה ואחרים - אם זה בתחום ה-Finance ואם זה בתחום הבריאות ודומיינים (Domains) כאלה ואחרים.
• זאת אומרת, הרבה פעמים זה לעסקים שצריכים ממש את ה-Domain הספציפי שלהם, ומודל שאפילו הרבה פעמים המשיכו לאמן אותו על ה-Data הספציפי שלהם.
• והיום, רוב התעשייה לא יודעת לעשות את זה בעצמה - היא צריכה את האנשים שיעשו את זה בשבילה, ולהתבסס על המודלים שלהם גם.

(אורי) אז בא לקוח, יש לו Data, הוא יודע מה הוא רוצה להשיג מה-Data הזה - והוא בא אליכם, ואתם מאמנים לו מודל?

• (חופית) נכון, כן. “בין היתר”, אפשר להגיד . . .
• הרבה פעמים אנחנו מכוונים אותו למה הוא רוצה - כי הוא רוצה דברים מאוד גדולים,
• ואבליואציה (Evaluation) של מודל - זאת אומרת, השלב שבו אתה עושה לו טסט על בכלל מה אתה רוצה ממנו - זה שלב שהוא אתגר בפני עצמו.
• אם נשים רגע את האימון של המודל בצד, שזה האתגר שלי בצוות, אם אני כרגע בעצם בצוות של ה-Pre-Train Model ב-CTO Office, אני חוקרת שם.
• אז אנחנו עושים בעצם את כל השלב של ה-Pre-Train, כל השלב הראשוני
• ויש את השלב של אבליואציה (Evaluation) של הטסטים - של איך בכלל אנחנו בוחנים אותו.

(רן) האמת שהיום היו לי שלוש פגישות על זה . . . כן, זאת אומרת, יש דומיינים (Domains) שבהם אתה - יש לך איזשהו Ground Truth, זאת אומרת, אתה יודע מתי התשובה נכונה. עם LLM-ים, אין לך את זה בדרך כלל - אתה לא יודע מתי “הוא עושה עבודה טובה" או לא, וצריך לפתח גם את זה. כן, זה מורכב . . . .

אוקיי, אז את אומרת שעוזרים ללקוחות להבין מה הם רוצים - ומדלברים (Deliver) את מה שאתם יודעים בכיוון הזה.

• (חופית) נכון - וגם חשוב לנו לתרום לקהילה.
• זאת אומרת, אנחנו לא סתם שחררנו את Jamba כ-Open Source, כי רצינו באמת לראות מה הקהילה עושה,.
• מה היא לוקחת ומה היא עושה איתו.
• זה מאוד היה חשוב לנו לראות ההתפתחויות של הדבר הזה.

09:13 מה Jamba?

(אורי) טוב, אז זה פעם שלישית שאמרתם “Jamba” . . .

(רן) . . . עכשיו צריך להסביר . . . . כן, אז מה זה Jamba? אולי אפשר גם להתחיל היסטורית מה זה Mamba, “האימא שלו” . . . [לא קובי?]

• (חופית) נכון, אז בטרנספורמרים קצת נגענו - ואולי ניכנס קצת לטרנספורמר לפני שאנחנו בכלל מדברים על Jamba, על בעצם למה מגיעה המוטיבציה לדבר הזה, לשילוב ארכיטקטורות.
• אז ה-Core העיקרי, הדבר העיקרי, “הבלוק העיקרי” בטרנספורמרים בעצם, שהביא את כל החידוש, זה בלוק שנקרא Self Attention.
• שזו בעצם איזושהי מטריצה, שמתארת אינטראקציות בין כל Input - לעצמו.
• זאת אומרת שכל Token - יש לו איזושהי . . . .
• ובעצם זו מכפלה-וקטורית שקורית בסוף - אבל זה איזשהו Score או . . . בעצם, כמה יש לי אינטראקציה עם ה-Token שהיה לפני בסדרה.
• זאת אומרת, לכל ה-Token-ים, לאורך כל ה-Context.
• אז בהינתן סדרה - יש את החישוב הזה שקורה, ואפשר לקרוא לו . . .

(רן) . . . סליחה, אני אתן דוגמא - . . .

• (חופית) כן, מעולה

(רן) . . . - “איש עומד ליד עץ - האם הוא יפה?”. “הוא” - מתייחס לאיש או מתייחס לעץ? המילה “הוא”. אני אגיד שוב את המשפט - “איש עומד ליד עץ, האם הוא יפה?”. זה דו-משמעי, נכון? האם המילה “הוא” מתייחסת לעץ או מתייחסת לאיש, שעומד לידו? אנחנו לא יודעים. המטרה של ה-Self-Attention היא למעשה למקד את ה-Attention של המילים האחרות אל הסובייקט, אל החלק במשפט, אל ה-Token במשפט שהוא למעשה הנושא של

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

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

• (חופית) נכון, זו אחלה דוגמה. למשל, אם נסתכל על מטריצה אחרת או על מודל שאומן כבר, אנחנו אכן נראה שכנראה “הוא” מתייחס . . .
• אנחנו נראה Score יחסית גבוה של “הוא” ו”עץ” ושל “הוא” ו-”האיש”
• זה למשל מה שרואים בסוף המטריצה הזאת אחרי שהיא מאומנת.
• אחרי שכל הפרמטרים כבר מאומנים, נעשה את ה-Self-Attention וזה מה שנראה.
• אז מה שקורה בעצם זה שיש לנו את המטריצה הזאת בכל Block Attention . . .

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

• (חופית) אבל כמו שאמרנו - זו בעצם מטריצה שהיא אורך ה-Input על אורך ה-Input
• כי כל Token - יש לו אינטראקציות עם כל שאר ה-Token-ים, זה ממש מחושב, כל ה-Score הזה, הממוצע המשוקלל הזה.
• וכשאנחנו מגיעים כבר לסדרות באורך 256K Token-ים למשל, שעל אורך הסדרה הזאת אימנו את Jamba בין היתר, אז אנחנו מדברים על חישוב שהוא כבר ריבועי באורך ה-Context, באורך הסדרה.
• ואם ניכנס לזה אפילו יותר ונדבר על זה שבזמן, ב-Inference Time, זאת אומרת שעושים Decoding, כשאנחנו מייצרים בכל פעם את ה-Token הבא, אנחנו שומרים איזשהו . . .
• זה נקרא KV-Cache - ל-Token-ים הקודמים שהיו.
• כי אתה לא רוצה לחשב על כל פעם מחדש - זה מאוד מאט לך את האימון.
• אבל אז השמירה של של הוקטורים האלה, כשיש לנו קונטקסט מאוד מאוד ארוך, ולכל אחד ממנו בעצם יש וקטור כזה . . .
• בכל Block-Attention, לאורך כל הטרנספורמר - זה בעצם כבר תופס המון המון זיכרון.
• אז זה לא רק עניין של Latency - שאנחנו בעצם מחשבים הכל וזה מאט אותנו - זה גם עניין של זה שזה תופס הרבה זיכרון.

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

(אורי) כדי לסרוק את כל המטריצה הזו . . .

(רן) כן, כדי להחזיק את זה . . . . עכשיו, אם מדובר על משפט פשוט בן עשר מילים, אז אוקיי - אז מאה, עשר בריבוע זה מאה, סבבה. אבל כשאנחנו מדברים על Context מאוד ארוך, כמו נגיד ספר או סרט, אז מספר ה-Token-ים הוא ענק, מגיע למאות אלפים, כמו שאמרת 256K . . .

• (חופית) נכון מאוד, ואם כבר מדברים על ספר או סרט - אז למה בכלל מעניין אותנו ספר או סרט?
• אז לאחרונה, אנחנו בעצם מחפשים כל פעם להתאים את עצמנו לדברים החדשנים - כרגע - בתעשייה.
• ו-Retrieval למשל זה אחד הדברים היותר מדוברים כרגע.
• שמה זה אומר? זה אומר שכשאני מבקש איזשהו Output מהמודל שפה, יש לי Instruction שאני נותן לו - ואני לאו-דווקא רוצה שהוא יתבסס על הידע שלו.
• זאת אומרת, אני לא רוצה שהוא ייתן לי “בשלוף” פשוט פרדיקציה (Prediction) של המודל.
• הייתי רוצה שלפני זה, יהיה איזשהו שלב מקדים - של כלי, שמביא בעצם כל מיני מסמכים שמתאימים לשאילתה שלך, מסמכים שמגיעים ממקור שהוא אמין ובטוח.
• ועל בסיס זה . . . זאת אומרת, המודל יראה את כל המסמכים האלה כ-Prompt, והוא יג'נרט (Generate) לך תשובה בהתאם למסמכים האלה.
• אז כשאנחנו כבר מגיעים ונכנסים לעולמות ה-Retrieval האלה, שאנחנו מגיעים ל-Context-ים שהם מאוד מאוד ארוכים.
• אתה יכול לקבל מסמכים, שאולי לא כל המסמך קשור, אבל חלקים בו קשורים אז אתה כן מקבל את כולו.
• המודל בעצמו יודע לעשות האדפטציות (Adaptations) המתאימות - אבל בסוף, ה-Context הופך להיות מאוד ארוך.

(רן) בואי ניתן דוגמא - נגיד, רופא בבית חולים שרוצה להתייעץ עם מנוע-שפה: “מה הבעיה של איציק?”. אוקיי, הגיע חולה, קוראים לו איציק, והוא רוצה לשאול אותו מה הבעיה שלו [הוא חושב שהעולם יפה?]. אוקיי, נניח שהוא אומר שיש לו תסמינים, לא יודע - חום גבוה, דופק וכו’. אבל מה המנוע-שפה לא יודע? את כל ההיסטוריה הרפואית של איציק, נכון [שלא לדבר על תל אביב ב-80s]? ובלי להבין את ההיסטוריה הרפואית של איציק, אי אפשר או שקשה מאוד לתת פרוגנוזה או דיאגנוזה או איך שקוראים לזה. אבל אנחנו יכולים לעזור לו - אנחנו יכולים לשלוף מתוך ה-Database את ההיסטוריה הרפואית ולבוא ולהגיד לו ב-Prompt “הנה ההיסטוריה הרפואית של איציק”, וזה יכול להיות ספר, זאת אומרת שזה יכול להיות הרבה הרבה דברים. “בהינתן זה, עכשיו תגיד מה הבעיה של איציק”, בהינתן שיש לו לחץ דם ודופק גבוה. זה משהו שאפשר לעשות רק עם Context מאוד ארוך, נכון? כי צריך לספק את

כל ההיסטוריה הרפואית. אז זה Use Case אחד.

• (חופית) נכון - ויש גם את עולמות הקוד, שניהיו נורא מבוקשים, שאנחנו מדברים ב-Repo-ים שלמים, שהמודל יכול להחזיק בעצם ב-Context שלו.
• ויש את עולמות ה-Chat - שאתה בעצם מתחיל Chat עם איזשהו מודל-שפה כזה או אחר, השיחה מאוד מאוד מתנפחת, אתה מקבל סוג של Out of Context - “אין לי Token-ים יותר! בוא נתחיל שיחה חדשה . . . “.
• אז בעצם אנחנו רוצים להיתגבר על הקשיים האלה באמצעות אימון מודלי-שפה ל-Context-ים ארוכים.

(רן) אז זו המוטיבציה, ואם עד עכשיו דרך אגב, מי שכן משחק עם אימון שפה והרבה פעמים מוגבל באורח ה-Context,

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

16:28 איך פותרים את בעיית ה-Context?

(רן) אז איך פותרים את בעת ה-Context? אמרנו שבטרנספורמרים, צרכי הזיכרון גדלים ריבועית כגודל ה-Input, וזו בעיה . . . אז איך כן פותרים את זה?

• (חופית) אז זה גם זיכרון וגם בעצם ה-Latency עצמו - המהירות שבה אנחנומחשבים את המטריצה הזאת, לאורך כל הטרנספורמר.
• אז בעצם, לאחרונה יצאו כל מיני מודלים שהם לא מבוססים Self-Attention, מודלי-שפה שהם מבוססי State-ים
• כמו ה-RNN-ים שאנחנו מכירים - זאת אומרת ש-Token נכנס, יש לנו איזושהי הכפלה במטריצה שקורית, ויש לנו State שמתעדכן בכל פעם שה-Token הבא נכנס.

(רן) כלומר, “מה קראתי עד עכשיו במשפט?” - זה ה-State.

• (חופית) נכון, “מה קראתי עד עכשיו במשפט”, בדיוק.
• אבל ה-State הזה מתעדכן כל פעם - זאת אומרת, ה-Token לא יוצר איזושהי אינטראקציה עם כל ה-Token-ים שהיו עד עכשיו. אלא רק עם ה-State, כפי שהוא עודכן עד עכשיו.

(אורי) אבל ה-State הוא בעצם ה-State של המטריצה - מעובד בצורה כלשהי . . . המטריציה שהייתה עד עכשיו.

• (חופית) נכון - אבל הוא כבר ראה המון Token-ים עד עכשיו . . .

(רן) זה איזשהו “סיכום”, סיכום-ביניים - “הנה זה מה שקראתי עד עכשיו”.

(אורי) . . . איזשהו Inference מסוים של מה היה עד עכשיו.

• (חופית) כן, נכון.

(רן) . . . . ואז האינטראקציה היא Order of 1, פחות או יותר, אם אני מבין אותך. או קרוב לזה . . .

• (חופית) כן, אפשר להגיד. אם מסתכלים על זה בהשוואה ל-Attention אז אפשר להגיד.

(רן) כן, אבל רגע - אבל זאת לא בדיוק הבעיה ש-RNN נתקלו בה? זאת אומרת, גם ה-RNN-ים ניסו לסכם איזשהו State, והם עשו את זה ביעילות אבל לא באפקטיביות אם נקרא לזה . . . זאת אומרת, הם “לא סיכמו את זה טוב”.

אז איך המודלים החדשים . . . .?

• (חופית) נכון. אז הם לא סיכמו את זה טוב, היו כל מיני בעיות כאלה ואחרות.
• מה שקרה זה שבעצם ב-RNN זה שמהר מאוד אתה “שכחת את ה-Token-ים הראשונים שלך”, וזאת הייתה אחת הבעיות.

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

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

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

(רן) כן - “ספר”. ו-Mamba פותר את זה? איך?

• (חופית) אז ה-Mamba . . . . בעצם, יש כל מיני דברים, יש כל מיני שיטות לאתחל את המטריצה הזאת, שבעצם על בסיסה אנחנו כל פעם מעדכנים את ה-State.
• את ה-State הזה, שאחר כך רץ בין כל Token-ים.
• אז יש כל מיני שיטות כאלה ואחרות - יותר שיטות מתמטיות, שבעצם עוזרות יותר לתת משקלים גם ל-Token-ים שהיו בעבר.
• שיהיה להם יותר משקל, שאתה לא “שוכח” אותם, אתה כן נותן להם יותר משקל.
• וזה לא רק זה - ה-Mamba, בעצם החידוש שלהם היה גם שאומנם המטריצה הזאת, שמעדכנת את ה-State, היא מטריצה אחת ויחידה, אבל יש עוד כל מיני מטריצות שנכנסות לתהליך.
• ששם, לכל מטריצה, לכל Token, היתה מטריצה משלו.
• זאת אומרת, המימדים שלנו הם כבר לא היו על מימד אחד, אלא כן על מימד אורך הסדרה.
• אז אתה אומר לעצמך “רגע, אבל שוב אני מגיע למצב ש...”

(רן) “שאני מרגיש מרומה קצת . . . .”

• (חופית) נכון . . . אז איך אני עושה את זה, אם שוב יש לי משהו שתלוי באורך הסדרה? אז מה קורה פה?
• אז בעצם, Mamba - הגישה החדשנית שלהם הייתה ש”אנחנו עושים את זה בצורה יעילה”, וזה נכנס לרמת החומרה (Hardware) אפילו .
• הם ייעלו את זה ברמת ה-Copy מרכיב זיכרון אחד לרכיב זיכרון אחר ב-GPU, הרכיב הרחוק יותר והקרוב יותר.
• “איך אני מצמצם כמה שיותר את ה-Copy האלה, את העתקות משני הרכיבים וכו’.
• אני לא אכנס לזה יותר מדי . . .

(רן) אוקיי, כלומר - דרישות-הזיכרון נשארו בערך אותו דבר, אבל ה-Latency פחת? או שגם דרישות-הזיכרון . . . .

• (חופית) יש יותר דרישות-זיכרון. לא כמו דרישות . . . . בסוף זה כן - ה-State בסוף כן נשאר ומתעדכן, ה-State עצמו כן מתעדכן ע”י מטריצה יחידה.
• אבל דרישות-הזיכרון הן הרבה פחות מטרנספורמרים, כמובן.
• הן כן יותר מ-RNN-ים - אבל שוב, הכל עניין של Tradeoffs, כי Mamba מאוד משמר את ה-Token-ים הראשונים האלה.

(רן) כן אוקיי - זאת אומרת, זה איזשהו Sweet-Spot בין ה-RNN-ים, שהיו “שוכחים” הרבה, לבין הטרנספורמרים - שהיו זוכרים “הכל”, אבל גם היו מאוד “בזבזנים” מבחינת זיכרון וגם, כמו שאמרת, מבחינת Latency.

• (חופית) נכון - ואנחנו חשבנו מאוד לאפטם (Optimize) את ה-Inference בעיקר, אפילו יותר מאשר את האימון.
• כי בסוף, הלקוח זה מה ש...

21:14 מ-Mamba ל-Jamba ו-Mixture of Experts

(רן) אוקיי. עכשיו: Mamba זה איזושהי שיטה וזה משהו שהוא ככה, Widespread - ואתם לקחתם ובניתם מודלים

משלכם, שקראתם להם Jamba. אז מה קורה שם?

• (חופית) נכון. אז קודם כל, אם נסתכל באופן כללי על טרנספורמרים, מודלי שפה, או שנקרא לזה Deep Neural Network - זה בעצם המון המון בלוקים שמקונקטים (Concatenate) אחד אחר השני.
• כל בלוק הזה - יש לו Input שהוא באורך הסדרה, ו-Output שהוא באורך הסדרה.
• אז אם נסתכל על כל בלוק הזה בנפרד, נגיד לעצמנו “זה לא מדע נורא נורא קשה או מאתגר”, לחבר את הדברים האלה
• כי זה כל היופי בבלוקים האלה - גם של ה-Self-Attention וגם של ה-Mamba
• ומזה אתה בעצם יכול לבנות רשת עמוקה.
• אז קודם כל, יש לנו בעצם גם את ה-MLP, שזו השכבה הליניארית בעצם - שאנחנו מטילים למימד גבוה יותר, ואז מחזירים למימד נמוך יותר, כדי תמיד להיות באותה מימד שאיתו נכנסת לרשת, לבלוק.
• אז זה בעצם מה שעשינו - שילבנו.
• הגענו לאיזושהי נקודה, שהיא גם עם Latency יחסית טוב - כרגע פי שלוש ממודל Transformer-Only, Self-Attention-Only.
• (רן) . . . זאת אומרת פי-שלוש יותר מהיר . . .
• (חופית) . . . פי-שלוש יותר מהיר - על Long-Context, על קונטקסטים ארוכים.
• ומצד שני - לא איבדנו מה-Accurecy של המודל, מכמה הוא “טוב”, מכמה . . . .
• זאת אומרת - על המון Benchmark-ים מוכרים היום, ראית איך Mamba . . .
• כי לפני זה, עשינו המון המון אבלציות (Ablation) עד שהגענו לדבר הזה, בכלל לשילוב הזה.
• חשבנו שאנחנו נוציא בהתחלה מודל שהוא רק Mamba ומודל שהוא רק טרנספורמר - ואז ראינו של-Mamba יש את הבעיות שלו
• שאני אתן לכם דוגמא - יש למשל את כל נושא ה-Few-Shots - זה כשאני אתן לך איזשהו From פורמט של Input ו-Output, אתן לך כמה דוגמאות, והייתי רוצה שבשאלה הבאה שלי, תוציא לי את אותו Format, אוקיי? למשל...
• (רן) נגיד, אם אתה זוכר ממבחן פסיכומטרי - אנולוגיות: “בית לדלת, זה כמו מטבח למקרר”, זה כמו... “עכשיו, תן לי עוד אחד!”
• (חופית) נכון. אז אנלוגיות זה עוד משהו קשה - אני אלך אפילו למשהו קל יותר, אני אלך לביקורות.
• ביקורות הכי בסיסיות - על הסרטים, של Negative ו-Positive
• אז נתת לו כמה דוגמאות, ואמרת לו “תן לי עכשיו ביקורת על הדוגמא החדשה הזאת”
• ובמקום להשתמש ב-Positive או Negative, שממש-ממש חשוב לך שזה יהיה מדויק ל-Input של ה-User שלך, הוא יכול להגיד לך “Nice”, או “Bad”, או להשתמש לאו דווקא ב...
• (רן) כן, זאת אומרת - להגיד לו “הנה, תענה בסגנון של שלושת הדוגמאות הבאות” - ומעכשיו הוא עונה בסגנון של שלושת הדוגמאות שנתתי לו.
• (חופית) נכון - אז את זה הוא לא עשה, הוא לא השתמש בדיוק באותו פורמט, וזה מאוד מזכיר State
• כי State בעצם שומר באיזשהו מקום את “המהות” של המילה - לאו דווקא את המילה עצמה.
• זאת אומרת, את המשמעות שלה, או מה היא אומרת.
• אז זו הבעיה שנתקלנו בה, וזה אכן . . . כל הבנצ'מרקים (Benchmarks) שהיו מבוססים למשל, על Few-Shot, או בכלל על פורמטים מסוימים של איך שאלה ותשובה אמורות להיראות - שם Mamba היה נופל.
• ואז, פשוט אמרנו “אז בואו נשלב!”
• בסוף, Sequence to Sequence - נכנסת סדרה, יוצאת סדרה, של Token-ים.
• אז בעצם, שילבנו את שני הדברים האלה - ביחס שהוא יחסית כל . . . .
• שבע שכבות, שיש בהן בלוקים של Mamba, ואז עוד שכבה אחת של Attention
• כי כמו שאמרתי - ה-Attention היה מאוד “מעיק”, מבחינת זיכרון ו-Inference Time, ב-Long Context, שהיה חשוב לנו מאוד מאוד לאפטם (Optimize).

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

• (חופית) נכון, כן, בדיוק.
• כן יצא לנו לעשות . . . בעצם, המאמרים שיצאו על Mamba, זה היה על מודלים מאוד מאוד קטנים, כל הניסויים.
• על מודלי מיליארד אחד, אפילו שבעה מיליארד.
• ואנחנו נכנסנו כבר לעולמות של . . . . אמנם, זה ה-Jamba ששחררנו היה מודל של 12 מיליארד Active Params, שתכף אני אסביר מה זה.
• אבל כל המודל היה 50 מיליארד פרמטרים - שזה המון.
• והתחלנו גם לאפטם (Optimize) את הדברים ב-Mamba עצמו
• ראינו שהאקטיבציות (Activations), למשל - שהגדלים של הוקטורים שהוצאנו ב-Mamba ממש “מתפוצצים”, נהיים עצומים.
• אתה צריך להוסיף Layer Normalization, אתה צריך כן להיכנס קצת לדברים שהם יותר “פנימה”
• זה לא איזשהו משהו סגור לחלוטין, שאתה לא נוגע בו.
• אז כן היה את האתגרים שם, שזה אתגרים באופן כללי של מודלים גדולים, כשאתה נחשף למודלים.
• זה היה, אני זוכרת כשעברתי מהתזה - פתאום בתזה, כשאתה מאמן מודלים קטנים, ללאמן מודלים גדולים
• אתה נחשף לאתגרים אחרים לגמרי . . .

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

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

(אורי) אבל זה גם כאילו . . . . העולם של התעשייה מתעסק בסוף במה שקורה באמת; בעולם של האקדמיה הם מחפשים את ה-Novelty, ולא . . .

• (חופית) אני מסכימה . . .

(אורי) . . . . העולם האמיתי הוא Outlier . . . . [באמפר סטיקר?]

• (חופית) נכון, אני גם חושבת שאני ממש רואה את זה ככה.
• אני הייתי חוקרת בתזה, והפכתי להיות . . . . נקרא לזה מ-Deep Learning Researcher, ל-Deep Learning Engineer Researcher.
• כי פתאום, למקבל מודל . . . כי מודל גדול - אתה חייב למקבל אותו, הוא לא ייכנס לך.
• גם כשאתה מגיע לשכבה היחידה שאתה כרגע מתעסק בה באימון - היא לא תיכנס לך בזיכרון. זה לא יקרה.
• ואז יש כבר Model Parallelism - אתה מתחיל לחלק את ה-Tensor-ים של הפרמטרים שלך בין GPU-ים שונים.
• זה פתאום להתעסק עם דברים שאתה לא... זה ממש מרגיש שלא נגעתי בהם לפני זה - וזה עולם ומלואו.
• וזה עולם שצריך לחקור בו. אז זה...

(אורי) בסוף, זה ה-Blocker-ים . . . .

• (חופית) נכון ,זה ה-Blocker-ים . . . . אלו בדיוק ה-Blocker-ים.

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

(רן) Inputs יותר? . . . “מבין יותר טוב”?

• (חופית) הוא יותר “Context-aware”, בוא נקרא לזה.

(אורי) כן ... הוא “מקבל טון” בתוצאות שלו. אבל כשאת אומרת “בסדר, לקחנו כמה State-ים של ה-Jamba”,

והוספנו כמה... סליחה, “ . . . כמה State-ים של ה-Mamba, והוספנו עוד כמה טרנספורמרים” - בסוף, מה קרה לזיכרון?

• (חופית) אז הזיכרון . . . אז אתה מוצא את ה-Tradeoff, אתה מוצא את ה-Tradeoff ביניהם.
• אז אתה לא תהיה עם הזיכרון הכי מינימלי שתקבל רק עם Mamba-only, אבל אתה כן חסכת המון.
• אני יכולה להגיד לך שלפחות ב... אני אתן לך דוגמא:
• ב-Inference time של 256 - של Context באורך של 256K, אם ניקח מודל שהוא זהה ל-Jamba שהוצאנו, אבל Transformer-only, ה-KV Cache שלו יהיה בגודל של 32GB, על ה-Context הזה של 256K,
• ואם זה יהיה... וה-Jamba שלנו מגיעה ל-8GB - אז חסכנו פה לא מעט...

(אורי) אז בכל מקרה זה חיסכון . . . .

(רן) עכשיו, שימו לב - זה לא Disc-Space - כי Disc-Space לא חסר. מדובר פה על זיכרון ב-GPU, וזה מאוד מאוד יקר. אוקיי? תסתכלו בטבלה של מחירים של AWS ותבינו מה המחירים של הדברים האלה. זה לא משחק ילדים - לחסוך כל כך הרבה GB של זיכרון זה מאוד מאוד משמעותי. זה יכול להיות הבדל בין “יש לנו עסק” או “אין לנו עסק”.

• (חופית) נכון - וגם אנחנו חושבים על זה, כשאנחנו מוציאים אותו לקהילה.
• בין אם זה שהם ימשיכו לעשות Fine-tuning למודל, בין אם זה “שישחקו איתו” ויעשו איתו דברים.
• לרוב יש לאנשים GPU אחד - זה לא ה-Resource-ים שיש לנו, שאנחנו מחזיקים בחברה.
• זה גם כמובן נלקח בחשבון.
• ול-Jamba שלנו גם הוספנו MOE - שזה נקרא Mixture of Experts, שזה גם מושג לאחרונה ששומעים אותו הרבה.
• שזה בעצם מה שרציתי להגיד לגבי ה-Active Params שאמרתי מקודם, וכמות הפרמטרים “האמיתית” של המודל.
• אז מה שקורה זה שכל שכבה שנייה . . . . Mixture of Experts זה לא משהו שאנחנו המצאנו, זה משהו שהגיע מבחוץ.
• אנחנו פשוט שילבנו את זה כחלק מה-Jamba, בצורה שהייתה נראית לנו נכונה, טובה, והכי יעילה לדברים שאנחנו רצינו להשיג.
• בכללי, מה הרעיון אומר? הרעיון אומר שאם יש לנו את השכבה הליניארית שבה אנחנו עושים הטלה שנמצאת בין כל הבלוקים של ה-Mamba וה-Attention.
• בין כל בלוק כזה, יש בעצם שכבה שנקראת MLP, שזו שכבה ליניארית שרובנו מכירים - היא עוד “מהרשתות הקלאסיות” . . .

(רן) אם אי פעם ראיתם רשת ניורונים - זה זה . . . “עיגולים מחוברים בקווים, שמחוברים לעיגולים בשכבה הבאה” - זה

מה שנקרא MLP.

• (חופית) נכון, זה ה-MLP.
• אז בגדול, לנו, עד עכשיו כל המודלים הרווחים שהיו בחוץ היו בעצם שכבת MLP אחת בין כל Attention, בין כל

בלוק Attention.

• וה-Mixture of Experts בא ואומר שאנחנו יכולים בעצם להחזיק, למשל, בשכבה אחת, במקום להחזיק שכבת MLP אחת כזאת, אנחנו נחזיק - אנחנו, לפחות במודל של Jamba, שמנו 16 בלוקים כאלה, של MLP.
• ולפי ה-Token שמגיע - מגיעה הסדרה של Token-ים, ולכל Token יש איזשהו Router,
• כשה-Router מחליט - זה Router נלמד כמובן, כמו כל הפרמטרים - שהוא מחליט לאיזה Expert ה-Token הזה מתאים.
• ואז אתה לא מנצל את כל ה-Expert-ים, זאת אומרת - ה-Active Params שלך, הפרמטרים שכרגע אתה משתמש בהם, הם של Expert אחד.
• כי אתה מחליט שה-Token הזה הולך ל-Expert הזה.
• אבל כל ה-Expert-ים האלה נלמדים במהלך האימון - כי כל Token ילך ל-Expert שונה.

(רן) אני אנסה רגע להסביר את זה בדרכי שלי, “הציורית” - נניח שאתם יודעים לדבר חמש שפות, ועכשיו אתם שומעים משהו בצרפתית, אז זה הולך לאיזור אחד במוח. אתם שומעים אחר כך משהו בערבית, אז זה הולך לאזור אחר של המוח. אבל אתם אף פעם לא משתמשים בו-זמנית, בכל חמשת השפות, או שסביר להניח שלא תשתמשו בו-זמנית - ולכן חלק מהמוח שלכם כל הזמן ”במנוחה". אוקיי, אז Mixture of Experts הוא למעשה “ה-Router” שמחליט “אה, זה צרפתית! זה הולך לאזור הזה של המוח, ולכן כל השאר יכול לנוח”.

איך מרוויחים מזה, בחומרה? מה זה עוזר לנו בעצם? אז למעשה, אנחנו לא צריכים להשתמש בו זמנית בכל הפרמטרים, שזה אומר אפשר לחסוך - תקני אותי אם אני טועה - אפשר לחסוך בזיכרון, אפשר לחסוך ב-Cycle-ים של GPU בזמן ה-Inference - ולמעשה, המודל, פוטנציאלית, הוא אולי 50 מיליארד פרמטרים, אבל למעשה, אני יכול להתייחס אליו, מבחינת “המשקל שלו”, כ-12 מיליארד פרמטרים.

(אורי) בהנחה שאנחנו "נפספס” איזה משהו - שתלוי “בחוכמה” של ה-Router.

(רן) אם ה-Router טועה, אז כן - “אכלנו אותה” . . .

• (חופית) אז ה-Router - הוא נלמד לאורך המון המון צעדים, אז הוא לרוב לא טועה, הוא אכן מגיע למקומות שאכן צריך להגיע אליהם.
• אני כן אדייק פה לגבי זיכרון - כל המודל יושב בזיכרון, כל ה-50 מיליארד פרמטרים, זה אומר שחיסכון בזיכרון אין.
• אבל מבחינת Latency, כמות ה-FLOP-ים והאופרציות שה-Token הזה יעבור לאורך הרשת, תהיה כמו מודל בגודל 12B, ולא כמו מודל בגודל 50B, 50 מיליארד.

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

• (חופית) כן.

(רן) אז ה-Mixture of Experts למעשה נמצא בין כל אחת מהשכבות שלכם?

• (חופית) אז בין כל שכבה שנייה. לא כל שכבה, אלא בכל שכבה שנייה שמנו אותו.
• שוב, זה עניין של . . . בסוף אנחנו מחזיקים המון המון גם בזיכרון, והמטרה הייתה לאפטם (To Optimize).
• המטרה ספציפית ב-Jamba הייתה לאפטם את זה שאנחנו יכולים להחזיק בזיכרון את כל המודל שלנו על GPU אחד, עד Context של 128K.
• אם היו לנו עד 256K, הוא דורש כבר יותר מ-GPU אחד, של 80GB.

(רן) כן. זיכרון . . . והגדלים באים בדרך כלל באופן סטנדרטי, ככה שיש את “המשבצת הנכונה” ל-80GB.

34:38 תרומה לקהילה

(רן) הזכרת מקודם תרומה לקהילה, ואת זה שאתם רוצים שכל אחד בקהילה יוכל לריץ את המודל. אז מה זה אומר? המודל הזה הוא פתוח?

• (חופית) אז הוא Open Source - הוא פתוח ב-Hugging Face, כן.
• אנשים יכולים לגשת לשחק איתו, להמשיך לאמן אותו גם.
• ממש “להיכנס לנבכי הארכיטקטורה” שלו.
• ובאמת שכל אחד מוזמן - זה רק יעזור לנו לקבל פידבקים.

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

אתם שיחרתם את Jamba, את הגרסה של - זה נקראת בעצם 50B או איך זה נקרא?

• (חופית) אז זה נקרא, זה 712B אפשר להגיד . . . למה עברנו מ-7B? מה שעשינו, MOE, מה שהחלטנו לעשות ועוד כמה חברות עשו את זה כמובן, זה להחליט לא לקחת Expert אחד אלא לקחת שני Expert-ים לכל Token.
• להוסיף לו עוד אקספרסיביות (Expressiveness), עוד רמה של אקספרסיביות בעצם.
• מה שהפך את המודל בעצם להיות מאיזה 7-8B פרמטרים, Active Params - ל-12 מיליארד Active Params.

(רן) כן, אז 7 כפול 12, זו התוצאה?

• (חופית) כן. זה 12 מיליארד פרמטרים - ו-50 מיליארד פרמטרים בסך הכל.

(רן) אוקיי, ואפשר לקחת - בהינתן GPU מספיק גדול, וכאלה כן קיימים, כלומר כן אפשר לשלם עליהם ולקבל אותם - ואפשר לרוץ ולהשתמש במודל. אם אורך Context מאוד מאוד ארוך חשוב - אם זה לשיחת -Chat פשוטה, אתם לא צריכים את ה-Context הזה, אבל אם זה “תקרא את כל הקוד שלי ותגיד לי איזו פונקציה אני צריך לכתוב” או “תציע לי Completion לפונקציה” או אם זה “תקרא את כל ההיסטוריה הרפואית ותן לי אנליזה” או “תראה את הסרט הזה” - לא דיברנו כל כך על Medim-ים אחרים, אבל גם זה משהו שעובד - אז זה יכול בהחלט לעבוד עם מודל שכזה.

דרך אגב - יש מודלים אחרים ששיחררתם בקוד פתוח?

• (חופית) שיחררנו את זה ואת ה-Instruct שלו.
• אבל עוד לא - יש מודלים גדולים שמתבשלים בדרך, כן. “גדולים באמת”.

(אורי) אני גם שנייה שנייה חופר ב-GPU שלי - במבצע סבתא יש בחמישה Token-ים פחות מ-128K . . .

(רן) יפה, אז אפשר אפשר להשלים את הסרט.

(אורי) כן, לא כולל מוטי בננה.

• (חופית) באמת?
• (אורי) לא.

37:18 כתוביות

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

אז היה מרתק, תודה רבה!

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

(אורי) יפתח לאנשים את המודל . . .

(רן) . . . . מוזמנים להיכנס ל-Hugging Face, להוריד משם - ולהתנסות.

האזנה נעימה ותודה רבה לעופר פורר על התמלול!