השוואת קוונטיזציה ב-Ollama: q4_K_M מול q8_0 ו-fp16
איך לבחור קוונטיזציה ל-Ollama ללא ניחושים. נסביר את ההבדלים בצריכת ה-RAM בין q4_K_M, q8_0 ו-fp16, ונראה מתי באמת מורגשת ירידה באיכות התשובות של המודל המקומי שלכם.
המשמעות של קוונטיזציה ב-Ollama
קוונטיזציה ב-Ollama מאחסנת כל משקל במודל באמצעות פחות סיביות מאשר בקובץ שבו הוא אומן. תג שמסתיים ב-q4_K_M שומר על כ-4 סיביות לכל משקל, בעוד ש-fp16 שומר על 16 סיביות; לכן, גודל ההורדה הוא כשליש מהגודל המקורי, והמכונה קוראת כשליש מכמות הבתים כדי להפיק כל טוקן. המשקלים מעוגלים לרשת גסה יותר, הם אינם נמחקים, וב-4 סיביות רוב המודלים משיבים בצורה קרובה מאוד לזו שבה פעלו בדיוק מלא.
זהו כל הטרייד-אוף: טביעת רגל זיכרון קטנה בהרבה ויותר טוקנים לשנייה, במחיר של ירידה קלה בדיוק. להלן הדרך לחזות את שני הצדדים עבור מודל ספציפי על שרת ספציפי, לפני שתבזבזו עשרים דקות בהורדת קובץ שלא ייכנס בזיכרון.
אם Ollama עדיין לא רץ, התחילו ב-התקנת Ollama על שרת VPS. דף זה מניח ש-ollama ls כבר עובד.
כיצד לקרוא תגית קוונטיזציה של Ollama כמו q4_K_M
מודלים מקומיים מופצים כקבצי GGUF, הפורמט שבו משתמש llama.cpp לאחסון משקולות על הדיסק. Ollama בנוי על גבי llama.cpp, לכן תגיות ה-Ollama נושאות את שמות הקוונטיזציה של llama.cpp ללא שינוי.
המספר מייצג את רוחב הביטים המיועד. q4 אומר שרוב טנזורי המשקולות דחוסים לארבעה ביטים כל אחד. q8 אומר שמונה. fp16 אינו עובר קוונטיזציה כלל: זהו המודל בפורמט 16-bit floating point, רמת הדיוק שבה רוב המודלים מתפרסמים.
K מסמן K-quant. המשקולות מקובצות לבלוקים קטנים, וכל בלוק מאחסן קנה מידה (scale) משלו לצד הערכים הדחוסים. בלוק שכל המשקולות בו קרובות ל-0.01 מקבל קנה מידה עדין. בלוק שמכיל ערך חריג אחד גדול מקבל קנה מידה גס. קני מידה אלו לכל בלוק הם ששומרים על קובץ ארבעה ביטים שמיש, והם גם הסיבה לכך שקובץ ארבעה ביטים לעולם אינו בדיוק ארבעה ביטים למשקולת.
האות האחרונה היא התערובת (mixture). S, M ו-L קובעים כמה טנזורים יקודמו לרוחב גדול מרוחב היעד. ב-q4_K_M, הטנזורים שהכי נפגעים מעיגול מאוחסנים ברוחב גדול יותר, בעוד הרוב נשאר בארבעה ביטים. זו הסיבה ש-q4_K_M מפיק פלט טוב יותר מה-q4_0 הישן יותר, באותו גודל קובץ כמעט.
שאלו את Ollama מה קיים אצלו על הדיסק במקום לנחש לפי השם שהקלדתם:
ollama pull qwen3:8b-q4_K_M
ollama show qwen3:8b-q4_K_Mollama show מדפיס את architecture, parameters, quantization, context length ו-embedding length. השורה quantization היא האמת המוחלטת עבור מודל שהורדתם לפני חודשים ואינכם זוכרים מה בחרתם.
סיביות למשקל (Bits per weight) הן המקור לגודל הקובץ
כל הערכת גודל מתחילה ממספר אחד: כמה סיביות הפורמט מקצה לכל משקל, בממוצע על פני כל הקובץ. llama.cpp מפרסמת נתונים מדודים עבור Llama 3.1 8B בתיעוד ה-quantize שלה, והם תקפים לכל מודל צפוף בעל מבנה דומה.
הנתונים שמאחורי התרשים
[
{
"label": "F16",
"bits_per_weight": 16,
"file_gib": 14.96
},
{
"label": "Q8_0",
"bits_per_weight": 8.5,
"file_gib": 7.95
},
{
"label": "Q6_K",
"bits_per_weight": 6.56,
"file_gib": 6.14
},
{
"label": "Q5_K_M",
"bits_per_weight": 5.7,
"file_gib": 5.33
},
{
"label": "Q4_K_M",
"bits_per_weight": 4.89,
"file_gib": 4.58
},
{
"label": "Q3_K_M",
"bits_per_weight": 3.99,
"file_gib": 3.74
}
]ההפתעה בטבלה זו נמצאת בעמודה השנייה. Q4_K_M אינו ארבע סיביות למשקל. הוא מודד 4.89 סיביות, כיוון שקני המידה של הבלוקים והטנזורים המקודמים (promoted tensors) תופסים נפח אחסון ממשי. Q8_0 מודד 8.5 סיביות במקום שמונה, מאותה סיבה. השתמשו במספר המדוד והחישוב יניב תוצאה הקרובה בתוך אחוזים בודדים לגודל הקובץ האמיתי:
weight bytes = parameter count x bits per weight / 8
8.03e9 params x 4.89 bits / 8 = 4.91e9 bytes = 4.57 GiBזהו קובץ Q4_K_M בגודל 4.58 GiB, שחושב מתוך שני מספרים. זהו גם, בקירוב טוב, הזיכרון שהמשקולות תופסות לאחר הטעינה. Ollama אינה פורסת דבר בעת הטעינה: המשקולות המקודדות נשארות בזיכרון באותה צורה דחוסה, וכל בלוק מומר ברגע השימוש בו.
מה Ollama מפיצה בפועל עבור כל גודל מודל
הספרייה מפרסמת תגיות q4_K_M, q8_0 ו-fp16 עבור רוב המשפחות. כמה משפחות חדשות יותר חורגות מדפוס זה ומופיעות בספרייה כתגיות ענן בלבד ללא אפשרות משיכה (pull) בכל רוחב שהוא; זהו המחסום שבו נתקלים בעת ניסיון להריץ את GLM 5.2 על גבי VPS. אלו הם גדלי Qwen3 נכון לאוקטובר 2026, כפי שהם מופיעים ברשימת התגיות בדף המודל. כל נתון להלן מתייחס לנפח הדיסק לפני השימוש ב-RAM, ושניים או שלושה מודלים יחד ימלאו נפח אחסון של VPS קטן, לכן כדאי לדעת היכן Ollama מאחסנת את המודלים שהיא מורידה לפני שמתחילים לאסוף תגיות.
הנתונים שמאחורי התרשים
[
{
"label": "Qwen3 4B",
"q4_K_M_gb": 2.6,
"q8_0_gb": 4.4,
"fp16_gb": 8.1
},
{
"label": "Qwen3 8B",
"q4_K_M_gb": 5.2,
"q8_0_gb": 8.9,
"fp16_gb": 16
},
{
"label": "Qwen3 14B",
"q4_K_M_gb": 9.3,
"q8_0_gb": 16,
"fp16_gb": 30
},
{
"label": "Qwen3 32B",
"q4_K_M_gb": 20,
"q8_0_gb": 35,
"fp16_gb": 66
}
]לתגית ברירת המחדל יש כאן חשיבות. ollama pull qwen3:8b מורידה בדיוק את אותם 5.2 GB כמו ollama pull qwen3:8b-q4_K_M, כיוון שהתגית ללא סיומת היא גרסת ה-q4_K_M. גרסת Q4_K_M אינה פשרה שהספרייה מציעה בחוסר רצון. זוהי ברירת המחדל שבחרו המפתחים, ולכן התאמה אליה היא הצעד הראשון ההגיוני עבור כל מודל שטרם בדקתם בעצמכם. אותו שיקול מנחה את בחירת התגיות בעת הרצת Qwen 3 על גבי VPS.
היחסים נשמרים בכל שורה. מעבר מ-q4_K_M ל-q8_0 עולה כשבעים אחוז יותר ולא בדיוק פי שניים, כיוון שטנזורי ה-embedding וה-output אינם משתנים באותו אופן כמו שאר המודל. גרסת fp16 גדולה בערך פי שלושה מ-q4_K_M. מודל 32B בגרסת q4_K_M תופס 20 GB של משקולות, מה שכבר חורג ממה ששרת עם 16 GB RAM יכול להחזיק עם חלון הקשר כלשהו. למבט רחב יותר על מה מתאים לאיזו מכונה, ראו אילו מודלים ניתן לארח באופן עצמי.
מדוע ה-KV cache הוא עלות שנייה התלויה בהקשר
המשקולות הן העלות הקבועה. ה-KV cache (מטמון מפתחות וערכים) הוא העלות המשתנה. כל אסימון (token) בחלון ההקשר שומר את וקטורי המפתח והערך שלו עבור כל שכבה, לכן המטמון גדל בקו ישר בהתאם לחלון שאתם מגדירים. הוא מוקצה עבור כל החלון בעת טעינת המודל, ולא ככל שהשיחה מתמלאת; זו הסיבה שחלון ארוך צורך זיכרון גם עבור הנחיה (prompt) של מילה אחת.
KV bytes per token = 2 (key and value) x layers x kv_heads x head_dim x bytes_per_element
Qwen3 8B at f16: 2 x 36 x 8 x 128 x 2 = 147456 bytes = 144 KiB per tokenמספרי המודל הללו מגיעים מהתצורה של המודל עצמו: 36 שכבות, 8 ראשי מפתח/ערך, ומימד ראש של 128. ollama show מספק לכם את הארכיטקטורה ואת מספר הפרמטרים, וה-config.json של המודל ב-Hugging Face מספק לכם את השאר. הכפילו את העלות לכל אסימון בגודל החלון, והמטמון יפסיק להיות טעות עיגול זניחה.
הנתונים שמאחורי התרשים
[
{
"label": "4k",
"kv_cache_gb": 0.6,
"floor_ram_gb": 5.8
},
{
"label": "8k",
"kv_cache_gb": 1.21,
"floor_ram_gb": 6.4
},
{
"label": "16k",
"kv_cache_gb": 2.42,
"floor_ram_gb": 7.6
},
{
"label": "32k",
"kv_cache_gb": 4.83,
"floor_ram_gb": 10
}
]ב-4096 אסימונים, חלון ברירת המחדל ש-Ollama בוחרת כאשר יש פחות מ-24 GiB של VRAM (כולל ב-VPS מבוסס CPU בלבד), המטמון מוסיף 0.6 GB מעבר למשקולות. העלו את החלון ל-32k והמטמון לבדו יגיע ל-4.83 GB, כמעט כמו הזיכרון שתופסות המשקולות המקוונטטות (quantized), והרף התחתון עבור המודל כולו הופך ל-10 GB. אנו קוראים לזה רף תחתון מכיוון שמאגרי חישוב ומערכת ההפעלה מתווספים מעליו. קראו את הנתון האמיתי מעמודת SIZE של ollama ps לאחר טעינת המודל. ב-GPU עם 24 עד 48 GiB של VRAM חלון ברירת המחדל הוא 32k, ומ-48 GiB הוא 256k, לכן בכרטיס גדול אל תניחו שהנתון הוא 4k.
החלון מוגדר בשרת, לא לכל בקשה, כאשר מריצים את Ollama כשירות:
OLLAMA_CONTEXT_LENGTH=8192 ollama serveעבור התקנת systemd, השתמשו ב-drop-in במקום זאת:
sudo systemctl edit ollama[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"בצעו הפעלה מחדש עם sudo systemctl restart ollama, ולאחר מכן בדקו את עמודת CONTEXT של ollama ps כדי לוודא באיזה חלון המודל הרץ נטען בפועל. OLLAMA_KV_CACHE_TYPE מבצע קוונטיזציה למטמון עצמו: f16 הוא ברירת המחדל, q8_0 משתמש בכמחצית מהזיכרון של f16, ו-q4_0 ברבע. זוהי אפשרות גלובלית, לכן כל מודל בשרת ההוא מקבל את אותו הטיפול. קוונטיזציה של המטמון נכנסת לתוקף רק כאשר Flash Attention מופעל, מה ש-Ollama עושה אוטומטית היכן שה-backend תומך בכך, ו-OLLAMA_FLASH_ATTENTION=1 כופה זאת. במכונה קטנה עם חלון ארוך, חציית המטמון מפנה יותר זיכרון מכל שינוי בודד אחר. אם ברצונכם לראות את החיסכון הזה לפני שתסתמכו עליו, העברת ה-KV cache מ-f16 ל-q8_0 מפרט את ההגדרה ואת הירידה שהיא יוצרת ב-ollama ps ברגע שהמודל נטען מחדש. הגדרת num_ctx והעלות שלה מכסה את החלון עצמו בפירוט. המטמון גם מקבל גודל פעם אחת לכל חריץ בקשה בו-זמנית (concurrent request slot) ולא פעם אחת לכל שרת, לכן מתן אפשרות ל-Ollama לענות לשתי הנחיות בו-זמנית מכפיל את הנתון שחישבתם זה עתה, וזו האריתמטיקה שמאחורי בחירת מספר חריצים מקבילים ומגבלת תור.
מה מתאים לשרת VPS עם 8, 16 או 32 GB זיכרון
משקלי המודל, בתוספת ה-KV cache, בתוספת מרווח ביטחון למערכת ההפעלה ולכל תהליך אחר שרץ. מרווח ביטחון של 2 GB הוא נוח בשרת VPS קטן.
8 GB. מודל 4B בפורמט q4_K_M שוקל 2.6 GB ומשאיר מקום לחלון הקשר (context window) ארוך. מודל 8B בפורמט q4_K_M נכנס עם חלון ברירת המחדל של 4k, אך עם מעט מאוד מרווח תמרון. אל תבנו על הרצת 8B עם חלון של 32k כאן, כיוון שהרף המינימלי של 10 GB כבר חורג מיכולות השרת.
16 GB. מודל 8B בפורמט q4_K_M עם חלון של 16k או 32k רץ בנוחות. מודל 14B בפורמט q4_K_M דורש 9.3 GB עבור המשקלים ונכנס עם חלון הקשר צנוע. מודל 8B בפורמט q8_0 שוקל 8.9 GB, לכן גם הוא מתאים; השוואה בין השניים באמצעות ה-prompts שלכם היא השעה המועילה ביותר שתוכלו להקדיש לנושא זה.
32 GB. מודל 14B בפורמט q8_0 (16 GB) ומודל 32B בפורמט q4_K_M (20 GB) שניהם נטענים. גרסת ה-32B עם חלון הקשר גדול תדחוף את הזיכרון לקצה גבול היכולת, לכן עקבו אחר ollama ps במקום להניח שהכל תקין.
מה נפגע ראשון בקוונטיזציה
שגיאת קוונטיזציה אינה מתפזרת באופן אחיד על פעולות המודל. שטף הדיבור (fluency) נשמר לאורך זמן, וזו בדיוק הסיבה לכך שקל לפספס את הנזק: מודל שעבר קוונטיזציה גרועה עדיין כותב משפטים תקינים. הדיוק הוא הראשון להיפגע. שליפה מדויקת של מספר גרסה, חתימת API או תאריך. שרשראות הסקה ארוכות, שבהן שגיאה קטנה בשלב השני הופכת לתשובה שגויה בשלב השמיני. פורמטים קשיחים של פלט, שבהם סוגריים שגויים אחד גורמים לכשל בקריאת כלי (tool call).
הנקודה האחרונה היא המבחן המעשי. כאשר מודל נדרש להחזיר JSON שהקוד שלכם מנתח, נזק הקוונטיזציה מופיע כשגיאת ניתוח (parse error) ולא כפרוזה גרועה במעט, כך שתבחינו בכך באותו יום. סוכן תכנות (coding agent) הוא הגרסה המחמירה ביותר של מבחן זה, כיוון שהוא מניע את המודל דרך קריאות כלי רבות בזו אחר זו; לכן הפניית סוכן לשרת ה-Ollama שלכם תחשוף קוונטיזציה אגרסיבית מדי בתוך אחר צהריים אחד.
מתחת לארבעה ביטים, הירידה באיכות הופכת לתלולה. הסוגים q3 ושני ביטים קיימים עבור אנשים שדוחסים מודל גדול לחומרה קטנה, והם מהווים אפשרות ממשית כאשר החלופה היא אי-הרצת המודל כלל. הם מהווים ברירת מחדל גרועה. בין q4_K_M לבין q8_0 הפער קטן מספיק כדי שטבלת perplexity מפורסמת לא תכריע עבור עומס העבודה שלכם, לכן אל תנסו להכריע זאת בדרך זו. הריצו את שניהם מול שלושים מה-prompts שלכם וקראו את הפלט.
מתי כדאי להשתמש ב-q8_0 או ב-fp16 מבחינת זיכרון
משכו את q8_0 כאשר יש לכם זיכרון פנוי באמת והמשימה רגישה לשגיאות קטנות: חילוץ נתונים מובנה, קריאה לכלים (tool calling), או קוד שחייב לעבור הידור. אתם רוכשים כאן ביטוח, לא מודל חכם יותר באופן מורגש.
משכו את fp16 משתי סיבות בלבד. או שאתם מבצעים קוונטיזציה (quantization) למודל בעצמכם וזקוקים לקובץ המקור, או שאתם מודדים נקודת ייחוס כדי לדעת כמה איבדתם במעבר לגרסת 4-bit. הרצה מ-fp16 צורכת פי שלושה זיכרון בהשוואה ל-q4_K_M עבור הבדל שרוב האנשים לא יבחינו בו במבחן עיוור, ובמערכת מבוססת CPU בלבד, היא גם חותכת את קצב יצירת ה-tokens לשליש.
הכלל החזק יותר, תחת תקציב זיכרון קבוע: מודל גדול יותר ב-q4_K_M בדרך כלל עדיף על מודל קטן יותר ב-q8_0. 9.3 GB של משקולות 14B לעומת 8.9 GB של משקולות 8B דורשים כמעט את אותה כמות RAM, והמודל הגדול יותר "יודע" יותר. בדקו זאת על ה-prompts שלכם במקום להסתמך על דעה בלבד.
הסקה מבוססת CPU בלבד מוגבלת על ידי רוחב פס של זיכרון
ברוב תוכניות ה-VPS אין GPU, לכן המודל רץ בזיכרון המערכת על גבי ה-CPU של המארח. יצירת הטקסט מוגבלת במקרה זה על ידי רוחב הפס של הזיכרון, ולא על ידי יכולת חישוב אריתמטית, כיוון שהפקת token אחד דורשת קריאה של כל משקל פעם אחת. עובדה זו מציבה תקרה שאינה קשורה למספר הליבות שרכשת.
tokens per second ceiling = memory bandwidth / bytes read per token
50 GB/s / 5.2 GB = 9.6 tokens/s qwen3 8B q4_K_M
50 GB/s / 8.9 GB = 5.6 tokens/s qwen3 8B q8_0
50 GB/s / 16 GB = 3.1 tokens/s qwen3 8B fp16חמישים GB/s הוא בערך הנתון התאורטי עבור מארח עם ערוץ כפול של DDR4-3200. החלק שלך קטן יותר, כיוון ש-VPS חולק את ה-bus הזה עם כל שוכר אחר על המכונה, לכן יש להתייחס למספרים אלו כתקרה שאף אחד לא מגיע אליה. צורת הגרף היא החלק השימושי: ב-CPU, הפחתת מספר הביטים לכל משקל בחצי בערך מכפילה את קצב ה-tokens. קוונטיזציה (Quantization) היא מנוף המהירות המשמעותי ביותר הזמין במכונה ללא GPU. האם הקצב שנותר לך הוא נסבל תלוי במודל, והמאמר Nemotron 3.5 Lightning on a VPS מבצע את החישוב הזה עבור build, תג ונתוני RAM ספציפיים. החצי השני של זמן ההמתנה תלוי בכמות הטקסט שהמודל מחליט לכתוב; בקצב של עשרה tokens לשנייה, תשובה של שש מאות tokens עולה דקה שלמה, לכן הגבלת התשובה באמצעות num_predict לרוב חוסכת זמן המתנה רב יותר מאשר צעד נוסף של הפחתת דיוק.
עיבוד ה-prompt מתנהג אחרת. קריאת prompt ארוך מוגבלת על ידי כוח חישוב ולא על ידי רוחב פס, לכן ליבות נוספות עוזרות במקרה זה, בעוד שאין להן כמעט השפעה על מהירות היצירה. מכונה שקולטת prompt של 4k במהירות ואז מייצרת טקסט באיטיות מתנהגת בצורה תקינה.
אל תקבל אף חישוב כעובדה מוגמרת. מדוד tokens לשנייה על המכונה שלך עם אותו prompt בכל רמת קוונטיזציה, ותן למספרים שלך לקבוע את המסקנות.
ביצוע קוונטיזציה (Quantization) למודל באופן עצמאי
שלב זה נחוץ כאשר ביצעתם fine-tuning למודל ואין עבורו תגית זמינה בספריות. המסלול תלוי בפורמט הסופי הרצוי, כיוון ש-Ollama אינה מייצרת עוד את ה-GGUF K-quants המוצגים בטבלאות בעמוד זה.
עבור K-quant כגון q4_K_M, יש לבצע את הקוונטיזציה לפני ש-Ollama ניגשת לקובץ. Ollama אינה מבצעת קוונטיזציה למודלי GGUF במהלך הייבוא, והיא מסרבת ל---quantize על מקור מסוג GGUF. בצעו קוונטיזציה לקובץ ה-GGUF הלא-מקוונטז באמצעות llama-quantize של llama.cpp, ולאחר מכן ייבאו את הקובץ המוכן. למסלול ייבוא זה יש מכשול משלו: אי-התאמה ב-chat template שגורמת למודל להשיב בתוכן משובש, נושא שמוסבר ב-ייבוא קובץ GGUF לתוך Ollama. השורה quantization מתוך ollama show היא הדרך לוודא שהקובץ המיובא הוא אכן הגרסה שהתכוונתם להפיק.
הפקודה --quantize של Ollama פועלת רק על ייבוא של safetensors. הפנו את ה-Modelfile לספרייה המכילה את משקולות ה-safetensors הלא-מקוונטזות:
FROM /path/to/safetensors/directoryלאחר מכן בצעו build:
ollama create --quantize int4 mymodelהחל מגרסה Ollama v0.40.2 (נבדק בתאריך 2026-10-11), הפקודה --quantize מקבלת את int4, int8, nvfp4, mxfp4 ו-mxfp8, כאשר q4 ו-q8 (כמו גם fp4 ו-fp8) משמשים ככינויים (aliases) עבור int4 ו-int8. שמות GGUF כגון q4_K_M, q4_K_S, q8_0, q6_K ו-q5_K_M נדחים עם שגיאת unsupported quantize type. סוגים אלו אינם ה-GGUF K-quants המופיעים בטבלאות לעיל, לכן אין להסתמך על נתוני הביטים למשקולת וגודל הקובץ בעמוד זה כתחזית עבורם.
מה תראה כאשר משהו משתבש
הכול רץ על ה-CPU למרות שציפית ל-GPU. בדוק את העמודה PROCESSOR:
ollama psהיא מדפיסה 100% GPU, 100% CPU, או פיצול כגון 48%/52% CPU/GPU. פיצול משמעו שהמשקולות (weights) בתוספת ה-KV cache לא נכנסו ל-VRAM (זיכרון הווידאו, הזיכרון שעל כרטיס המסך), ולכן חלק מהמודל הועבר לזיכרון המערכת. המהירות צונחת אז לרמה הקרובה לזו של ה-CPU בלבד, כיוון שכל token ממתין לחצי האיטי. הקטן את חלון ההקשר (context window), בצע קוונטיזציה (quantization) ל-cache, או משוך גרסה קטנה יותר של המודל. הוספת ליבות לא תעזור.
המודל נסגר (killed) בזמן הטעינה. בדוק את ה-kernel ואת לוג השירות:
sudo dmesg -T | grep -i "out of memory"
sudo journalctl -u ollama -n 50שורה המכילה Out of memory: Killed process משמעה שהסכום הכולל של המשקולות, ה-KV cache והמאגרים (buffers) חרג מהזיכרון הזמין במכונה. בשרת VPS ללא הגדרת swap, המכונה כולה עלולה לקפוא למשך מספר שניות לפני שהשורה הזו מופיעה.
התשובות הפכו גרועות יותר למרות שלא שינית דבר. שתי גרסאות של אותו מודל יכולות להתקיים זו לצד זו ב-ollama ls תחת תגיות שונות, וסקריפט שמושך את השם ללא סיומת יצביע על מה שהספרייה מפנה אליו כעת. הרץ את ollama show מול התגית המדויקת שהלקוח שלך מבקש וקרא את השורה quantization, במקום להסתמך על השם בקובץ התצורה שלך.
FAQ
באיזו קוונטיזציה (quantization) של Ollama כדאי לבחור?
התחילו עם q4_K_M. זוהי ברירת המחדל שמספקת ספריית Ollama עבור רוב המודלים, ולכן ollama pull qwen3:8b ו-ollama pull qwen3:8b-q4_K_M יורידו את אותו הקובץ. עברו ל-q8_0 רק כאשר יש לכם זיכרון פנוי והמשימה רגישה לשגיאות קטנות, כמו קריאה לכלים (tool calling) או פלט JSON מובנה. כאשר תקציב הזיכרון מוגבל, מודל גדול יותר ב-q4_K_M בדרך כלל עדיף על מודל קטן יותר ב-q8_0; לכן, בדקו שילוב זה לפני שתקצו RAM נוסף לטובת דיוק גבוה יותר.
האם q4_K_M באמת אומר ארבעה ביטים למשקל (weight)?
לא. במדידה על Llama 3.1 8B התוצאה היא 4.89 ביטים למשקל, כיוון שכל בלוק משקלים שומר קנה מידה (scale) משלו, והטנזורים הרגישים ביותר מקודדים בטיפוס רחב יותר. Q8_0 מודד 8.5 ביטים במקום שמונה מאותה סיבה. השתמשו בנתון הנמדד לצורך הערכה: מספר הפרמטרים כפול ביטים למשקל, חלקי שמונה, ייתן את גודל הקובץ בבתים.
כמה RAM דרוש למודל 8B בשרת VPS מבוסס CPU בלבד?
יש לחשב משקלים, מטמון KV (KV cache) ומרווח ביטחון. Qwen3 8B ב-q4_K_M תופס 5.2 GB עבור המשקלים. בחלון ברירת המחדל של 4096 טוקנים, המטמון מוסיף 0.6 GB, מה שמביא את הרף התחתון לאזור ה-5.8 GB, עוד לפני חישובי buffers ומערכת ההפעלה. בחלון של 32k, המטמון לבדו תופס 4.83 GB. תכננו על 8 GB עבור חלון קצר ו-16 GB אם אתם זקוקים לחלון ארוך.
מדוע המודל רץ ב-100% CPU למרות שיש לשרת GPU?
הריצו את ollama ps וקראו את עמודת PROCESSOR. הערך 100% CPU, או פיצול כמו 48%/52% CPU/GPU, מצביעים על כך שהמשקלים בתוספת מטמון ה-KV לא נכנסו ל-VRAM, ולכן Ollama העבירה חלק מהמודל או את כולו לזיכרון המערכת. הסיבה הנפוצה לכך היא חלון הקשר (context window) גדול מכפי שהכרטיס יכול להכיל, כיוון שהמטמון מוקצה עבור כל החלון בעת טעינת המודל. הקטינו את החלון בעזרת OLLAMA_CONTEXT_LENGTH, הגדירו את OLLAMA_KV_CACHE_TYPE=q8_0 כדי לצמצם את המטמון בחצי, או הורידו קוונטיזציה קטנה יותר.