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

אילו מודלי AI ניתן לארח באופן עצמי על שרת VPS?

גלו אילו מודלי AI ירוצו על השרת שלכם לפי כמות ה-RAM הזמינה. המדריך כולל חישובי נפח עבור 4 GB, 16 GB ו-64 GB, נתוני ביצועים אמיתיים ועלויות ה-context הנסתרות.

מה קובע אילו מודלי AI ניתן לארח באופן עצמי

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

שתי עלויות קובעות את התשובה. ה-weights הם העלות הקבועה, הנקבעת לפי מספר ה-parameter וה-quantisation. ה-context window הוא העלות השוטפת, וזהו המשתנה שאנשים שוכחים עד שמודל שנטען אתמול מסרב להיטען היום.

חישוב גודל המודל: סיביות לכל פרמטר

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

weights in GB = (parameters in billions x bits per weight) / 8

רוב המודלים משוחררים ב-16 סיביות, מה שמתרגם ל-2 GB לכל מיליארד פרמטרים. חלק מהמודלים משוחררים כשהם כבר מקוונטזים חלקית: לדוגמה, gpt-oss של OpenAI עבר אימון נוסף (post-trained) כאשר משקולות ה-mixture of experts שלו הן בפורמט 4 bit MXFP4. כך או כך, כמעט אף אחד לא מריץ משקולות של 16 סיביות על שרת VPS. אלו הן רמות הקוונטיזציה שתפגשו בפועל, עם ממוצע הסיביות האמיתי לכל משקולת:

  • Q8_0 מאחסן כ-8.5 סיביות לכל משקולת, כלומר בערך 1.1 GB לכל מיליארד פרמטרים.
  • Q6_K מאחסן כ-6.6 סיביות, כלומר בערך 0.83 GB לכל מיליארד.
  • Q5_K_M מאחסן כ-5.7 סיביות, כלומר בערך 0.71 GB לכל מיליארד.
  • Q4_K_M מאחסן כ-4.8 סיביות, כלומר בערך 0.6 GB לכל מיליארד.

השתמשו ב-0.6 GB לכל מיליארד פרמטרים כמספר העבודה שלכם. Q4_K_M הוא ברירת המחדל ההגיונית בשרת המוגבל בזיכרון: אובדן האיכות בהשוואה ל-8 סיביות הוא קטן ברוב המשימות, והקובץ קטן כמעט בחצי. מתחת ל-4 סיביות האובדן גדל במהירות, לכן מודל 70B שנדחס ל-2 סיביות בדרך כלל יספק תשובות פחות טובות ממודל 32B ב-4 סיביות מאותו דור. כאשר הזיכרון מצומצם, עדיף להקטין את גודל המודל לפני שיורדים מתחת ל-4 סיביות.

תרשיםRAM at 4-bit: weights and KV cache, calculated
הנתונים שמאחורי התרשים
[
  {
    "label": "3B",
    "weights_gb": 1.8,
    "kv_8k_gb": 0.9,
    "kv_128k_gb": 14
  },
  {
    "label": "8B",
    "weights_gb": 4.8,
    "kv_8k_gb": 1,
    "kv_128k_gb": 16
  },
  {
    "label": "14B",
    "weights_gb": 8.4,
    "kv_8k_gb": 1.5,
    "kv_128k_gb": 24
  },
  {
    "label": "32B",
    "weights_gb": 19.2,
    "kv_8k_gb": 2,
    "kv_128k_gb": 32
  },
  {
    "label": "70B",
    "weights_gb": 42,
    "kv_8k_gb": 2.5,
    "kv_128k_gb": 40
  }
]

עמודת המשקולות לעיל מבוססת על כלל ה-0.6 GB למיליארד. קובצי GGUF אמיתיים נמצאים בטווח של אחוזים בודדים מחישוב זה, כיוון ששכבות ה-embedding וה-output נשמרות בדיוק גבוה יותר משאר המודל. מודל 3B ב-4 סיביות הוא בערך 1.8 GB. מודל 8B הוא 4.8 GB. מודל 32B הוא 19.2 GB, ומודל 70B הוא 42 GB.

מדוע אורך ההקשר (context length) צורך יותר זיכרון RAM מאשר המשקולות

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

נוסחת ה-KV cache, והיכן למצוא את הנתונים
bytes per token = 2 x layers x kv_heads x head_dim x bytes per element

הספרה 2 מייצגת את המפתח ואת הערך. הערכים עבור layers, kv_heads (מופיעים כ-num_key_value_heads) ו-head_dim נמצאים כולם ב-config.json בדף כרטיס המודל. מספר הבתים לכל אלמנט הוא 2 עבור מטמון של 16-bit. מודל 8B טיפוסי כולל 32 שכבות, 8 ראשי key value ומימד ראש של 128, לכן 2 x 32 x 8 x 128 x 2 = 131072 בתים, שהם 128 KiB לכל אסימון.

באורך ההקשר המוגדר כברירת מחדל ב-Ollama, מודל 8B צורך חצי ג'יגה-בייט עבור המטמון. ב-8192 אסימונים הוא צורך 1 GB. באורך הקשר של 128k, כפי שמפורסם בכרטיס המודל שלו, הוא צורך 16 GB, שזה יותר מפי שלושה ממשקל המודל עצמו. במודל 70B המצב הפוך: המטמון שלו ב-128k הוא 40 GB, פחות ממשקל המודל עצמו, כיוון ש-grouped query attention מונע מהעלות לכל אסימון לגדול באותו קצב של כמות הפרמטרים.

אורך ההקשר המוגדר כברירת מחדל ב-Ollama הוא 4096 אסימונים בשרת מבוסס CPU בלבד. כאשר קיים GPU, המערכת בוחרת את ברירת המחדל מתוך ה-VRAM: 32k עבור זיכרון שבין 24 ל-48 GiB, ו-256k עבור 48 GiB ומעלה. ניתן להגדיל ערך זה באמצעות המשתנה OLLAMA_CONTEXT_LENGTH בשרת, ולאחר מכן לבדוק מה קיבל המודל בפועל בעמודה CONTEXT בתוך ollama ps. החישובים המתמטיים של הזיכרון מאחורי הגדרה זו מפורטים ב-פוסט על num_ctx ואורך הקשר.

קיימות שתי דרכים לצמצם את צריכת הזיכרון של המטמון. בקש את אורך ההקשר הדרוש לך במקום את האורך המפורסם בכרטיס המודל, שכן רוב עבודות הצ'אט והתכנות נכנסות בטווח של 8k עד 32k. לחלופין, בצע קוונטיזציה (quantisation) למטמון עצמו ל-8-bit, מה שיחצה את צריכתו, במחיר מסוים של ירידה בדיוק השליפה בהקשרים ארוכים.

מודל תושב שומר על ה-RAM עד שגורם כלשהו מפנה אותו

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

ollama ps
ollama stop qwen3:4b

ollama ps מציג את המודלים השוכנים בזיכרון, כאשר עמודה SIZE מציגה כמה זיכרון תופס המודל, ועמודה UNTIL מציגה מתי הוא יפוג. כדי להצמיד מודל לצמיתות, הגדירו את OLLAMA_KEEP_ALIVE=-1 בשירות. ערך של 0 יפנה את המודל מיד עם סיום כל תגובה.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_KEEP_ALIVE=-1"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
sudo systemctl daemon-reload
sudo systemctl restart ollama

שלחו הנחיה (prompt) אחת, ולאחר מכן הריצו את ollama ps שוב כעבור עשר דקות. המודל עדיין מופיע ברשימה, וזו בדיוק המטרה: הוא תופס את ה-RAM ללא קשר לשאלה אם מישהו משתמש בו. מודל מוצמד אינו נחשב לקיבולת פנויה. בשרת VPS עם 16 GB, מודל 8B עם context של 8k תופס בערך 6 GB כל עוד השירות רץ, לכן יש להתאים את גודל השרת לפי המודל בתוספת היישום שלכם, ולא לפי המודל בלבד. הצמדת מודל בזיכרון סוקרת את הפשרה מול השהיית טעינה קרה (cold start latency).

מה מריץ שרת VPS עם 4 GB זיכרון

הקצו כ-1 GB עבור מערכת ההפעלה ושרת המודל, מה שמותיר כ-3 GB פנויים. נפח זה מתאים למודלים בגודל 1B עד 4B בקוונטיזציה של 4 bits, עם אורך הקשר (context) ברירת מחדל של 4096 טוקנים. נכון לאוגוסט 2026, קטגוריה זו כוללת את Llama 3.2 בגרסת 3B, את Qwen 3 בגרסאות 1.7B ו-4B, ואת המהדורות הקטנות של Gemma ו-Phi. התייחסו לשמות אלו כדוגמאות לגודל בלבד, לא כהמלצות. השמות מתחלפים מדי כמה חודשים, אך החישוב המתמטי נותר קבוע.

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

אופן הכשל ברמה זו הוא שימוש ב-swap. אם המודל אינו נכנס בזיכרון, Linux לא תסרב לטעון אותו. במקום זאת, המערכת תבצע paging לזיכרון אל הדיסק. מכיוון שיצירת טוקן בודד דורשת קריאה של כל משקולות המודל פעם אחת, מהירות היצירה תקרוס לשניות לכל טוקן. עקבו אחר free -h ואחר העמודות si ו-so ב-vmstat 1 בזמן שהמודל משיב. התעלמו מהשורה הראשונה בפלט של vmstat, המציגה ממוצע מאז האתחול, וזכרו שהמונים מכסים את כל המערכת, לא רק את המודל. ערכי swap in ו-swap out שנשארים על אפס בזמן שהשרת במצב המתנה ועולים מיד עם תחילת יצירת הטוקנים, מעידים על כך שהמודל גדול מדי עבור התוכנית שבחרתם.

מה מריצים על VPS עם 8 עד 16 GB RAM

זהו השלב שבו מודל באירוח עצמי הופך לשימושי באמת. על 8 GB ניתן להריץ מודל 7B או 8B בקוונטיזציה של 4 ביט, שזה בערך 4.8 GB של משקולות, עם context של 8k. על 16 GB ניתן להריץ מודל 13B או 14B ב-4 ביט, כ-8.4 GB, או להשאיר מודל 8B ב-8 ביט אם אתם מעדיפים להשקיע את הזיכרון בדיוק (precision) מאשר במספר הפרמטרים.

המהירות היא המכשול. מודל 8B על גבי CPU מייצר בערך 3 עד 7 טוקנים לשנייה, ומודל 14B מייצר כ-1.5 עד 3.5. קצב קריאה אנושי הוא סביב 5 עד 10 טוקנים לשנייה, כך שמודל 8B על שרת VPS מבוסס CPU מרגיש כמו צפייה בקלדן איטי. זה תקין עבור משימות רקע, אך מעייף עבור צ'אט אינטראקטיבי. הרצות מדודות של Qwen 3 בגרסת 8B ומעלה על VPS מראות כיצד זה נראה בפועל.

מה מריצים על VPS עם 32 עד 64 GB זיכרון

מודל 32B בקוונטיזציה של 4-bit תופס כ-19.2 GB, לכן הוא מתאים לתוכנית של 32 GB עם context קצר, ורץ בנוחות על 48 GB או 64 GB. מודל 70B ב-4-bit תופס כ-42 GB, בהתאם ל-43 GB שמציין Ollama עבור Llama 3.3 70B בפורמט Q4_K_M. הוא נכנס בקושי לתוכנית של 48 GB עם context קצר, וזקוק ל-64 GB עבור כל שימוש ארוך יותר.

לאחר מכן, יש לבחון את המהירות באופן ריאלי. מודל 32B על גבי CPU רץ במהירות של כ-0.6 עד 1.5 טוקנים לשנייה, ומודל 70B במהירות של 0.2 עד 0.5. תשובה של 500 טוקנים ממודל 70B תיקח כעשרים דקות. בקצב הזה, הבקשה לרוב תסתיים בשגיאה לפני שהמודל יסיים, כיוון שזמן הקצוב (timeout) של לקוח או proxy כלשהו לפני Ollama יפוג קודם לכן; זהו המקור ל-שגיאת the context deadline exceeded. אלו כלים לעיבוד אצווה (batch). הזינו להם תור של מסמכים במהלך הלילה והמהירות לא תהיה קריטית. הציבו אותם מאחורי ממשק צ'אט, והמהירות הופכת למשמעותית מאוד.

ניתוב בשיטת Mixture of Experts משנה את החישוב הזה, וזהו פרט ארכיטקטוני אחד ששווה ללמוד. מודל MoE מעביר כל טוקן דרך חלק קטן בלבד מהמשקולות שלו. מודל עם 30B פרמטרים בסך הכל ו-3B פעילים לכל טוקן דורש זיכרון של מודל 30B, אך מייצר טקסט במהירות קרובה למודל 3B דחוס, כיוון שכל טוקן קורא רק את ה-experts הפעילים. על שרת עם 32 GB, מודל MoE במבנה כזה הוא שמיש הרבה יותר ממודל 30B דחוס. הכלל שיש לזכור: סך הפרמטרים קובע את צריכת הזיכרון, הפרמטרים הפעילים קובעים את המהירות.

מהי המהירות האמיתית של הסקת CPU?

יצירת טוקן בודד מחייבת קריאה של כל המשקולות הפעילות מהזיכרון פעם אחת. אין דרך לעקוף זאת, לכן מהירות היצירה ב-CPU נקבעת לפי רוחב הפס של הזיכרון ולא לפי מספר הליבות. התקרה היא תוצאה של חילוק: רוחב הפס הזמין של הזיכרון חלקי גודל המשקולות בבתים. שרת VPS שיתופי קטן מספק באופן ריאלי בין 10 ל-25 GB לשנייה לכל ה-vCPUs שלו, לכן מודל בגודל 4.8 GB יגיע למהירות מקסימלית של כ-2 עד 5 טוקנים לשנייה.

תרשיםTypical reported CPU generation speed at 4-bit on a small VPS
הנתונים שמאחורי התרשים
[
  {
    "label": "3B",
    "tokens_per_second_low": 6,
    "tokens_per_second_high": 14
  },
  {
    "label": "8B",
    "tokens_per_second_low": 3,
    "tokens_per_second_high": 7
  },
  {
    "label": "14B",
    "tokens_per_second_low": 1.5,
    "tokens_per_second_high": 3.5
  },
  {
    "label": "32B",
    "tokens_per_second_low": 0.6,
    "tokens_per_second_high": 1.5
  },
  {
    "label": "70B",
    "tokens_per_second_low": 0.2,
    "tokens_per_second_high": 0.5
  }
]

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

ollama run qwen3:4b --verbose "Write three sentences about disk latency."

הסיכום המודפס לאחר סיום התשובה מסתיים בשורה המכילה את eval rate: ... tokens/s. זהו נתון מהירות היצירה שלכם. התעלמו מההרצה הראשונה של סשן, כיוון ש-load duration באותו סיכום כולל את קריאת המשקולות מהדיסק. מדידה נכונה של טוקנים לשנייה מסביר כיצד לקבל נתון שראוי להשוואה.

שתי תוצאות מפתיעות אנשים בהקשר זה. הוספת vCPUs מפסיקה להועיל מהר מאוד, כיוון שאחרי כ-8 ליבות, הליבות הנוספות ממתינות לזיכרון במקום לבצע חישובים. ובתוכנית שיתופית, אותה פקודה תחזיר מספרים שונים משעה לשעה, וזה נובע מ-זמן גניבת CPU משכן רועש ולא ממשהו שהגדרתם לא נכון.

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

מה משתנה כשמוסיפים GPU

החישוב האריתמטי אינו משתנה, רק המאגר שעליו הוא חל. נפח ה-VRAM הוא מגבלה קשיחה, לכן חשבו מה נכנס לפני שתשכרו שרת:

  • 8 GB של VRAM מכילים מודל 7B או 8B בקוונטיזציה של 4 ביט עם הקשר (context) קצר.
  • 16 GB מכילים מודל 14B ב-4 ביט עם הקשר ממשי, או מודל 8B ב-8 ביט.
  • 24 GB מכילים מודל 32B ב-4 ביט עם הקשר קצר.
  • 48 GB מכילים מודל 70B ב-4 ביט עם הקשר צנוע; מקום להקשר ארוך ועבודה במקביל מתחיל בערך ב-80 GB.

כאשר מודל אינו נכנס בזיכרון, Ollama מפצלת אותו: חלק מהשכבות ב-GPU, והשאר ב-CPU. הפקודה ollama ps מדווחת על הפיצול בעמודה PROCESSOR, בפורמט הדומה ל-78%/22% CPU/GPU. התייחסו לכך כאזהרה ולא כתכונה. החלק שרץ על ה-CPU קובע את הקצב, כיוון שכל טוקן ממתין לשכבות הללו; לכן, מודל שרבע מהשכבות שלו נמצאות ב-CPU ירוץ במהירות הקרובה למהירות ה-CPU ולא למהירות ה-GPU. אם אתם רואים פיצול שלא התכוונתם אליו, הקטינו תחילה את אורך ההקשר. ה-cache הוא בדרך כלל הגורם שחורג מהמגבלה.

עבודה במקביל (concurrency) היא סיבה נוספת להגדלת המשאבים. המשקולות משותפות בין בקשות בו-זמנית, אך כל בקשה פעילה זקוקה ל-KV cache משלה. לכן, עשרה משתמשים בו-זמנית במודל 8B עם הקשר של 8k זקוקים לפי עשרה מ-1 GB של cache מעבר למשקולות. המדריך הגשת שירות למשתמשים במקביל ממודל באירוח עצמי מפרט היכן עובר הגבול הזה.

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

מה לא ניתן לארח באופן עצמי

קיימים שני מחסומים שונים בתחום זה, וכדאי להבין באיזה מהם נתקלתם.

המחסום הראשון הוא משקולות (weights) סגורות. מודלים מסחריים חזיתיים אינם מופצים, לכן אין קובץ שניתן להוריד, ושום שינוי בנפח ה-RAM לא ישנה זאת. ניתן לארח באופן עצמי את כל המעטפת שלהם: הממשק, שכבת השליפה (retrieval), לולאת הסוכן (agent loop) והלוגים. המודל עצמו נשאר API מרוחק. המאמר האם ניתן לארח את Claude באופן עצמי מפרט זאת במלואו.

המחסום השני הוא משקולות פתוחות שפשוט גדולות מדי. המודלים הפתוחים הגדולים ביותר מבוססים על ארכיטקטורת Mixture of Experts, עם מאות מיליארדי פרמטרים בסך הכל. אותו כלל חל עליהם: מודל של 400B פרמטרים בקוונטיזציה של 4-bit דורש כ-240 GB עבור המשקולות בלבד, עוד לפני חישוב ה-cache. מדובר בחומרה ייעודית, ועלות השכרתה החודשית גבוהה בהרבה ממה שרוב האנשים מוציאים על טוקנים של API בשנה שלמה. המאמר מה נדרש כדי לארח באופן עצמי מודל מסוג Kimi מפרט את הדרישות בפועל. אותה חלוקה מופיעה בתוך הספרייה של Ollama, שם GLM 5.2 מופיע כמודל ענן בלבד בעוד שגרסה קטנה בהרבה היא זו שניתן להוריד בפועל ל-VPS.

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

בדקו מה עומד לרשותכם לפני הבחירה

free -h
nproc
lscpu | grep 'Model name'

תכננו לפי עמודת ה-available ב-free -h, ולא לפי עמודת ה-total, כיוון ש-total כוללת זיכרון שהמערכת כבר משתמשת בו. החסירו כ-1 GB עבור מערכת ההפעלה ושרת המודלים. חלקו את היתרה ב-0.6 כדי לקבל את מספר הפרמטרים המקסימלי במיליארדים שניתן להחזיק ב-4 bits. לאחר מכן, החסירו את ה-KV cache עבור ההקשר (context) שבו אתם באמת מעוניינים. מה שנותר הוא התשובה שלכם, ובניגוד לרשימת שמות מודלים, נתון זה אינו מתיישן.

FAQ

כמה זיכרון RAM דרוש להרצת מודל 8B?

כ-4.8 GB עבור המשקולות בקוונטיזציה של 4-bit, בתוספת ה-KV cache עבור אורך ההקשר (context length) שלכם, ובתוספת כ-1 GB עבור מערכת ההפעלה ושרת המודל. בהקשר של 8192 טוקנים, ה-cache מוסיף כ-1 GB, לכן תוכנית של 8 GB תעבוד בעוד תוכנית של 4 GB לא תספיק. אם ברצונכם להשתמש במלוא ה-128k context שהמודל מצהיר עליו, ה-cache לבדו יצרוך 16 GB, ותזדקקו לתוכנית של 32 GB.

מדוע המודל איטי למרות של-VPS יש הרבה vCPUs?

מכיוון שיצירת טוקנים מוגבלת על ידי רוחב הפס של הזיכרון, ולא על ידי מספר הליבות. כל טוקן דורש שליפה של כל סט המשקולות הפעיל מה-RAM, כך שברגע שמספר ליבות מנצלות את ערוצי הזיכרון, הליבות הנותרות פשוט ממתינות. סיבה נפוצה נוספת היא swap. אם vmstat 1 מציג את si ו-so כערכים אפסיים לפני שליחת ה-prompt, אך הם עולים בזמן שהמודל משיב, סביר להניח שהמשקולות אינן נכנסות ב-RAM וחלק מכל טוקן מוגש מהדיסק, מה שגורם להאטה משמעותית.

האם חלון הקשר ארוך יותר באמת דורש יותר זיכרון?

כן, והגידול הוא ליניארי ביחס למספר הטוקנים. מודל 8B טיפוסי צורך כ-128 KiB של KV cache לכל טוקן, כך ש-8192 טוקנים עולים 1 GB ו-131072 טוקנים עולים 16 GB. ה-cache מוקצה בעת טעינת המודל ולא בזמן שהשיחה מתארכת, לכן הגדרת הקשר של 128k משריינת את הזיכרון הזה באופן מיידי, גם אם כל prompt שתשלחו יהיה באורך של 200 טוקנים בלבד.

האם כדאי להריץ מודל גדול ב-2-bit או מודל קטן יותר ב-4-bit?

בחרו במודל הקטן יותר ב-4-bit. האיכות יורדת באיטיות מ-8-bit ל-4-bit, אך צונחת במהירות מתחת ל-4-bit. לכן, מודל 70B שנדחס ל-2-bit בדרך כלל יספק תשובות פחות טובות ממודל 32B ב-4-bit מאותו דור מודלים. קוונטיזציה אגרסיבית מתבטאת בחזרתיות ובאי-ביצוע הוראות במקום בהודעת שגיאה, מה שמקשה על זיהוי הבעיה ומטעה לחשוב שהבעיה ב-prompt. התייחסו ל-4-bit כאל רף מינימלי ושנו את מספר הפרמטרים במקום זאת.

האם ניתן לארח עצמאית מודל חזק כמו המודלים המסחריים הגדולים?

לא על VPS רגיל. המודלים הפתוחים החזקים ביותר מגיעים למאות מיליארדי פרמטרים, מה שדורש ב-4-bit מעל 200 GB של RAM עוד לפני ה-KV cache, והמודלים המסחריים החזקים ביותר אינם מופצים כלל. חומרה רגילה מתאימה להרצת מודל 8B עד 32B למשימה ספציפית, שבה מודל קטן וממוקד לרוב משתווה למודל כללי. אם אתם זקוקים לאיכות ברמה הגבוהה ביותר, השוו את עלות ה-API לעלות החומרה לפני הרכישה.

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