SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-10-30

הרצת Qwen 3.8 27B על שרת VPS עם Ollama: מדריך ביצועים

למדו כיצד להריץ את qwen3.8:27b על שרת ללא GPU. המאמר מפרט את דרישות ה-RAM המדויקות, את מגבלות המהירות בטוקנים לשנייה ואת הגרסה הנדרשת ב-Ollama להפעלת המודל.

האם ניתן להריץ את Qwen 3.8 27B על שרת VPS ללא GPU?

כדי להריץ את Qwen 3.8 27B על שרת VPS, עליכם להשתמש בתג qwen3.8:27b. נכון ל-21 באוקטובר 2026, ספריית Ollama כוללת אותו כתג שניתן למשוך מקומית: 27.3 מיליארד פרמטרים, קוונטיזציה מסוג Q4_K_M, רישיון Apache 2.0, חלון הקשר (context window) של 256K, והורדה של 18 GB הכוללת מקרן חזותי (vision projector) של כ-0.9 GB. התמיכה ב-Qwen 3.8 27B נוספה ל-Ollama בגרסה v0.32.12, ששוחררה ב-14 באוגוסט 2026, לכן התקנה ישנה יותר דורשת שדרוג תחילה. נכון ל-29 באוקטובר 2026, הגרסה היציבה האחרונה היא v0.40.13, שפורסמה ב-28 באוקטובר 2026.

התשובה הקצרה היא כן, על שרת VPS עם 32 GB RAM ומעלה, אך הביצועים יהיו איטיים. מודל צפוף (dense) של 27B בקוונטיזציה Q4 דורש כ-17 GB של RAM עבור המשקולות בלבד, עוד לפני שנשמר טוקן הקשר אחד. נתון זה פוסל לחלוטין תוכניות של 8 GB ו-16 GB. בשרת VPS טיפוסי עם DDR4 דו-ערוצי, התקרה היא בערך 3 טוקנים לשנייה, מהירות איטית מקצב הקריאה של רוב האנשים.

התגים המוקדמים יותר של 27B עדיין זמינים בספרייה: qwen3.6:27b ו-qwen3.5:27b הם שניהם מבני Q4_K_M בגודל דומה. המודל Qwen3.8-27B שומר על הארכיטקטורה של Qwen3.6-27B, וקובצי התצורה הרשמיים של שניהם מציגים את אותו מבנה שכבות, לכן חישובי הזיכרון להלן תקפים לשניהם. בדקו את הרשימה העדכנית לפני העתקת פקודה כלשהי ב-דף התג qwen3.8 של Ollama. החישוב כאן תלוי במספר הפרמטרים, בביטים לכל משקולת ובמבנה ה-attention, ולא במספר הגרסה.

איזה תג (tag) של Ollama למשוך, וכיצד לבדוק זאת

משיכת תג שאינו קיים מניבה שגיאה ברורה, לכן קל להכריע בנושא ישירות על השרת. תג שקיים עשוי עדיין להיות בלתי ניתן להרצה מקומית, וזהו המכשול שנתקלים בו עם GLM 5.2, שמופיע בספרייה אך מוגש רק מהענן של Ollama.

ollama --version
ollama pull qwen3.8:27b
ollama show qwen3.8:27b

ollama show מדפיס את הארכיטקטורה, מספר הפרמטרים, אורך ההקשר (context length) והקוונטיזציה (quantisation) עבור התג שברשותך בפועל. אם שורת הפרמטרים מציגה 27.3B ושורת הקוונטיזציה מציגה Q4_K_M, יש בידך את הגרסה שעבורה נכתב מדריך זה. הספרייה מכילה גם את qwen3.8:27b-q8_0 ו-qwen3.8:27b-bf16 עבור אותם משקולות בדיוק ברמת דיוק גבוהה יותר, גרסאות 27b-mtp, וכן תגי 27b-nvfp4, 27b-mxfp8, 27b-mlx ו-27b-mlx-bf16 שדף התגים מסווג כ-MLX, פורמט המיועד ל-Apple Silicon ולא ל-Linux VPS. בניגוד ל-qwen3.6, הערך qwen3.8 אינו כולל תגי 35b-a3b. מודלים מסוג MoE (תערובת מומחים) אלו עדיין נמצאים תחת qwen3.6 ומתנהגים בצורה שונה מאוד על גבי CPU. פירוט נוסף על כך מופיע בהמשך.

חישוב כמות פרמטרים לפי בתים למשקל

תרשיםQwen3.8 27B weights in RAM, by quantisation
הנתונים שמאחורי התרשים
[
  {
    "label": "Q4_K_M",
    "size_gb": 17,
    "bits_per_weight": 4.98,
    "notes": "published tag qwen3.8:27b, language model file"
  },
  {
    "label": "Q5_K_M",
    "size_gb": 19.5,
    "bits_per_weight": 5.7,
    "notes": "computed, no official library tag exists"
  },
  {
    "label": "NVFP4",
    "size_gb": 18,
    "bits_per_weight": 5.27,
    "notes": "published tag 27b-nvfp4, MLX build, one file including the vision encoder"
  },
  {
    "label": "Q8_0",
    "size_gb": 29,
    "bits_per_weight": 8.5,
    "notes": "published tag 27b-q8_0, language model file"
  },
  {
    "label": "BF16",
    "size_gb": 55,
    "bits_per_weight": 16.1,
    "notes": "published tag 27b-bf16, language model file"
  }
]

הנוסחה מורכבת משורה אחת. בתים של משקולות = פרמטרים * סיביות למשקל / 8. בחישוב נקי של 4 סיביות, 27.3 מיליארד פרמטרים יהיו 13.7 GB. קובץ מודל השפה בגרסה המשווקת תחת התג Q4_K_M הוא 17 GB, מה שמתרגם בפועל ל-4.98 סיביות למשקל.

הפער הזה אינו שגיאה. פורמטים מסוג K-quant אינם שומרים כל טנזור ברוחב הנומינלי. הטנזורים שמאבדים הכי הרבה איכות תחת דחיסה מקבלים יותר סיביות. רשימת הטנזורים של Ollama עבור הקובץ המשווק qwen3.8:27b מציגה את אלו ב-Q6_K: שכבת הפלט, בערך מחצית מהטלות ה-down של ה-feed-forward, הטלות ה-V של ה-attention בכמחצית משכבות ה-full-attention, וכמחצית מהטלות ה-QKV המשולבות בשכבות ה-linear-attention. טנזורי הנורמליזציה הקטנים נשארים בדיוק מלא של 32 סיביות. הטמעת הטוקנים (token embedding), הטלות ה-Q וה-K של ה-attention, והטלות ה-gate וה-up של ה-feed-forward נשארות ב-Q4_K כמו רוב המודל. השם של הפורמט מייצג ממוצע, והממוצע נוחת קרוב ל-5. אותו אפקט מופיע בקצה השני של הסקאלה: 55 GB עבור BF16 הם 16.1 סיביות למשקל ולא 16 עגול. שם, הטמעת הטוקנים היא ב-BF16 כמו כל השאר, והעודף הקטן נובע מהמטא-דאטה של הקובץ, מטנזורי הנורמליזציה שנשמרו ב-32 סיביות, ומכך שהגודל המוצג מעוגל לגיגה-בייט הקרוב.

יש לתכנן תקציב עבור כל התג, לא רק עבור קובץ מודל השפה. כל תג GGUF של qwen3.8:27b כולל גם מקרן ויזואלי (vision projector) של כ-0.9 GB, וזו הסיבה שהתג Q4_K_M רשום כ-18 GB.

עבור Q5_K_M אין תג מפורסם בערך הספרייה הרשמי של qwen3.8, לכן השורה של 19.5 GB מחושבת לפי 5.7 סיביות למשקל המקובלות עבור פורמט זה, ולא נמדדה. Q8_0 כמעט מכפיל את Q4 ל-29 GB. בשרת מבוסס CPU בלבד, הכפלה זו עולה בפי שניים בתעבורת זיכרון לכל טוקן, ולכן היא גם בערך חוצה את כמות הטוקנים לשנייה שלכם. Q4_K_M הוא ברירת המחדל הנכונה כאן מהסיבה הזו בלבד. אם אתם מעדיפים את צד האיכות של ההחלטה הזו על פני צד הזיכרון, השוואה מעמיקה יותר בין Q4, Q8 ו-fp16 מראה היכן הפלט מתחיל להידרדר בפועל.

עלות ה-KV cache ככל שההקשר (context) גדל

המשקולות (weights) הן עלות קבועה. ה-KV cache (מטמון מפתחות וערכים, מצב ה-attention שהמודל שומר עבור כל token שהוא כבר ראה) גדל בקו ישר עם אורך ההקשר, וזהו המקום שבו רוב האנשים נתקלים במחסור ב-RAM.

תרשיםKV cache size by context length, Qwen3.8 27B
הנתונים שמאחורי התרשים
[
  {
    "label": "4k tokens",
    "kv_f16_gb": 0.25,
    "kv_q8_gb": 0.13
  },
  {
    "label": "8k tokens",
    "kv_f16_gb": 0.5,
    "kv_q8_gb": 0.25
  },
  {
    "label": "16k tokens",
    "kv_f16_gb": 1,
    "kv_q8_gb": 0.5
  },
  {
    "label": "32k tokens",
    "kv_f16_gb": 2,
    "kv_q8_gb": 1
  },
  {
    "label": "64k tokens",
    "kv_f16_gb": 4,
    "kv_q8_gb": 2
  },
  {
    "label": "128k tokens",
    "kv_f16_gb": 8,
    "kv_q8_gb": 4
  }
]

הנתונים הללו מגיעים מקובץ ה-config של המודל. Qwen3.8-27B, בדומה ל-Qwen3.6-27B, הוא מודל hybrid-attention. רק 16 מתוך 64 השכבות שלו משתמשות ב-full attention ושומרות מטמון שגדל עם כל token, ולשכבות אלו יש 4 ראשי מפתח/ערך תחת GQA (grouped-query attention) ומימד ראש של 256. 48 השכבות האחרות משתמשות ב-linear attention (Gated DeltaNet) ומחזיקות מצב בגודל קבוע, אשר לפי החישוב שלי הוא בסדר גודל של 150 MB לכל slot של שיחה, ללא קשר לאורך ההקשר. זה מסתכם ב-64 KiB לכל token ב-f16, כלומר 2 GB ב-32k tokens ו-8 GB ב-128k. אל תסתמכו על החישוב שלי במקום על המכונה שלכם. טענו את המודל וקראו את עמודת ה-SIZE ב-ollama ps, המדווחת על משקולות בתוספת מטמון ותקורות כנתון אחד.

הקשר של 256K המצוין בכרטיס המודל הוא בהישג יד בארכיטקטורה זו, אך הוא אינו בחינם. מילוי שלו ב-f16 עולה כ-16 GB של מטמון מעבר למשקולות, על מכונה שכבר השקיעה 17 GB במשקולות. Ollama לא מעניקה לכם את מלוא החלון כברירת מחדל. התיעוד של אורך ההקשר קובע את ברירת המחדל לפי ה-VRAM: 4k tokens מתחת ל-24 GiB, 32k בין 24 ל-48 GiB, ו-256k ב-48 GiB ומעלה. ל-VPS מבוסס CPU בלבד אין VRAM כלל, לכן הוא נופל לרמת ה-4k, ואתם מעלים זאת במכוון באמצעות OLLAMA_CONTEXT_LENGTH. משתנה גלובלי זה אינו הכלי היחיד, ו-הגדרת num_ctx בבקשה בודדת מאפשרת לכם לשמור על ברירת מחדל חסכונית עבור כל השאר, בעוד משימה ארוכה אחת מקבלת את החלון הגדול יותר. העלו זאת בשלבים ובדקו את ollama ps לאחר כל שינוי.

שתי הגדרות שומרות על מטמון נמוך. OLLAMA_KV_CACHE_TYPE=q8_0 מאחסן את המטמון ב-8 סיביות במקום ב-16, מה שמוריד 32k tokens מ-2 GB ל-1 GB. זה דורש flash attention, לכן הגדירו גם את OLLAMA_FLASH_ATTENTION=1, ואשרו את הירידה ב-ollama ps במקום להניח שהיא הוחלה. אם לא נגעתם בסוג המטמון לפני כן, מדריך על q8_0 מול f16 עבור ה-KV cache של Ollama מכסה את הגדרת שני המשתנים וקריאת הנתונים לפני ואחרי. OLLAMA_NUM_PARALLEL=1 חשוב באותה מידה. Ollama יכולה לשרת כמה בקשות בו-זמנית, וכל slot מקבל נתח הקשר משלו, לכן העלאת המקביליות מכפילה בשקט את המטמון שתקצבתם. ברירת המחדל הנוכחית היא כבר 1, וה-override להלן מקבע אותה שם. אם יותר מאדם אחד ישתמש במכונה זו, הכפלה זו היא המקום שבו מתחילות הבעיות, ו-מספר המשתמשים בו-זמנית שמודל באירוח עצמי יכול לשרת נקבע על ידי slots של מטמון ועומק תור הרבה לפני שהוא נקבע על ידי מספר הליבות.

מה נכנס ב-8, 16, 32 ו-64 GB של RAM

תרשיםUsable context by VPS RAM tier, f16 cache, headless Linux
הנתונים שמאחורי התרשים
[
  {
    "label": "8 GB",
    "q4_max_ctx_ktok": 0,
    "q8_max_ctx_ktok": 0,
    "notes": "Weights alone exceed the box. Use a 4b or 8b model."
  },
  {
    "label": "16 GB",
    "q4_max_ctx_ktok": 0,
    "q8_max_ctx_ktok": 0,
    "notes": "17 GB of weights does not fit in 16 GB of RAM."
  },
  {
    "label": "32 GB",
    "q4_max_ctx_ktok": 128,
    "q8_max_ctx_ktok": null,
    "notes": "Q4 fits with room for long context. Q8 weights fit, but usable context needs a measured total memory budget."
  },
  {
    "label": "64 GB",
    "q4_max_ctx_ktok": 256,
    "q8_max_ctx_ktok": 256,
    "notes": "Both fit with the full 256K window."
  }
]

התייחסו לשני המספרים כאל אלפי טוקנים של הקשר (context) שנכנסים לצד המשקולות ומקרן הראייה (vision projector), בפורמט f16 cache, על שרת Linux VPS ללא ממשק גרפי עם כ-1.5 GB פנויים עבור מערכת ההפעלה ומרווח ביטחון קטן מעל. אפס משמעו שהמשקולות עצמן אינן נכנסות, ולכן דבר אינו נכנס; null משמעו שהמשקולות נכנסות אך לא אושר נתון הקשר שמיש עבור שכבה זו.

8 GB ו-16 GB אינם גבוליים. 17 GB של משקולות לא נכנסים ל-16 GB של RAM, ושום הגדרת הקשר לא תשנה זאת. הוספת swap לא תציל את המצב. Ollama מבצעת מיפוי זיכרון (memory-map) לקובץ ה-GGUF, כך שברגע שדפי הזיכרון הפעילים חורגים מה-RAM, ה-kernel מתחיל לפנות אותם ולקרוא אותם מחדש, וכל טוקן גורר קריאה של גיגה-בייטים מהדיסק. השרת יסבול מ-iowait גבוה ויפיק הרבה פחות מטוקן אחד לשנייה.

32 GB הם נקודת הכניסה. המשקולות תופסות 17 GB, מקרן הראייה מוסיף כ-0.9 GB, ונותרים לכם בערך 12.5 GB פנויים, המכסים כ-128k טוקנים של הקשר f16 עם מרווח ביטחון. משקולות Q8_0 בנפח 29 GB נכנסות ב-32 GB, אך הקשר שמיש תלוי גם במקרן הראייה, ב-cache, במערכת ההפעלה ובזיכרון ה-runtime. בדקו את טביעת הרגל הכוללת בשרת שלכם לפני שתחליטו ש-Q8 הוא בר-הרצה בשכבה זו.

64 GB הם נפח נוח. Q4 מותיר מקום לחלון המלא של 256k, ומשקולות Q8_0 נכנסות יחד עם מלוא ה-256k מאחוריהן. לפני שמשלמים על 64 GB כדי לקבל Q8, היו ברורים לגבי מה שאתם קונים: פלט מעט טוב יותר בחצי מהמהירות, על מכונה שהייתה איטית ממילא. Q4 כבר מגיע ל-128k טוקנים בתוכנית של 32 GB, וזהו האיזון העדיף עבור כמעט כולם.

מהי מהירות ה-inference של מעבד (CPU) ב-VPS?

יצירת טוקן אחד ממודל צפוף (dense model) מחייבת קריאה של כל המשקולות מהזיכרון פעם אחת. לא חלק מהן, אלא את כולן. לכן, מגבלת המהירות אינה מספר הליבות שלכם, אלא רוחב הפס של הזיכרון חלקי גודל המשקולות. בקוונטיזציה של Q4, מדובר ב-17 GB של תעבורת זיכרון לכל טוקן.

תרשיםTheoretical token ceiling from memory bandwidth, 17 GB of weights
הנתונים שמאחורי התרשים
[
  {
    "label": "DDR4-2666, 2 channel",
    "mem_bandwidth_gb_s": 42.6,
    "ceiling_tok_s": 2.5
  },
  {
    "label": "DDR4-3200, 2 channel",
    "mem_bandwidth_gb_s": 51.2,
    "ceiling_tok_s": 3
  },
  {
    "label": "DDR5-4800, 2 channel",
    "mem_bandwidth_gb_s": 76.8,
    "ceiling_tok_s": 4.5
  },
  {
    "label": "DDR4-3200, 8 channel",
    "mem_bandwidth_gb_s": 204.8,
    "ceiling_tok_s": 12
  },
  {
    "label": "DDR5-4800, 12 channel",
    "mem_bandwidth_gb_s": 460.8,
    "ceiling_tok_s": 27.1
  }
]

אלו הם תקרות תיאורטיות, לא מדידות בפועל. הפלט האמיתי מגיע בערך ל-50 עד 70 אחוז מהנתון המוצג, כיוון שזמן השהיה (latency) של הזיכרון ו-prefetching לא מושלם מונעים הגעה לשיא התיאורטי. שרת VPS עם ערוץ כפול של DDR4-3200 הוא בעל תקרה של 3 טוקנים לשנייה, לכן צפו לערך של כ-2. שרת עם ערוץ כפול של DDR5-4800 הוא בעל תקרה של 4.5, לכן צפו לערך של כ-3.

שרתים גדולים מגיעים עם אזהרה. פלטפורמת EPYC עם 12 ערוצים מספקת 460.8 GB/s ותקרה של 27.1 טוקנים לשנייה, אך אתם לא שוכרים שרת EPYC שלם. רוחב פס של זיכרון הוא משאב שרת שמשותף לכל הדיירים על אותה מכונה, לכן פרוסת 8 vCPU לא מקבלת 12 ערוצים של רוחב פס בלעדי. מדריכים המתמקדים ב-GPU מתעלמים מכך לחלוטין, וזו הסיבה ששתי תוכניות VPS עם מספר vCPU זהה יכולות להציג הבדל של פי שלושה בביצועים על אותו מודל.

יותר vCPUs מפסיקים להועיל בשלב מוקדם מאותה סיבה. ברגע שהליבות מבקשות נתונים מהר יותר ממה שבקר הזיכרון מסוגל לספק, תהליכונים (threads) נוספים רק מוסיפים תקורה של ניהול משימות ולא מעבר לכך. ל-Ollama אין משתנה סביבה כלל-שרתי עבור מספר התהליכונים, לכן הגדירו את num_thread בבקשה options למספר הליבות הפיזיות שלכם, בצעו מדידה, ולאחר מכן נסו חצי מהמספר הזה. בתוכניות שיתופיות רבות, ההגדרה הנמוכה יותר מהירה יותר.

עיבוד ה-prompt מתנהג אחרת. שלב ה-prefill, המעבר על הקלט שלכם לפני הופעת הטוקן הראשון, מוגבל על ידי כוח חישוב (compute bound) ולא על ידי רוחב פס, לכן הוא כן משתפר עם הוספת ליבות. ההשפעה המעשית היא השהיה ארוכה לפני שהפלט מתחיל ב-prompt גדול, ולאחריה קצב איטי וקבוע כמו שצוין לעיל. מדדו את שני החלקים בנפרד בעזרת --verbose, שמדפיס prompt eval rate ו-eval rate עבור כל בקשה.

אם מודל 27B הצפוף פשוט איטי מדי, בדקו את התגיות qwen3.6:35b-a3b לפני שאתם מוותרים על ה-CPU. הן מפעילות בערך 3 מיליארד פרמטרים לכל טוקן במקום את כל 27.3 המיליארדים, כך שתעבורת הזיכרון לכל טוקן יורדת בסדר גודל שלם, למרות שהקובץ על הדיסק גדול יותר. אתם מקריבים נפח RAM לטובת מהירות. גם לבחירת ה-runtime יש משמעות כאן, ו-Ollama ו-llama.cpp חושפים בקרות כוונון CPU שונות עבור אותו קוד inference בסיסי.

מתי כדאי לשכור זמן GPU

תרשיםGPU memory bandwidth and token ceiling on the same 17 GB of weights
הנתונים שמאחורי התרשים
[
  {
    "label": "L40S, 48 GB",
    "mem_bandwidth_gb_s": 864,
    "ceiling_tok_s": 51
  },
  {
    "label": "RTX 4090, 24 GB",
    "mem_bandwidth_gb_s": 1008,
    "ceiling_tok_s": 59
  },
  {
    "label": "A100, 80 GB",
    "mem_bandwidth_gb_s": 2039,
    "ceiling_tok_s": 120
  },
  {
    "label": "H100 SXM, 80 GB",
    "mem_bandwidth_gb_s": 3350,
    "ceiling_tok_s": 197
  }
]

אותה נוסחה המיושמת על רוחב הפס של זיכרון ה-GPU מניבה קטגוריה שונה של תשובות. כרטיס צרכני עם 24 GB מוגבל ל-59 טוקנים לשנייה עבור משקלים אלו. כרטיס מרכז נתונים (data centre) מודרני מגיע ל-197. זהו פער שלא ניתן לגשר עליו באמצעות כוונון מספר ה-threads. הכרטיס מריץ את הזיכרון שלו במהירות של 1008 GB/s, בעוד ה-VPS שלכם פועל במהירות של עשרות בודדות.

לכן, קבעו את הגבול לפי עומס העבודה ולא לפי העדפה אישית. הסקה (inference) על גבי CPU היא הפתרון הנכון כאשר העבודה היא אסינכרונית ואף אחד לא ממתין לתוצאות: סיכום לילי של ערימת מסמכים, או משימת סיווג לילית שרצה בזמן שאתם ישנים. שכרו GPU ברגע שאדם ממתין לפלט, או ברגע שבקשות מגיעות מהר יותר מכפי שהשרת שלכם מסוגל לסיים אותן. סביבות הרצה של CPU אינן מוגבלות לבקשה אחת בכל פעם: התיעוד של שרת llama.cpp מפרט פענוח מקבילי ו-continuous batching גם ב-CPU וגם ב-GPU, וגם Ollama מסוגל לשרת בקשות במקביל, במחיר של צריכת זיכרון cache גבוהה יותר. מה שקובע הוא קצב השירות הנמדד שלכם מול קצב הגעת הבקשות, לכן בצעו מדידת זמן ל-batch ריאלי על השרת שלכם. ברגע שבקשות מגיעות מהר יותר מהקצב הזה, התור ילך ויגדל.

השוואת העלויות פחות מובנת מאליה מכפי שהיא נראית. VPS עם 64 GB מחויב בכל שעה בחודש, בין אם המודל טעון ובין אם לא, בעוד השכרת GPU לפי שעה מפרידה בין עלויות החישוב לבין עלויות האחסון, שיכולות להימשך גם לאחר הפסקת החישוב. אם השימוש האמיתי שלכם הוא שעתיים ביום, ה-GPU השכור יכול להיות גם מהיר יותר וגם זול יותר. חשבו תחילה את מחזור העבודה (duty cycle) שלכם, ורק אז תמחרו אותו. בחירת VPS עם GPU מכסה את מה שצריך לבדוק במופע (instance) עצמו, ו-vLLM עוקף את Ollama ברגע שמשרתים בקשות במקביל על GPU מכיוון שהוא מבצע batching בצורה יעילה יותר.

קיימת אפשרות שלישית שאנשים נוטים לשכוח. השאירו את המודל של 27B על ה-CPU עבור עבודות batch, והשתמשו במודל API מאוחסן עבור המסלול האינטראקטיבי. שום דבר לא מחייב מודל אחד לשרת את שני הצרכים.

התקנת Ollama ומדידת ביצועי השרת שלכם

סקריפט ההתקנה הוא הסקריפט הרשמי, והוא מגדיר שירות systemd שרץ כמשתמש ייעודי ollama.

curl -fsSL https://ollama.com/install.sh | sh
ollama --version
free -g

ollama --version אמור להדפיס 0.32.12 או גרסה מאוחרת יותר, שהיא הגרסה הראשונה עם תמיכה ב-Qwen 3.8 27B. בדקו את free -g לפני שאתם מושכים משהו. הפקודה מדווחת ב-GiB, לכן תוכנית שמשווקת עם 32 GB של RAM עשויה להציג כ-29 בעמודת total; השוו את הזיכרון הזמין למשקולות ולתקציב ה-cache שלעיל.

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

sudo systemctl edit ollama
[Service]
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_NUM_PARALLEL=1"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_KEEP_ALIVE=60m"
sudo systemctl restart ollama
ollama pull qwen3.8:27b
ollama run qwen3.8:27b --verbose "Name two Linux distributions."

הפלט של --verbose הוא המדידה שלשמה הגעתם. eval rate הוא כמות ה-tokens לשנייה שלכם במהלך יצירת הטקסט. prompt eval rate הוא מהירות ה-prefill שלכם. load duration הוא הזמן שלקח לקרוא את המשקולות מהדיסק, וזו הסיבה ש-OLLAMA_KEEP_ALIVE=60m מוגדר: ב-CPU, טעינה מחדש של 17 GB מהדיסק בכל בקשה עולה יותר מהבקשה עצמה. זמן ההמתנה המוגדר כברירת מחדל הוא חמש דקות, קצר מספיק כדי שתור עיבוד עם מרווחים בין פריטים ישלם את עלות הטעינה הזו שוב ושוב, והקישור ל-אפשרויות להשארת מודל בזיכרון מכסה גם את השדה keep_alive לכל בקשה וגם את שמירת ההגדרה לאחר reboot.

בזמן שהמודל טעון, בדקו את טביעת הרגל של הזיכרון מטרמינל שני.

ollama ps

עמודת SIZE היא טביעת הרגל האמיתית בזיכרון כולל ה-KV cache, והיא אמורה להיות קרובה למשקולות בתוספת ה-vision projector בתוספת השורה עבור אורך ההקשר (context length) שלכם בטבלת ה-KV. ב-8192 tokens עם cache של 8-bit, החלק הגדל של ה-cache הוא רק כרבע ג'יגה-בייט, לעומת 0.5 GB אם הוא היה נשאר ב-f16, עם מצב ה-linear-attention הקבוע מעל. עמודת PROCESSOR צריכה להציג 100% CPU. אם היא מציגה משהו אחר, משהו תפס GPU והמספרים במדריך זה אינם מתארים את השרת שלכם.

מצבי כשל והודעות השגיאה המדויקות

המודל מסרב להיטען. Ollama מדפיס שורה המציינת את שני הערכים, במבנה model requires more system memory (18.6 GiB) than is available (15.2 GiB). זהו כשל תקין, כיוון ש-Ollama ביצע בדיקה לפני הקצאת הזיכרון במקום לתת ל-kernel לטפל בכך. יש להקטין את אורך ה-context, לעבור ל-tag קטן יותר, או לשדרג לתוכנית בעלת משאבים גדולים יותר.

התהליך נעלם באמצע יצירת תשובה. הלקוח אינו מציג מידע מועיל, ו-journalctl -u ollama -n 50 מראה שהשירות מבצע אתחול מחדש. הרצו את dmesg -T | tail; שורה המכילה את Out of memory: Killed process ... (ollama) מעידה על כך ש-OOM killer של ה-kernel סיים את התהליך. מצב זה קורה כאשר בדיקת הטעינה המוקדמת עברה בהצלחה, אך ה-cache גדל מעבר להערכה במהלך שיחה ארוכה. יש לקצר את אורך ה-context.

פעולת ה-pull נכשלת מיד. Error: pull model manifest: file does not exist מציין שה-tag אינו קיים ב-library. מספר גרסה שטרם שוחרר יפיק שגיאה זו, וכך גם כל שגיאת הקלדה ב-tag. qwen3.8:27b עצמו הוא תקין, לכן אם ה-tag הספציפי הזה נכשל, חפשו תחילה שגיאת הקלדה. אשרו את ה-tag בדף ה-library לפני שאתם מאשימים את הרשת, ואם tag תקין יורד אך אינו מופעל, בדקו את ollama --version מול גרסה 0.32.12.

הכל עובד אך הביצועים איטיים בצורה בלתי נסבלת. קצב של פחות מ-token אחד לשנייה במכונה עם מספיק RAM מצביע על paging ולא על בעיית כוח עיבוד. הרצו את vmstat 1 בזמן יצירת התוכן. עמודת si או so שאינה אפס מעידה על כך שה-kernel מבצע swapping, והפתרון הוא פחות context או פחות מודלים טעונים. ערך wa גבוה וקבוע ללא פעילות swap מעיד על כך שמשקולות (weights) הממופות לזיכרון נקראות שוב ושוב מהדיסק, מה שאומר שהן אינן נכנסות בפועל בזיכרון.

ה-token הראשון לוקח 30 שניות ולאחר מכן המהירות עולה. זהו שלב ה-prefill, וזהו מצב תקין. עלות של system prompt ארוך משולמת בכל בקשה שאינה נמצאת ב-cache, לכן קצרו את ה-system prompt לפני שתבצעו כוונון של כל פרמטר אחר.

למה באמת מתאים מודל 27B שרץ על CPU בלבד

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

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

כדי לבצע benchmark לכל אלו, אתם זקוקים לקלט מובנה אמיתי, ורוב ממשקי ה-API הציבוריים דורשים חשבון עוד לפני שניתן למדוד throughput. סכימת ההדגמה של Strasmore (שאותה אנו מריצים) מתעדת SQL לקריאה בלבד על נתוני מניות ואופציות בארה"ב ללא צורך במפתח או הרשמה, תוך שימוש בשמות טבלאות עם זיהוי מסד נתונים: https://ai.strasmore.com/api/demo/sql?sql=SELECT ticker, close FROM global_markets.delayed_stocks_minute_aggs LIMIT 5. מגבלות ההדגמה הן 500 שורות ו-20 שניות לכל קריאה, עם היסטוריה החל מ-1 בינואר 2025, מה שצורך בנוחות יותר ממה ששרת של שני טוקנים לשנייה יספיק לעבד. רשימת העמודות המלאה נמצאת ב-https://ai.strasmore.com/api/demo/schema.

אם זו ההתקנה הראשונה שלכם של Ollama, המדריך המלא להרצת Ollama על VPS מכסה את הגדרת השירות, ה-HTTP API וכללי ה-firewall שמדריך זה מניח שכבר יש לכם. אל תחשפו את פורט 11434 לאינטרנט. ה-API המקומי של Ollama אינו דורש אימות, לכן כל גורם שיגיע לפורט יוכל להשתמש במודל שלכם.

FAQ

האם קיים מודל Qwen 3.8 27B ב-Ollama?

כן. נכון ל-21 באוקטובר 2026, ספריית Ollama כוללת ערך qwen3.8, ו-qwen3.8:27b (המתויג גם כ-latest) הוא גרסת Q4_K_M בגודל 18 GB של מודל צפוף בעל 27.3 מיליארד פרמטרים, הכולל מקרן ויזואלי וחלון הקשר של 256K. המודל רץ מקומית ודורש Ollama בגרסה v0.32.12 ומעלה. התגים הישנים יותר qwen3.6:27b ו-qwen3.5:27b עדיין מופיעים ברשימה. בדקו את https://ollama.com/library/qwen3.8/tags עבור הרשימה העדכנית. תג שאינו קיים יחזיר שגיאת Error: pull model manifest: file does not exist.

כמה זיכרון RAM דרוש להרצת מודל Qwen 27B על גבי VPS?

32 GB הם המינימום המעשי עבור Q4_K_M. המשקולות תופסות 17 GB, המקרן הוויזואלי מוסיף כ-0.9 GB, מערכת ההפעלה זקוקה לכ-1.5 GB, וזיכרון ה-KV cache מוסיף בערך 1 GB לכל 16,000 טוקנים של הקשר בפורמט f16, כיוון שרק 16 מתוך 64 השכבות של המודל מחזיקות cache גדל. תוכנית של 16 GB אינה יכולה להכיל את המשקולות כלל, ושימוש ב-swap אינו עוזר כיוון שהקובץ ממופה לזיכרון (memory-mapped) וה-kernel פשוט קורא אותו מחדש מהדיסק עבור כל טוקן. 64 GB יספקו מרחב לחלון מלא של 256K, גם עם משקולות Q8_0 בגודל 29 GB.

כמה טוקנים לשנייה יספק מודל 27B על גבי CPU?

חלקו את רוחב הפס של הזיכרון בגודל המשקולות, וקחו 50 עד 70 אחוזים מהתוצאה. שרת VPS עם DDR4-3200 בעל שני ערוצים מגיע לתקרה של כ-3 טוקנים לשנייה ומספק כ-2. שרת עם DDR5-4800 בעל שני ערוצים מגיע לתקרה של כ-4.5 ומספק כ-3. פלטפורמות שרתים עם ריבוי ערוצים נראות טוב יותר על הנייר, אך רוחב הפס של הזיכרון משותף לכל הדיירים על המארח, לכן מדדו את הביצועים שלכם עם ollama run qwen3.8:27b --verbose וקראו את השורה eval rate.

האם להשתמש ב-Q4 או ב-Q8 על גבי VPS מבוסס CPU בלבד?

ברוב המוחלט של המקרים, השתמשו ב-Q4_K_M. משקולות Q8_0 הן בגודל 29 GB לעומת 17 GB, כך שהן נכנסות בתוך 32 GB, אך המקרן, ה-cache, מערכת ההפעלה וסביבת הריצה מותירים מעט מאוד מרווח פעולה; 64 GB יספקו מקום להקשר ארוך. המודל מעביר כמעט פי שניים זיכרון לכל טוקן, מה שמקצץ את כמות הטוקנים לשנייה בערך בחצי. הבדל האיכות בין Q4_K_M ל-Q8_0 במודל 27B הוא זניח עבור רוב המשימות. השקיעו את ה-RAM בהקשר ארוך יותר, שכן זה משנה את יכולות המודל ולא רק את אופן הניסוח שלו.

מתי השכרת GPU זולה יותר מ-VPS עם זיכרון RAM גדול?

כאשר מחזור העבודה שלכם נמוך או כאשר יש אדם שממתין לתוצאות. ל-GPU עם 24 GB זיכרון יש תקרה תיאורטית של כ-59 טוקנים לשנייה עבור משקולות אלו, לעומת 2 או 3 ב-VPS טיפוסי; חיוב השכרת ה-GPU לפי שעה נעצר כאשר המופע (instance) נעצר, אך אחסון קבוע עדיין עשוי לעלות כסף. VPS עם 64 GB מחויב לאורך כל החודש ללא קשר לשאלה אם המודל טעון או לא. חשבו כמה שעות ביום אתם באמת מייצרים טוקנים. נקודת האיזון תלויה בתעריפי ההשכרה, זמן הריצה ועלויות האחסון הקבוע. עבודה אצווה (batch) מתמשכת בעדיפות נמוכה היא המקום שבו ה-VPS הפעיל תמיד מנצח.

האם המאמר הזה היה מועיל?