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

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

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

ולמרות זאת הוא לא עונה על השאלה שהוא מבטיח לענות עליה. כי הוא מתמחר רק חצי מהחישוב.

מה הכרטיס קולע אליו, וזה הרבה

כרטיסי המסך נכונים. ל-RTX 5060 ול-4060 יש 8 GB; ל-5060 Ti יש 16 GB (והיא קיימת גם בגרסת 8 GB, שהכרטיס לא מזכיר); ל-4080 יש 16 GB; ל-3090 יש 24 GB; ל-5090 יש 32 GB. ל-RTX PRO 6000 Blackwell יש 96 GB בשלוש המהדורות — Workstation, Max-Q ו-Server — שנבדלות רק במעטפת ההספק. ל-DGX Spark יש 128 GB של זיכרון מאוחד.

גם השבבים של Apple. וכאן טעיתי לפני שבדקתי: חשבתי שהרשימה הפכה את ההיררכיה, כי היא נתנה 96 GB ל-M5 Ultra ו-128 GB ל-M5 Max. היא לא הפכה. ה-96 GB הם תצורת הבסיס של M5 Ultra; ה-128 GB הם התקרה של M5 Max. היררכיית התקרות האמיתית היא M5 Ultra 512 GB, M5 Max 128 GB, M5 Pro 64 GB, M5 ו-M6 32 GB — והיא נשמרת בקפדנות. הכרטיס ערבב רצפות עם תקרות, וזה מבלבל, אבל כל תא הוא תצורה שאפשר באמת לקנות.

גם ה-M6 נכון, והוא חדש עד כדי כך שכמעט פסלתי אותו: הוא הוכרז ב-25 באוגוסט 2026, יומיים לפני האימות הזה. השבב הראשון של Apple ב-2 nm, עד 32 GB של זיכרון מאוחד, רוחב פס של 170 GB/s, בכורה ב-Mac mini עם משלוח החל מ-22 בספטמבר.

כל המודלים קיימים: Gemma 4 (הדור הנוכחי של Google, שיצא באפריל, הראשון במשפחה תחת רישיון Apache 2.0), Qwen3.8-27B, Qwen3.8-Flash-Next ו-DeepSeek V4 Flash 0731. הקוונטיזציות המצוטטות קיימות במאגרים המצוינים.

הפריט היחיד ברשימה שלא קיים

ה-RTX 5080 Super מעולם לא יצאה לשוק.

ה-24 GB שהכרטיס מייחס לה היו המפרט המתוכנן, אף פעם לא זה של מוצר שנשלח. המקורות החזקים בענף — VideoCardz, TechPowerUp, Tom's Hardware — מתארים את סדרת SUPER כנדחית לזמן בלתי מוגבל, והסיבה כלכלית: מודול GDDR7 של 3 GB עולה בערך פי שלושה ממודול של 2 GB, בשוק שבו הביקוש של מרכזי הנתונים בולע את ההיצע. יש דיווח על ביטול סופי, אבל רק במקור משני חלש, ואני לא מקדם "דווח כמבוטל" ל"מבוטל".

בשביל הקורא, מה שחשוב הוא מעשי: השורה הזו ממליצה על חומרה שאי אפשר לקנות. ברמת 24 GB, מה שקיים היום הוא RTX 3090 (יד שנייה) או RTX 4090. תיקנתי את זה באיור.

הטעות שמכריעה: הכרטיס מתמחר רק את המשקלים

כאן נמצאת הבעיה האמיתית, והיא לא של חומרה ולא של שמות.

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

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

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

שלב אחרי שלב, עם שני המרכיבים

המשקלים למטה הם הגודל האמיתי של קובץ ה-GGUF שפורסם, מומר ל-GiB. ה-cache יצא מה-config.json של כל מודל, עם אצווה 1 ו-cache ב-16 סיביות.

זיכרון	המודל של הכרטיס	משקלים	+ cache 32K	+ cache בהקשר המרבי	נכנס עד
4 GB	Gemma 4 E2B QAT q4_0	3.12	3.57 ✅	4.88 ❌	32K
8 GB	Gemma 4 12B QAT q4_0	6.50	8.66 ❌	22.66 ❌	8K
16 GB	Gemma 4 12B Q8_0	11.80	13.96 ✅	27.96 ❌	32K
24 GB	Qwen3.8-27B UD-Q4_K_M	15.33	17.47 ✅	31.47 ❌	128K
32 GB	Qwen3.8-27B UD-Q6_K	20.47	22.61 ✅	36.61 ❌	128K
48 GB	Qwen3.8-27B Q8_0	27.05	29.19 ✅	43.19 ✅	256K
64 GB	Qwen3.8-27B BF16	50.91	53.05 ✅	67.05 ❌	128K
96 GB	Qwen3.8-Flash-Next UD-Q2_K_XL	73.45	74.31 ✅	79.56 ✅	256K
128 GB	Qwen3.8-Flash-Next UD-Q4_K_XL	103.68	104.54 ✅	109.79 ✅	256K
256 GB	DeepSeek V4 Flash 0731 UD-Q8_K_XL	150.75	153.44 ✅	172.25 ✅	256K

הערכים ב-GiB. "ההקשר המרבי" הוא ההקשר הגדול ביותר שמדדתי לכל מודל: 128K ב-Gemma 4 E2B, 256K בשאר.

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

השלב שנשבר: 8 GB

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

ה-Gemma 4 12B ב-q4_0 הרשמי של Google תופס 6.50 GiB של משקלים בכרטיס מסך של 8 GB. נשארים 1.5 GiB. ה-cache צורך 0.66 GiB ב-8 אלף טוקנים של הקשר — נכנס, בדוחק. ב-32 אלף טוקנים ה-cache עולה ל-2.16 GiB והסך הכול מגיע ל-8.66 GiB בכרטיס מסך של 8 GB. לא נכנס. ו-32 אלף טוקנים זה לא הקשר אקזוטי: זה קובץ קוד בינוני, או חצי שעה של שיחה.

מי שילך לפי השורה הזו יוריד 7 GB, יריץ, ימצא את זה מצוין בהודעות הראשונות ויראה את התהליך מת באמצע משימה אמיתית — בלי להבין למה. זה הסוג הגרוע ביותר של המלצה שגויה: זו שעובדת בבדיקה ונכשלת בשימוש.

ברמת 16 GB קורה דבר דומה, דיסקרטי יותר. הכרטיס מציע את Gemma 4 26B A4B ב-Q4_K_M כאפשרות "על הגבול". במדידה, הוא מעבר לגבול: 15.65 GiB של משקלים ועוד 1.35 GiB של cache ב-32K נותנים 17.00 GiB בכרטיס מסך של 16 GB.

והשלב של 4 GB סוגר רק בטקסט טהור. ה-Gemma 4 E2B הוא מולטימודלי, והמקרן (projector) שהוא נושא כדי לראות תמונה ולשמוע אודיו שוקל עוד 0.92 GiB: איתו, ה-3.57 GiB הופכים ל-4.49 GiB וכרטיס המסך של 4 GB לא מחזיק. הכרטיס ממליץ על מודל שרואה, ברמה שבה נכנס רק החלק שקורא.

ובכיוון ההפוך, הכרטיס שמרן מדי ב-96 GB: הוא ממליץ על Flash-Next ב-UD-Q2_K_XL (73.45 GiB), אבל UD-Q3_K_XL (83.81 GiB) ועוד 6.11 GiB של cache בהקשר המרבי מסתכמים ב-89.92 GiB ונכנסים בנוחות. ברמה הזו אפשר לבחור קוונטיזציה טובה יותר מהמוצעת.

ארבע מלכודות של שמות

NVFP4 שייך לאקוסיסטם אחר. הכרטיס מציג את NVFP4 לצד Q4_K_M, Q6_K ו-Q8_0, כאילו היו אפשרויות מאותו התפריט. הן לא. ה-Q* הם פורמטים של GGUF, מ-llama.cpp. NVFP4 הוא פורמט 4 סיביות של NVIDIA שרץ ב-vLLM וב-SGLang, דורש tensor cores של Blackwell ומגיע ממאגר אחר. לבחור ביניהם זה לא לבחור קוונטיזציה — זה לבחור מחסנית תוכנה אחרת.

ה-Q4_K_M וה-Q6_K של Qwen3.8-27B קיימים רק עם הקידומת UD-. במאגר של Unsloth, קובצי ה-GGUF היחידים בלי קידומת הם Q4_0, Q4_1, Q8_0 ו-BF16. מי שיחפש לפי השם שבכרטיס לא ימצא את הקובץ.

ה-"Q8" של DeepSeek הוא לא 8 סיביות לכל משקל. ל-UD-Q8_K_XL של DeepSeek V4 Flash 0731 יש 161.87 GB עבור 304 מיליארד פרמטרים — מה שנותן בערך 4.3 סיביות לכל משקל, לא 8. Unsloth עצמה כותבת בכרטיס המודל (model card) שהקובץ הזה גדול רק ב-7 GB מה-Q4. התווית מתארת את הדיוק של חלק מהטנזורים, לא את הממוצע של הקובץ.

ה-GB של ה-Hub הוא לא ה-GB של הכרטיס. גודל קובץ מתפרסם במיליארדי בייטים; זיכרון וידאו נספר בחזקות של שתיים. זה הפרש של 7%, מספיק כדי להפוך "נכנס" ל"לא נכנס" בשורות הצפופות. המרתי הכול ל-GiB בטבלה.

שלוש הסתייגויות שתקפות לכל הטבלה

השורות עם ✅ עדיין אופטימיות. משקלים ועוד cache אינם התפוסה הכוללת של התהליך: חסרים ההקשר של CUDA או Metal, האקטיבציות הביניים ומה שמערכת ההפעלה והתצוגה כבר צורכות. הוסיפו 1 עד 2 GB ועבדו עם רווחה של 10% עד 15%.

שני כרטיסים אינם כרטיס אחד גדול. "2× RTX 5090 = 64 GB" נכון אריתמטית ומטעה ארכיטקטונית. דור Blackwell הצרכני חסר NVLink: צריך לפרוס את המודל בין שני הכרטיסים, והתעבורה בין השכבות עוברת דרך ה-PCIe. זה נחשב כקיבולת מצטברת עם קנס חיבוריות, אף פעם לא כמאגר יחיד. אותו הדבר תקף לשני ה-DGX Spark של 256 GB: הקישור של 200 Gb/s ביניהם נותן בערך 25 GB/s מול 273 GB/s של הזיכרון המקומי. זיכרון מאוחד באמת, ברשימה הזו, יש רק ב-Apple Silicon וב-DGX Spark בודד.

במק, לא כל הזיכרון המאוחד שייך ל-GPU. macOS שומר חלק מהמאגר למערכת. הגבול ניתן לכוונון — במכונה הזו, sysctl iogpu.wired_limit_mb מחזיר 0, שמשמעותו "השתמש בברירת המחדל של המערכת" — אבל Apple לא מפרסמת מהי ברירת המחדל הזו. זו כנראה הסיבה שהכרטיס נותן ל-M5 Max של 128 GB קוונטיזציה קטנה יותר מאשר ל-DGX Spark של 128 GB, וההבחנה הוגנת: שני מספרים זהים לא שווים אותו דבר בפועל.

מה הייתי עושה עם זה

אם יש לך 8 GB, אל תוריד את ה-12B בציפייה לעבוד איתו. השתמש ב-Gemma 4 E4B, או קבל את ה-12B עם הקשר מוגבל ל-8K והגדר את השרת לכך במפורש, במקום לגלות את הגבול כשהתהליך ימות.

אם יש לך 24 או 32 GB, ה-Qwen3.8-27B הוא בחירה טובה — אבל תכנן את גודל ההקשר. ב-128 אלף טוקנים הוא נכנס; במקסימום של 262,144, לא. מי שצריך את ההקשר המרבי ברמה הזו חייב לקוונטז גם את ה-cache, עם --cache-type-k ו---cache-type-v ב-llama.cpp. קוונטיזציה של קובץ המשקלים לא מכווצת את ה-cache — אלה דברים נפרדים, וזה הבלבול הנפוץ ביותר שאני רואה.

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

איך לעשות את החישוב הזה מחדש

המספרים בעמוד הזה אינם של צד שלישי. המשקלים הם הגודל של הקבצים שפורסמו; ה-cache יצא מתוכנית שקוראת את ה-config.json של כל מודל ומפרידה בין השכבות ששומרות cache לאלה שלא. התוכנית שבונה את הטבלה מפורסמת יחד איתה: gerar-dataset.py.

כל שורה נושאת את המאגר שממנו יצא המשקל, והחישוב הוא חיסור — אפשר לבדוק כל תא ביד.

מקורות

Qwen3.8-27B · GGUF · NVFP4
Qwen3.8-Flash-Next · GGUF
DeepSeek V4 Flash 0731 · GGUF
Gemma 4 — ההכרזה · הערות השחרור · הדוח הטכני · GGUF QAT רשמי של ה-12B · GGUF QAT רשמי של ה-E2B
llama.cpp — סיביות לכל משקל בכל פורמט
Apple: Mac Studio (M5 Max ו-M5 Ultra) · MacBook Pro 14" (M5 Pro ו-M5 Max) · ההכרזה על M6 ועל M5 Ultra
RTX 50 SUPER נדחתה: VideoCardz · TechPowerUp · Tom's Hardware, על מחיר ה-GDDR7
החישוב של שני המרכיבים, בפירוט: איך לדעת אם מודל בינה מלאכותית רץ על המחשב שלך — ולמה · חבילה ניתנת לציטוט

אומת ב-27 באוגוסט 2026. גודלי הקבצים נקראו ב-Hugging Face Hub באותו התאריך; ה-cache חושב מתוך קובצי ה-config.json שפורסמו, ולא נמדד בזמן ריצה. היעדרה של ה-RTX 5080 Super ותצורות הזיכרון של Apple נבדקו במקורות המפורטים. מה שלא נבדק מוצהר ככזה בגוף המאמר.