BitNet.cpp: הדור הבא של בינה מלאכותית כללית

• אלגו ריתם
• אוקטובר 30, 2024
• חדשות בינה מלאכותית, מודלי שפה
• AI, LLMs
• 0תגובות

BitNet.cpp: דור חדש של בינה מלאכותית כללית

ב-17 באוקטובר 2024, חברת מיקרוסופט הכריזה על BitNet.cpp – מסגרת היסק חדשנית שמיועדת להריץ מודלים לשוניים גדולים (LLMs) מכווצים ל-1 ביט בלבד. BitNet.cpp מהווה צעד משמעותי קדימה בתחום הבינה המלאכותית הכללית (Gen AI), המאפשר פריסה יעילה של LLMs בני 1 ביט על מעבדי CPU סטנדרטיים, ללא צורך בגרפיקה ייעודית ויקרה. התפתחות זו ממשיכה את מגמת דמוקרטיזציית הגישה ל-LLMs, והופכת אותם לזמינים במגוון רחב יותר של מכשירים ויישומים לבינה מלאכותית מוטמעת (on-device AI).

הבנת מודלים לשוניים גדולים בני 1 ביט

מודלים לשוניים גדולים (LLMs) במתכונת המסורתית דורשים משאבי חישוב משמעותיים, בשל השימוש בממתרים בדיוק גבוה של נקודה צפה (בדרך כלל FP16 או BF16) עבור משקלי המודל. דרישה זו הפכה את פריסת LLMs ליקרה ודורשת אנרגיה רבה.

בבסיסם, LLMs בני 1 ביט משתמשים בטכניקות כיווץ קיצוניות כדי לייצג משקלי מודל באמצעות שלושה ערכים בלבד: -1, 0 ו-1, ולכן הכינוי “1.58 ביט” (מכיוון שנדרש קצת יותר מביט אחד כדי לקודד שלוש מצבים אפשריים).

מערכת משקלים טרנרית

הרעיון המרכזי

הכיווץ ל-1 ביט בתשתית BitNet.cpp מתבסס על מערכת משקלים טרנרית. BitNet פועל עם שלושה ערכים אפשריים בלבד עבור כל פרמטר:

• -1 (שלילי)
• 0 (ניטרלי)
• 1 (חיובי)

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

הבסיס המתמטי

הכיווץ ל-1 ביט כולל המרת משקלים ופעילויות לייצוג טרנרי שלהם באמצעות השלבים הבאים:

1. בינריזציה של משקלים
   בינריזציה של המשקלים כוללת ביניון סביב הממוצע (α), המתרגם לייצוג טרנרי. השינוי מבוטא מתמטית כך:

   Wf=Sign(W−α)
   כאשר:
   W היא מטריצת המשקלים המקורית.
   α הוא ממוצע המשקלים.
   Sign(x) מחזירה +1 אם x > 0, ו- -1 אחרת.

2. כיווץ פעילויות
   כיווץ הפעילויות מבטיח שהקלטים יהיו מוגבלים לרוחב סיביות מסוים:
   x^e=Quant(x)=Clip(γx×Qb,−Qb+ϵ,Qb−ϵ)
   כאשר:
   Qb = 2^(b-1) הוא רמת הכיווץ המרבית עבור רוחב b-bit.
   γ היא הערך המוחלט המרבי של x (מסומן כ-||x||∞).
   ε הוא מספר קטן למניעת גלישה במהלך החישובים.
3. פעולת BitLinear
   שכבת BitLinear מחליפה כפלי מטריצה מסורתיים בפעולה מופשטת:
   y=Wf×x^e×(Qbβγ)
   כאשר:
   β הוא גורם שיקלול המשמש למזעור שגיאות אפרוקסימציה.
   γ מחלק את הפעילויות.
   Qb הוא גורם הכיווץ.
   המרה זו מאפשרת חישובים יעילים תוך שימור ביצועי המודל.

השלכות על הביצועים

יעילות זיכרון משופרת

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

• LLMs מסורתיים: 16 ביט לכל משקל
• BitNet.cpp: 1.58 ביט לכל משקל

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

1. מהירות היסק משופרת על מעבדי CPU

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

על Apple M2 Ultra: BitNet.cpp משיגה עד 5.07x תאוצה למודלים גדולים יותר (30B) בהשוואה ל-Llama.cpp, עם מהירות שיא של 593.43 טוקנים לשנייה עבור מודל בגודל 125M, שהיא תאוצה של 1.37x. עבור מודלים גדולים יותר כמו 3.8B ו-7B, BitNet.cpp שומרת על מהירות מעל 84.77 טוקנים לשנייה, ממחישה את יעילותה בכל הסולמות.

על Intel i7-13700H: BitNet.cpp משיגה שיפורי מהירות דרמטיים אף יותר. בגודל מודל של 7B, BitNet.cpp מספקת תאוצה אדירה של 5.68x בהשוואה ל-Llama.cpp. עבור מודלים קטנים יותר כמו 125M, היא מעבדת 389.08 טוקנים לשנייה, שהיא מהירות של 2.37x גבוהה יותר מאשר Llama.cpp.

2. יעילות אנרגטית מרשימה – משנה את חוקי המשחק למכשירי קצה

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

על Apple M2 Ultra: חיסכון האנרגיה של BitNet.cpp הוא מהותי. עבור המודל בגודל 700M, היא צורכת 55.4% פחות אנרגיה לטוקן בהשוואה ל-Llama.cpp, בירידה מ-0.314 ל-0.140. מגמה זו נמשכת עבור מודלים גדולים יותר, כאשר המודל בגודל 70B מראה הפחתה של 70.0% בצריכת האנרגיה.

על Intel i7-13700H: BitNet.cpp מספקת חיסכון אנרגיה של 71.9% עבור המודל בגודל 700M, עם צריכה יורדת מ-1.367 ל-0.384. למרות שאין נתוני אנרגיה עבור המודל בגודל 70B ב-Llama.cpp, BitNet.cpp נותרת יעילה, עם צריכת אנרגיה של 17.33 עבור המודל בגודל 70B.

3. חציית קו הבסיס של מהירות קריאה אנושית

אחת התובנות המעניינות ביותר מגרפים אלה היא ההתייחסות למהירות קריאה אנושית, המסומנת ב-5-7 טוקנים לשנייה. קו אדום זה מראה ששתי המימושים, ובמיוחד BitNet.cpp, יכולים לעבור בנוחות את מהירות הקריאה האנושית גם עבור המודלים הגדולים ביותר:

על Apple M2 Ultra, BitNet.cpp עוברת את מהירות הקריאה האנושית עבור כל גדלי המודל, כשהמהירות הנמוכה ביותר היא 8.67 טוקנים לשנייה עבור מודל בגודל 70B.

על Intel i7-13700H, המודל בגודל 100B עדיין משיג 1.70 טוקנים לשנייה, כמעט ונוגע בטווח התחתון של מהירות קריאה אנושית, בעוד שכל המודלים הקטנים יותר עוברים קו בסיס זה.

התייחסויות להדרכת המודל

Straight-Through Estimator (STE)

מכיוון שכיווץ 1-ביט מכניס פונקציות לא דיפרנציאליות, ההדרכה כוללת טכניקה ייחודית הידועה כ-Straight-Through Estimator (STE). בגישה זו, הגרדיאנטים זורמים ללא שינוי דרך הנקודות הלא-דיפרנציאליות. הנה דוגמה לקוד פשוט ב-Python:

class StraightThroughEstimator(Function):
    @staticmethod
    def forward(ctx, input):
        return input.sign()
    @staticmethod
    def backward(ctx, grad_output):
        return grad_output

הדרכת דיוק מעורב

כדי לשמור על יציבות במהלך ההדרכה, משתמשים בשיטת דיוק מעורב:

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

אסטרטגיית שיעור למידה גבוה

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