מודל של 125B על מחשב גיימינג: שלושת הטריקים שהכניסו אותו ל-12GB

כלי הקוד הפתוח Strata מריץ מודל של 125 מיליארד פרמטרים על מחשב גיימינג רגיל, עבור כל מי שרוצה AI חזק בלי לשלוח מילה אחת לענן. על כרטיס מסך RTX 5070 עם 12GB בלבד הוא כותב 94 טוקנים בשנייה, לפי המדידות שבריפו. בתוך פחות מחודש הפרויקט אסף כמעט 28 אלף כוכבים ב-GitHub, וזה לא במקרה.

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

כדי שלא נלך לאיבוד, נלווה את כל הכתבה עם מחשב אחד: מחשב גיימינג ביתי עם כרטיס RTX 5070 של 12GB, 64GB זיכרון RAM ודיסק SSD. זה בדיוק המחשב שעליו מפתח Strata מדד את המספרים שלו, ובכל פרק נשאל את אותה שאלה: איך המודל הענק הזה נכנס אליו?

המצב: 125 מיליארד מספרים לא נכנסים ל-12GB

בואו נתחיל מהבסיס. מודל שפה הוא בעצם קובץ ענק של מספרים, שנקראים פרמטרים או משקלים (weights). כל מספר הוא כמו כפתור כוונון קטן שנקבע בזמן האימון, ויחד הם קובעים איך המודל עונה. המודל ש-Strata מריץ, Qwen3.8-Flash-Next, מכיל 125 מיליארד כפתורים כאלה, וחלון הקשר (כמות הטקסט שהמודל מחזיק בראש באותה שיחה) של 262 אלף טוקנים.

עכשיו החשבון. בפורמט המקובל לשמירת מודלים כל פרמטר תופס 2 בייטים, כלומר בערך 250GB למודל כזה. אפילו בגרסה הדחוסה החביבה Q8_0 (שמונה ביטים לכל מספר) ההורדה שוקלת 188GB, לפי טבלת הגדלים של Strata. ובמחשב שלנו? 12GB בכרטיס המסך ו-64GB ב-RAM.

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

טריק ראשון: צוות מומחים במקום מוח אחד (MoE)

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

במודל Qwen3.8-Flash-Next זה נראה ככה, לפי כרטיס המודל ב-Hugging Face: 512 מומחים בכל שכבה, ולכל טוקן מופעלים רק 10 מומחים "מנותבים" ועוד מומחה אחד משותף. רכיב קטן שנקרא נתב (router) מחליט לכל מילה אילו מומחים יטפלו בה. בסך הכל, מתוך 125 מיליארד פרמטרים, בכל טוקן עובדים רק כ-6 מיליארד. זה בערך 5% מהמודל.

הקטע המדליק הוא ש-MoE פותר את בעיית החישוב, אבל לא את בעיית האחסון. כל 512 המומחים עדיין צריכים להיות זמינים איפשהו, כי אי אפשר לדעת מראש מי יידרש למילה הבאה. וכאן Strata עושה בדיוק את מה שהוא עצמו מתאר כמטבח: המומחים הכי עסוקים יושבים על כרטיס המסך (השיש), כל המומחים יושבים ב-RAM (המזווה), המעבד הרגיל עובד במקביל על מומחים שלא נכנסו לכרטיס, וטבלת חיפוש גדולה של כ-29GB נשארת על ה-SSD (המחסן). על המחשב שלנו, כרטיס המסך מחזיק רק את מה שבאמת חם.

יש לו עוד שכבה של מהירות: מודל עוזר קטן מנחש כמה מילים קדימה, והמודל הגדול בודק את כולן במכה אחת ושומר את הנכונות. לפי ה-README זה מביא את אותה תשובה בדיוק, פי 1.6 עד 1.8 מהר יותר.

טריק שני: דחיסה עד הסוף (קוונטיזציה ומשקלים טרנריים)

גם עם חלוקה חכמה, 250GB זה הרבה יותר מ-64GB. אז דוחסים. קוונטיזציה (quantization) היא דחיסה של כל משקל למספר עם פחות ביטים, בתמורה לאובדן קטן של דיוק. תחשבו על מחירים בסופר: במקום 12.37 שקל כותבים "בערך 12". בשביל רוב ההחלטות זה מספיק, והרשימה נהיית הרבה יותר קצרה.

כשאנחנו רואים בשם של קובץ Q2 או IQ2, הכוונה בערך לשני ביטים לכל משקל, במקום 16 בפורמט המלא. הפרויקט Strata מציע כמה רמות דחיסה של אותו מודל: Q2_0 הכי מהירה ודורשת 37.6GB של RAM ו-VRAM ביחד, IQ2_XS המומלצת דורשת 39.2GB, ו-IQ3_S, הכבדה ביותר עם 54.8GB, היא לפי הפרויקט זו שמשתווה למודל המלא במבחנים שפורסמו. במחשב שלנו, עם 64GB, כל הגדלים נכנסים. במחשב עם 32GB הפרויקט ממליץ על גרסת Coder, שהשאירה רק 256 מתוך 512 המומחים שנבחרו לפי קוד, והיא חלשה יותר מחוץ לקוד ובשפות שאינן אנגלית. וזה רלוונטי לנו, כי אנחנו כותבים בעברית.

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

המודל Bonsai 2 27B של PrismML, ששוחרר ב-17 בספטמבר ברישיון Apache 2.0, הוא הדוגמה הטרייה. מודל של 27 מיליארד פרמטרים, מבוסס Qwen3.8 27B, דחוס ל-5.9GB בלבד, עם 98.2% מהביצועים של הגרסה המלאה לפי החברה. זה 1.76 ביטים בממוצע לכל משקל, יותר מפי 9 קטן מהמקור. חשוב לדעת: ה-5.9GB הם באריזה הכי דחוסה, ואילו הדמו הרשמי מוריד כברירת מחדל אריזה מהירה יותר של 7.8GB. בכל מקרה, זה נכנס בנוחות לכרטיס של 12GB.

בגרף רואים את כל הסיפור: אותו מודל של 125 מיליארד קופץ מ-188GB ל-37.6GB בדחיסה של שני ביטים, מודל MoE של 35 מיליארד יורד מ-19.5GB לפחות מ-3GiB של זיכרון פעיל בזכות הזרמה, ו-Bonsai 2 27B יושב כולו ב-5.9GB.

טריק שלישי: להזרים מומחים מה-SSD (Edge0)

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

הבעיה היא תזמון. לפי המאמר של Edge0 (arXiv, ספטמבר 2026), הזרמה נאיבית לא עוזרת, כי המומחים של השכבה הבאה נבחרים רק אחרי שהשכבה הנוכחית סיימה, ואז מחכים לדיסק. הפתרון שלהם נקרא prerouter (נתב מקדים): ראש קטן ומאומן שמנחש מראש אילו מומחים יידרשו בשכבה הבאה, ומתחיל לטעון אותם מהדיסק בזמן שהחישוב הנוכחי רץ. תחשבו על מלצר טוב שכבר מזמין את המנה הבאה מהמטבח כשאנחנו עוד באמצע הראשונה. בנוסף, מתאם LoRA קטן (שכבת תיקון זעירה שמאמנים מעל המודל) מחזיר חלק מהאיכות שהלכה לאיבוד בדחיסה ל-4 ביטים.

המספרים מרשימים: מודל MoE של 35 מיליארד פרמטרים, שבדחיסה של 4 ביטים שוקל 19.5GB, רץ לפי ה-README בכ-15 עד 18 טוקנים בשנייה על Mac mini M4 Pro עם 24GB, כשהזיכרון הפעיל המרבי עומד על 2.9GiB בלבד. הממוצע בחמישה בנצ'מרקים נמוך ב-3.9 נקודות מהמודל המלא.

וכאן חשוב לדייק, כי ברשת זה מתערבב: המנוע Edge0 לא מריץ היום את המודל של 125 מיליארד. המודלים שלו הם 35B ו-8B, ותמיכה בארכיטקטורה של משפחת Qwen3.8-Flash מופיעה ברשימת התכניות לרבעון הרביעי של 2026. גם Strata עצמו משתמש ברעיון דומה בקטן: אם ה-RAM לא מספיק, הוא קורא חלק מהמומחים מה-SSD תוך כדי, וזה איטי הרבה יותר.

מהלכה למעשה: מריצים 125B על המחשב שלנו

בואו נחזור למחשב שלנו ונתקין. לפי ה-README של Strata, מה שצריך: כרטיס NVIDIA מסדרות RTX 20 עד 50 או כרטיס AMD נתמך, עם 12GB VRAM לפחות; 32GB RAM לפחות, ו-64GB מריצים כל גודל; כ-80GB פנויים בדיסק, עדיף SSD; ו-Windows 10/11 או Linux עם דרייבר עדכני. ב-Mac עם שבב של Apple יש תמיכה ניסיונית שמקמפלת את המנוע מקוד.

התהליך עצמו קצר. ב-Windows לוחצים פעמיים על START-HERE.bat, וב-Linux מריצים ./setup.sh. המתקין מזהה את הכרטיס, שואל איזה גודל, כמה הקשר והאם לקרוא תמונות, ואפשר ללחוץ Enter לכל ההמלצות. ההורדה שוקלת כ-70GB, ובסוף הדפדפן נפתח על http://127.0.0.1:8080. הנה הגרסה ל-Linux:

# 1. get Strata (on Windows: unzip and double-click START-HERE.bat instead)
git clone https://github.com/Niko1221/Strata.git
cd Strata

# 2. install + download the model (~70GB). Press Enter for the recommended answers.
./setup.sh
# the Strata app opens at http://127.0.0.1:8080

# 3. use it from Claude Code (Anthropic-compatible endpoint)
ANTHROPIC_BASE_URL=http://127.0.0.1:8080 claude

# 4. or from any OpenAI-compatible app: base URL http://127.0.0.1:8080/v1
#    (any API key and any model name work)

שני דברים שכדאי לדעת מראש. הראשון: בהפעלה הראשונה המחשב יכול להיתקע לדקה עד שלוש, כי Strata טוען 35 עד 55GB לזיכרון. זה תקין, לא סוגרים את החלון. השני: השרת מדבר גם בשפה של OpenAI וגם בשפה של Anthropic, כך שאפשר לחבר אליו את Claude Code עם משתנה סביבה אחד, ANTHROPIC_BASE_URL, שמצביע על הכתובת המקומית. מבחינת Claude Code, הוא פשוט מדבר עם שרת אחר.

ואם המחשב שלנו חלש יותר? המודל Bonsai 2 27B הוא נקודת כניסה עדינה בהרבה. משכפלים את הריפו Bonsai-demo של PrismML, מריצים ./setup.sh ואז ./scripts/start_llama_server.sh, ומקבלים צ'אט עם תמונות וכלים על אותה כתובת מקומית. מי שעוד לא הריץ אף מודל מקומי, כדאי להתחיל מהמדריך שלנו ל-Ollama, LM Studio ו-Unsloth, ורק אז לקפוץ ל-125B.

בעיניי: מה זה כן, ומה זה עדיין לא

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

אבל בואו נהיה הוגנים לגבי המגבלות:

• "מחשב גיימינג רגיל" זה מחשב די חזק. 12GB של VRAM זה המינימום, ו-RAM של 32GB מאפשר רק את גרסת ה-Coder. כדי ליהנות מהמודל המלא צריך 48 עד 64GB.
• דחיסה של שני ביטים היא פשרה. הפרויקט עצמו מגדיר את Q2_0 כ"טוב" ואת IQ3_S כ"הכי טוב". המהירות של 94 טוקנים היא בגרסה הכי דחוסה, ובהקשר של 128 אלף טוקנים היא יורדת ל-76.
• בקשה אחת בכל פעם. כברירת מחדל Strata עונה לבקשה אחת והשאר ממתינות. זה עוזר אישי, לא שרת לצוות.
• מספרים שמסתובבים ברשת. נתקלתי בטענה על "RTX 4090 ב-100 טוקנים לשנייה". לא מצאתי מדידה כזו לא ב-README ולא בדוחות הקהילה של הפרויקט. מה שכתוב שם הוא הערכה, לא מדידה: RTX 3090 עם 24GB אמור להגיע ל-100 עד 140 טוקנים בשנייה. עד שמישהו ימדוד, אני מתייחס לזה כהערכה.
• הכל טרי. הפרויקטים Strata, Edge0 ו-Bonsai 2 כולם בני פחות מחודש וחצי. מה שנכון היום עשוי להשתנות בשבוע הבא.

שורה תחתונה: אם יש לנו מחשב גיימינג עם 12GB ו-64GB RAM, אפשר הערב להריץ עליו מודל של 125 מיליארד פרמטרים, פרטי לגמרי, ולחבר אליו את כלי הקוד שלנו. זה כבר לא ניסוי מעבדה.

אז מה המשימה הראשונה שנעביר למודל שרץ אצלנו בבית, בלי ענן בכלל?

רוצים ללכת עם זה רחוק יותר?

את כל העולם של מודלים מקומיים, מ-VRAM ועד בחירת המודל הנכון לחומרה שלנו, אני מפרק צעד אחר צעד בקורס מודלים מקומיים מקצה לקצה, בעברית, כשהמידע נשאר אצלנו. זה הבסיס שהופך את Strata ו-Bonsai ממשהו מפחיד למשהו שמתקינים בערב אחד.

ואם אנחנו כבר מחברים מודל מקומי ל-Claude Code, הקורס Claude Code Mastery מראה איך לעבוד איתו כמו שצריך.

את הניסויים בהרצה על חומרה אמיתית אני מעלה ל-YouTube ול-LinkedIn, ועדכונים קצרים ב-X, ב-Instagram וב-TikTok. הקוד שלי נמצא ב-GitHub.

ועכשיו השאלה האמיתית: כשמודל של 125 מיליארד פרמטרים רץ אצלנו בבית, אילו משימות אנחנו עדיין מוכנים לשלוח לענן, ולמה?