Colibri: 744 מיליארד פרמטרים על לפטופ - איך זה בכלל אפשרי

"Colibri לוקח מודל של 744 מיליארד פרמטרים - מהסוג שעד אתמול הריצו רק על מדף שרתים ששווה יותר מדירה - ומכניס אותו ללפטופ עם 25 ג'יגה זיכרון רגיל, בלי שום כרטיס מסך." ככה הייתי מסכם את הדבר הכי מטורף שראיתי השבוע. כשקראתי את זה בפעם הראשונה חשבתי שמישהו התבלבל במספרים. אבל מסתבר שזה עובד, והסיפור האמיתי כאן הוא לא כמה מהר זה רץ, אלא למה זה בכלל אפשרי.

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

הקיר שכולם קיבלו כגזירה משמיים

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

בואו נעשה את החשבון. ל-GLM-5.2 יש 744 מיליארד פרמטרים. יש דרך חסכונית לאחסן אותם שנקראת int4 (קוונטיזציה - שמירת כל מספר בארבעה ביט במקום שישה-עשר, בערך כמו לכתוב 'כ-20 שקל' במקום '19.87'). גם בשיטה החסכונית הזו כל פרמטר שוקל חצי בייט, אז המודל כולו שוקל בערך 370 ג'יגה. ללפטופ טיפוסי יש בין 16 ל-32 ג'יגה. זה כמו לנסות למזוג 370 ליטר לתוך דלי של 30 ליטר: זה לא עניין של כסף, אלא של מקום פיזי.

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

למה קיצורי הדרך הרגילים לא באמת עוזרים

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

וכאן שווה להיות הוגנים עם המבקרים. אחת התגובות שקיבלתי היתה: "זה סתם מודל מקוונטט שנותן לך תשובה אחרי יום". חצי מהמשפט נכון, וחשוב לדייק. Colibri לא מחליף את המודל בגרסה מטומטמת יותר. הוא מריץ את GLM-5.2 האמיתי והמלא ב-int4, בדיוק אותם משקלים שרצים במרכזי הנתונים הגדולים. int4 היא שיטה מקובלת שכמעט לא פוגעת באיכות במודלים גדולים, אז האיכות שאנחנו מקבלים היא של המודל האמיתי, לא של צל מזוקק שלו. הבעיה הקשה ש-Colibri פותר היא לא איכות, אלא איך דוחפים 370 ג'יגה לתוך 25.

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

הנה החלק היפה, ובואו נפרק אותו לשלושה מהלכים.

מהלך ראשון - MoE. GLM-5.2 בנוי כ'תערובת מומחים' (Mixture of Experts): במקום רשת אחת ענקית שכולה עובדת בכל רגע, יש בכל שכבה 256 'מומחים' קטנים, ורכיב זעיר שנקרא נתב (router) בוחר לכל טוקן רק כשמונה מהם. התוצאה: מתוך 744 מיליארד פרמטרים, רק כ-40 מיליארד באמת פעילים בכל טוקן, בערך חמישה אחוזים. תחשבו על זה כמו בית חולים עם 256 רופאים מומחים: כל חולה פוגש רק שמונה מהם, ואין שום סיבה שכל 256 יעמדו יחד בחדר אחד.

מהלך שני - מפצלים את הזיכרון לשתי קומות. את החלק שהמודל צריך בכל טוקן בלי יוצא מן הכלל - מנגנון תשומת הלב ושכבות הבסיס, בערך 17 מיליארד פרמטרים ששוקלים כ-9.9 ג'יגה ב-int4 - Colibri משאיר קבוע ב-RAM. את 21,504 המומחים (75 שכבות כפול 256 מומחים, בערך 19 מגה כל אחד) הוא משאיר על ה-SSD, הכונן המהיר.

מהלך שלישי - זורמים לפי דרישה. בכל טוקן, הליבה הקבועה שב-RAM מבצעת את החישוב, הנתב מכריז 'לטוקן הזה אני צריך את מומחים 7, 40 ו-131', ו-Colibri קורא מהכונן רק את החתיכות האלה, מריץ אותן, וזורק. מטמון חכם (LRU cache - שומר את מה שהשתמשנו בו לאחרונה) מחזיק את המומחים הנפוצים חמים ב-RAM. תחשבו על זה כמו ספרייה: אנחנו לא צריכים להביא הביתה את כל הבניין כדי לקרוא עמוד אחד, אלא שולפים בדיוק את הספר שצריך, ברגע שצריך אותו.

וכל זה, שימו לב, בקובץ C יחיד בן כ-2,400 שורות, בלי שום תלות חיצונית. בלי פייתון בזמן ריצה, בלי ספריות מתמטיקה חיצוניות (BLAS), בלי CUDA, בלי כרטיס מסך. יש שם גם כמה טריקים הנדסיים יפים: מנגנון תשומת לב דחוס (MLA) ששומר 576 מספרים לכל טוקן במקום 32,768, ומנגנון ניחוש מקדים (MTP) שמפיק 2.2 עד 2.8 טוקנים בכל מעבר של המודל, במקום טוקן בודד.

בואו נעקוב אחרי טוקן אחד מקצה לקצה, כדי שהתמונה תתחבר. הפרומפט נכנס. הליבה הקבועה שב-RAM (9.9 ג'יגה) מחשבת את תשומת הלב. הנתב בוחר כשמונה מומחים בכל אחת מ-75 השכבות, בערך 600 מומחים לטוקן בודד. Colibri קורא אותם מהכונן, כ-11 ג'יגה של קריאות דיסק, ומייצר בדיוק את אותו טוקן שמדף ה-H100 היה מייצר. ואז הכל חוזר על עצמו לטוקן הבא. אותה תשובה בדיוק, רק בכתובת אחרת: לפטופ במקום חמישה כרטיסי H100.

// שתי קומות זיכרון: הליבה קבועה ב-RAM, המומחים זורמים מהדיסק.
Weights   dense = load_int4("dense.bin");   // ~9.9 GB - lives in RAM, always
ExpertLRU cache = lru_new(RAM_BUDGET);     // hot experts kept warm in RAM

for (int t = 0; ; t++) {                   // one iteration = one token
    hidden = attention(dense, kv_cache);   // MLA: 576 floats/token, not 32768

    for (int layer = 0; layer < 75; layer++) {
        int picks[8] = router(hidden, layer);         // MoE: pick ~8 of 256
        for (int i = 0; i < 8; i++) {
            Expert e = cache_get(cache, layer, picks[i]);
            if (!e) e = read_from_ssd(layer, picks[i]); // ~19 MB, on demand
            hidden = apply_expert(hidden, e);
        }
    }
    int tok = sample(hidden);
    emit(tok);              // ~11 GB of disk reads bought exactly one token
    if (tok == EOS) break;
}

אבל כמה זה איטי, באמת?

עכשיו החלק ההוגן, עם מספרים. במצב 'קר', לפני שהמטמון מתחמם, על מחשב פיתוח רגיל זה רץ בכ-0.05 עד 0.1 טוקן לשנייה. על מכונות עם יותר זיכרון זה עולה: מקבוק M5 Max עם 128 ג'יגה מגיע ל-1.06 טוקן לשנייה, ומחשבי Ryzen ו-Framework שולחניים נעים בין 0.28 ל-0.40. בואו נעשה את החשבון בכנות: ב-0.5 טוקן לשנייה, תשובה באורך 500 מילים לוקחת בערך 17 דקות.

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

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

מה זה אומר על מחר

והחומרה רצה בדיוק לכיוון הזה. NVIDIA השיקה את DGX Spark, ו-AMD את Ryzen AI Halo, שניהם עם 128 ג'יגה זיכרון מאוחד סביב 4,000 דולר - בדיוק המשתנה שהגרף שלמעלה הכי רגיש אליו. AMD אפילו רמזה כבר על גרסה עם 192 ג'יגה למודלים של 300 מיליארד פרמטרים ומעלה. הטריק ש-Colibri הוכיח על מכונה של 25 ג'יגה נעשה הרבה יותר טוב על המכונות שיוצאות השנה.

וצריך לומר בכנות גם איפה GLM-5.2 עומד. הוא מודל חזית אמיתי: במבחן הקוד FrontierSWE מפריד בינו לבין המלך, Claude Opus 4.8, פחות מנקודה אחת (0.7). במבחן SWE-bench Pro הוא מקבל 62.1 מול 69.2 של אופוס, פער של כשבע נקודות. הוא לא עוקף את אופוס, אבל הוא נושם לו בעורף, וכל זה במשקלים פתוחים.

בעיניי

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

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

שורה תחתונה: היום זה 'איטי אבל אפשרי', ומחר החומרה כבר נושמת 128 ג'יגה. אז השאלה שנשארת איתי: כמה זמן באמת נותר עד שמודל חזית שלם ירוץ אצלנו בבית, פרטי לגמרי, בלי לבקש רשות מאף אחד? ואתם - הייתם מחכים 15 דקות לתשובה, אם היא רצה על המכונה שלכם ולא עוזבת אותה לרגע?