למה מודל LLM באירוח עצמי מואט עם ריבוי משתמשים?
השרת שלכם איטי כי Ollama מעבד בקשה אחת בלבד כברירת מחדל. למדו כיצד batching, ניהול KV cache ושימוש במנוע הגשה מתאים יאפשרו לכם לשרת יותר משתמשים בו-זמנית ללא שדרוג חומרה.
מדוע LLM באירוח עצמי מאט כאשר מצטרפים משתמשים נוספים?
כאשר LLM באירוח עצמי נתקע ב־5 משתמשים במקביל, הסיבה השכיחה היא שהשרת מוגדר ליצור תשובה אחת בכל פעם, וארבעת המשתמשים האחרים ממתינים בתור. התיעוד של Ollama מציין זאת במפורש לגבי ברירת המחדל שלו: OLLAMA_NUM_PARALLEL הוא "המספר המרבי של בקשות מקבילות שכל מודל יעבד בו־זמנית, כברירת מחדל 1." שום דבר אינו מקולקל, ותוכנת הגשת המודל יכולה לטפל בכמה בקשות במקביל. ארבעה מתוך חמשת המשתמשים שלך ממתינים לתורם משום שהגדרה קבעה זאת.
הפתרון אינו בדרך כלל שרת חזק יותר. נדרש מנוע הגשה שמעביר בקשות רבות דרך המודל באותו מעבר קדימה, וכן די זיכרון פנוי כדי להחזיק את השיחות של כל המשתמשים בזמן העיבוד. שני החלקים חשובים, אך החלק השני הוא שקובע בפועל את תקרת הביצועים שלך.
שני השלבים שכל בקשה עוברת
שלב ה-Prefill קורא את כל ה-prompt בבת אחת ובונה עבורו את ה-attention cache. כל אסימון (token) ב-prompt עובר דרך המודל במקביל, לכן ה-Prefill הוא פעולת כפל מטריצות אחת גדולה, והוא מוגבל על ידי תפוקה אריתמטית. שלב ה-Decode כותב את התשובה אסימון אחד בכל פעם. כל אסימון דורש קריאה חוזרת של מלוא משקולות המודל מהזיכרון, בעוד שהפעולה האריתמטית המבוצעת על אותו אסימון בודד היא מזערית. ה-Decode מוגבל על ידי רוחב פס של זיכרון.
אסימטריה זו היא הסיבה לכך ש-batching עובד. פעולת Decode עבור משתמש אחד קוראת, למשל, 5 GB של משקולות לכל אסימון ומשאירה את רוב היחידות האריתמטיות במצב המתנה. הוספת בקשה שנייה גורמת למנוע לקרוא את אותם 5 GB פעם אחת, ואז לחשב שני אסימונים מתוכם. המשתמש השני כמעט אינו מוסיף זמן המתנה. הגשת בקשות בזו אחר זו מבזבזת את היתרון הזה.
שני מדדים מתארים את חוויית המשתמש. TTFT (זמן לאסימון ראשון) הוא זמן ההמתנה בתור בתוספת ה-Prefill. ITL (זמן השהיה בין אסימונים) הוא המרווח בין אסימונים מוזרמים, והוא נקבע על ידי ה-Decode. שרת איטי סובל בדרך כלל מבעיה באחד מהם, והפתרונות אינם זהים. כדאי לקבוע עם איזה מהם אתם מתמודדים לפני שינוי הגדרות כלשהן, ו-מדידת זמני prefill ו-decode בנפרד היא הדרך לגלות זאת.
עיבוד אצווה סטטי גורם לכולם להמתין לתגובה האיטית ביותר
עיבוד אצווה סטטי (Static batching) הוא הגרסה הנאיבית, והוא מתקבל כאשר מקבצים בקשות באופן ידני בקוד היישום. המנוע אוסף N בקשות, מריץ אותן יחד, ומחזיק כל משבצת (slot) פנויה עד לסיום היצירה הארוכה ביותר בקבוצה.
משתמש המבקש סיכום של 1,200 אסימונים (tokens) גורם לארבע תשובות קצרות להישאר נעולות באצווה, כיוון שהאצווה אינה משחררת אף משבצת עד שהחבר האיטי ביותר בה מסיים את עבודתו.
לכך מתלווים שני מחירים. רצפים שהסתיימו ממשיכים לתפוס משבצות שאינן מחשבות דבר מועיל, ולכן התפוקה האפקטיבית יורדת ככל שאורכי הפלט משתנים – ואורכי פלט של צ'אט משתנים במידה רבה. בקשה שמגיעה צעד אחד לאחר יצירת האצווה ממתינה עד להתרוקנות האצווה כולה לפני שהיא מתחילה בשלב ה-prefill, מה שאומר שזמן ה-TTFT שלה נקבע על ידי חיבור של מישהו אחר.
Continuous batching מקבל בקשות ומפנה להן משאבים בכל token
Continuous batching מתזמן ברמה של שלב decoding יחיד. לאחר כל שלב, ה־scheduler מסיר רצפים שפלטו זה עתה את stop token שלהם, ולאחר מכן מקבל בקשות ממתינות אל החריצים הפנויים. תשובה שמסתיימת בשלב 40 משחררת את החריץ שלה בשלב 40, ולא בסוף ה־batch.
אין כאן דבר חריג. llama-server מתעד את -cb, --cont-batching כ־"whether to enable continuous batching (a.k.a dynamic batching) (default: enabled)", ומונה בין התכונות שלו "Parallel decoding with multi-user support". בנוסף, מאז שינוי שמוזג בנובמבר 2025, הוא מתחיל כברירת מחדל עם 4 חריצים (-np מוגדר כברירת מחדל ל־-1, כלומר auto). vLLM בנוי סביב הרעיון הזה. גם Ollama משרת בקשות מקביליות. ברירת המחדל פשוט מגבילה את המספר ל־1. לכן אנשים רבים מסיקים שהחומרה שלהם אינה יכולה לבצע concurrency, אף שהתצורה שלהם היא שמנעה זאת.
תוצאות שפורסמו לגבי continuous batching נמדדות בדרך כלל בכרטיסי datacenter שיש בהם גם כוח חישוב פנוי וגם עשרות ג׳יגה־בייטים עבור ה־cache. התבנית של התוצאות האלה רלוונטית גם למחשב שלכם. הגודל שלהן אינו זהה, והסיבה לכך מוסברת בסעיף הזיכרון שלהלן.
שלב ה-prefill מתחרה עם ה-decode על אותם משאבי חישוב
כאשר בקשה חדשה מגיעה בזמן שארבע תשובות נמצאות בתהליך הזרמה (streaming), ה-prompt שלה חייב לעבור prefill תחילה, ופעולת ה-prefill צורכת משאבי חישוב רבים. אם ה-scheduler מקצה ל-prefill זה צעד (step) משלו, ארבעת המשתמשים שמקבלים הזרמה לא יקבלו אף token במהלך זמן זה. ב-prompt ארוך, מדובר בהשהיה מורגשת בכל חלון פתוח. זהו ה-"גמגום" שאליו מתכוונים משתמשים כשהם אומרים שהשרת "מקרטע" בכל פעם שמישהו אחר לוחץ על שליחה.
טכניקת ה-chunked prefill מפרקת prompt ארוך לחלקים ומשלבת כל חלק באותו צעד שבו מתבצעים ה-decodes הפעילים. מדריך הכוונון של vLLM מציג את הפשרה באופן ישיר: תקציבי chunk קטנים יותר "משיגים ITL טוב יותר מכיוון שיש פחות פעולות prefill שמאטות את ה-decodes", בעוד ערכים גבוהים יותר "משיגים זמן טוב יותר עד ל-token הראשון (TTFT), כיוון שניתן לעבד יותר tokens של prefill ב-batch אחד". עליכם לבחור את חוויית המשתמש שברצונכם להגן עליה: האדם שממתין לתחילת התשובה, או האנשים שצופים בטקסט זורם.
אורך ה-prompt קובע עד כמה הדבר יפגע בביצועים. prompt של 6,000 tokens עם תשובה של 200 tokens מהווה 6,000 tokens של עבודת prefill מול 200 צעדי decode. צ'אט מבוסס שליפת מידע (RAG) ו-system prompts ארוכים דוחפים אתכם למשטר עבודה כזה, כך שה-prefill מפסיק להיות זניח והופך לגורם שמעכב את המשתמשים. טכניקת ה-prefix caching מסייעת כאשר החלק הארוך חוזר על עצמו: vLLM חושף את --enable-prefix-caching, אשר עושה שימוש חוזר ב-cache עבור prefix משותף של ה-prompt במקום לחשב אותו מחדש עבור כל בקשה.
הזיכרון שנגמר ראשון הוא מטמון ה־KV
כל token בכל שיחה פעילה משאיר וקטור key ווקטור value בכל שכבה של המודל. זהו מטמון ה־KV (מטמון key/value), והוא מאפשר ל־decode להימנע מחישוב מחדש של כל ה־prompt עבור כל token חדש. מספר ערכי המטמון לכל token נקבע לפי המבנה של המודל: 2 (אחד עבור key ואחד עבור value) כפול מספר השכבות, כפול מספר ראשי ה־key/value, כפול ממד הראש. קראו את המספרים האלה מתוך ה־config.json של המודל. הכפילו במספר הבתים לכל ערך כדי לקבל את הגודל, והגורם האחרון הוא הגדרת runtime, לא חלק מהמודל: llama-server שומר את המטמון ב־f16 (2 bytes) כברירת מחדל, ומקבל טיפוסים קטנים יותר כגון q8_0 באמצעות -ctk ו־-ctv.
חשבו זאת פעם אחת, ותקרת הקיבולת תפסיק להיות מסתורית. מודל 8B טיפוסי עם 36 שכבות, 8 ראשי key/value וממד ראש 128, ששומר את המטמון ב־16-bit, צורך 2 36 8 128 2 bytes לכל token. כלומר 147,456 bytes, שהם בערך 144 KiB. לכן שיחה אחת באורך 8,192 tokens דורשת בערך 1.2 GB של מטמון. חמש שיחות כאלה דורשות בערך 6 GB, בנוסף ל־weights, וזו התשובה המעשית לשאלה כמה משתמשים יכולים להיכנס.
Concurrency מכפיל את ה־context, והכלים מציינים זאת במפורש. ה־FAQ של Ollama: "עיבוד מקבילי של בקשות עבור מודל נתון מגדיל את גודל ה־context לפי מספר הבקשות המקבילות. לדוגמה, context בגודל 2K עם 4 בקשות מקבילות יוצר context בגודל 8K והקצאת זיכרון נוספת." דרישת ה־RAM גדלה לפי OLLAMA_NUM_PARALLEL כפול OLLAMA_CONTEXT_LENGTH. ב־llama-server, מספר ה־slots האוטומטי כברירת מחדל מריץ את כל ה־slots על מאגר KV מאוחד אחד, ולכן כל ה־-c context הוא מאגר יחיד שממנו ה־slots מקצים זיכרון. הגדירו את -np בעצמכם, והמאגר המאוחד מושבת אלא אם תעבירו גם את --kv-unified, ולכן ה־context שאתם מבקשים באמצעות -c מתחלק בין -np ה־slots, והגדלת מספר ה־slots כשלעצמה מצמצמת את הכמות שכל בקשה יכולה להכיל. קראו את ה־context לכל slot מתוך לוג האתחול, במקום להניח מהו.
vLLM מקצה זיכרון מראש. --gpu-memory-utilization (ברירת מחדל 0.92) הוא "השבר מזיכרון ה־GPU שישמש את מפעיל המודל". אלא אם תגדירו את --kv-cache-memory-bytes, vLLM מסיק את גודל מטמון ה־KV מתוך השבר הזה: כל מה שנותר מהתקציב לאחר שה־weights וזיכרון העבודה שה־engine פרופיל נלקחו בחשבון הופך למאגר KV מדופן, וכאשר המאגר הזה מתרוקן, ה־scheduler מפנה בקשה במקום להכשיל אותה:
WARNING 05-09 00:49:33 scheduler.py:1057] Sequence group 0 is preempted by PreemptionMode.RECOMPUTE mode because there is not enough KV cache space.ב־engine V1 של vLLM, מצב ה־preemption כברירת מחדל הוא RECOMPUTE, ולכן בקשה שפונתה משליכה את המטמון שלה ומבצעת prefill מחדש כאשר היא מתקבלת שוב. העבודה הזאת מתבצעת פעמיים. בתיעוד מזהירים כי "preemption וחישוב מחדש עלולים להשפיע לרעה על זמן האחזור מקצה לקצה", ושורת הלוג הזאת היא ההסבר הטוב ביותר לכך שמשתמש אחד חסר מזל המתין זמן רב בהרבה מכל האחרים, אף שהממוצע שלכם נראה תקין. הגדירו את disable_log_stats=False כדי לתעד את הספירה המצטברת, או קראו את מונה ה־preemption מתוך מדדי Prometheus ש־vLLM חושף.
מה משתנה ב-2, 5 ו-20 משתמשים בו-זמנית
שני משתמשים. העומס כמעט בלתי מורגש על GPU עם זיכרון מטמון פנוי, כיוון שזרם הפענוח השני "רוכב" על הראשון בתוספת זמן זניחה. בשרת VPS מבוסס CPU בלבד עם 4 עד 8 GB של RAM, זה לא בחינם: שני הזרמים חולקים את אותם vCPUs ואת אותו רוחב פס של ה-RAM, לכן כל משתמש מקבל בערך מחצית מקצב ה-tokens לשנייה, ודרישת ה-cache מוכפלת מול תקציב מצומצם בהרבה.
חמישה משתמשים. כאן הגדרות ברירת המחדל מפסיקות להספיק, והבעיה מתחילה כבעיית תור. כאשר OLLAMA_NUM_PARALLEL מוגדר ל-1, ארבעה אנשים ממתינים למי שביקש את התשובה הארוכה, וכל אחד מהם רואה מהירות תקינה ברגע שתורו מגיע. העלאת מספר המקביליות משנה את אופי הבעיה: חמישה חריצים עם 8K context כל אחד דורשים 40K של token cache. אם זה לא נכנס ב-VRAM, המנוע מעביר שכבות ל-RAM של המערכת, ואם זה לא נכנס ב-RAM, השרת מבצע swap וקצב ה-tokens לשנייה קורס.
עשרים משתמשים. עשרים בני אדם בממשק צ'אט הם בדרך כלל לא עשרים בקשות בו-זמנית, וזה הדבר החשוב ביותר להבין לפני רכישת חומרה. אדם קורא תשובה וחושב במשך 20 עד 60 שניות בין תור לתור, לכן רוב הסשן שלו אינו פעיל. עשרים סוכנים, או עשרים משימות סיכום מסמכים, הם עשרים זרמים אמיתיים ללא זמן המתנה כלל. זו מכונה מסוג אחר. מפתח שהפנה סוכן תכנות לשרת Ollama שלו נמצא קרוב יותר למקרה השני מאשר לראשון, כיוון שהסוכן ממשיך לשלוח בקשות כל עוד המשימה רצה ולא מותיר את הפסקות הקריאה שמאפיינות אדם.
האם המשתמשים שלכם פועלים במקביל, או רק מחוברים?
חשבו תחילה כמה בקשות יהיו פעילות לפני שתתכננו את גודל המערכת. החישוב פשוט: מספר הבקשות הפעילות שווה למספר המשתמשים כפול מספר השניות הנדרשות ליצירת פלט בכל תור, חלקי מספר השניות בין תורים.
- מדדו תחילה את המהירות בזרם יחיד אצלכם, גם ב־prefill וגם ב־decode. אל תשתמשו במספר מכרטיס של אדם אחר: מדדו tokens per second במחשב שלכם והשתמשו בתוצאה שקיבלתם.
- העריכו את מחזור הפעילות. 20 משתמשי צ'אט, 12 שניות של יצירת פלט בכל תור, ותור אחד בכל 90 שניות נותנים 20 * 12 / 90, כלומר כ־2.7 בקשות פעילות.
- הגדירו את מספר ה־slots מעט מעל הערך הזה, ולאחר מכן בדקו אותו מול הזיכרון: מספר ה־slots כפול ההקשר לכל בקשה חייב להתאים למספר אסימוני ה־cache הזמינים בפועל.
- שמרו על תור קצר, כדי שחריגה מהקיבולת תיכשל במהירות ובאופן גלוי.
מספר אסימוני ה־cache הזמינים שווה לזיכרון הפנוי לאחר טעינת ה־weights, חלקי העלות לכל אסימון המפורטת בסעיף הקודם. כרטיס בנפח 24 GB שמריץ מודל 8B ב־16-bit מקצה כ־16 GB ל־weights, ולכן נותרו לכל היותר כ־6 GB ל־cache בשימוש ברירת המחדל; לאחר שמקצים מקום לזיכרון העבודה, הכמות מעט קטנה יותר. מדובר בכ־5 שיחות באורך 8K. כדי להתאים יותר שיחות, קצרו את ההקשר לכל בקשה, או אחסנו את ה־cache ב־8-bit (llama-server לוקח --cache-type-k q8_0). שתי האפשרויות מגדילות את המקביליות באמצעות ויתור מסוים, וכדאי לקרוא את התיאור הכנה של הפשרה הזאת לפני שמתחייבים לרכישת חומרה: מתי GPU VPS משתלם יותר מאסימוני API.
מתי ברירות המחדל של Ollama אינן מספיקות
הגדילו את מספר הבקשות המקבילות דרך יחידת השירות, כיוון שפקודת export ב-shell לא תשפיע על daemon שמנוהל על ידי systemd.
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_MAX_QUEUE=64"sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=Environment
ollama pssystemctl show אמור להציג את שלושת המשתנים שהגדרתם זה עתה. אם לא, קובץ ה-drop-in לא נשמר, ושום פעולה אחרת לא תועיל. ollama ps יציג לאחר מכן את המודל הטעון עם גודל גדול יותר ממשקל המודל בלבד, כיוון שארבעה חריצים של 8,192 tokens משריינים 32,768 tokens של זיכרון מטמון (cache) לצדם. עמודת PROCESSOR המציגה חלק מהמודל על ה-CPU כאשר ציפיתם שכולו יהיה על ה-GPU, משמעותה שביקשתם יותר זיכרון מטמון ממה שנותר בכרטיס. הקטינו את אחד משני המספרים. צמצום ההקשר (context) הוא בדרך כלל הדרך הבטוחה יותר, אך חלון קטן מדי יקצץ הודעות ארוכות בשקט במקום להציג שגיאה, לכן כדאי לבצע sizing ל-num_ctx באופן מכוון במקום להקטין אותו עד שהמודל ייכנס.
ברירת המחדל של התור דורשת בחינה נוספת. Ollama מנהל תור של עד OLLAMA_MAX_QUEUE בקשות, ו"ברירת המחדל היא 512". מעבר לכך, הוא משיב "בשגיאת 503 המציינת שהשרת עמוס". תור באורך 512 על שרת שמשרת ארבע בקשות במקביל הוא הבטחה שלא ניתן לקיים, כיוון שהלקוח שנמצא במיקום ה-300 יחווה timeout הרבה לפני שיגיע תורו. תור קצר מחזיר שגיאה שהיישום שלכם יכול לנסות שוב או לדווח עליה, וזה עדיף על חיווי טעינה שלעולם לא מסתיים.
בצעו בדיקה אמיתית. שלחו שתי בקשות בו-זמנית משני טרמינלים ועקבו אחר שתיהן. אם הבקשה השנייה לא מפיקה דבר עד שהראשונה מסתיימת, הגדרת המקביליות לא נכנסה לתוקף.
מתי מנוע serving אמיתי מתחיל להצדיק את העלות
vLLM מצדיק את הגדרת היתר כאשר יש לכם GPU עם משאבי חישוב וזיכרון פנויים, ויותר מארבע בקשות בערך שנמצאות בפועל בעיבוד במקביל. מנגנון התזמון שלו פועל ברמת ה־token, המטמון שלו מחולק לדפים כדי שאפשר יהיה להשתמש מחדש במקטעים פנויים, והוא ממיר VRAM פנוי לריבוי בקשות במקביל במקום להשאיר אותו ללא שימוש. נכון לאוקטובר 2026, ההתקנה וההפעלה המתועדות עבור GPU כוללות שלוש פקודות. vllm download-kernels מורידה kernels מקומפלים מראש, ש־vLLM הייתה מורידה ומקומפלת אחרת בעת האתחול:
uv pip install vllm --torch-backend=auto
vllm download-kernels
vllm serve Qwen/Qwen2.5-1.5B-Instructcurl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "Qwen/Qwen2.5-1.5B-Instruct",
"messages": [{"role": "user", "content": "Say hello."}]
}'תשובה שמכילה מערך choices פירושה שהשרת פעיל והמודל נטען. תחת עומס, שני הפרמטרים החשובים הם --max-num-seqs, "המספר המרבי של sequences לעיבוד באיטרציה יחידה", ו־--max-num-batched-tokens, "המספר המרבי של tokens שאפשר לעבד באיטרציה יחידה". הראשון מגביל את המקביליות. השני מגדיר את תקציב ה־prefill בחלקים שתואר קודם.
כאשר יש פחות מכארבע בקשות בעיבוד במקביל, vLLM מוסיפה מורכבות ומספקת תועלת מועטה. GPU כבר אינו חובה: נכון לאוקטובר 2026, מדריך ההתקנה ל־CPU מתעד "הסקת מודלים בסיסית ו־serving" במעבדי x86 ו־Arm, עם wheels מוכנים מראש עבור x86 מאז גרסה 0.17.0 ועם תמונת Docker ל־CPU. עם זאת, הרגלי צריכת הזיכרון שלה נשמרים. ב־CPU היא מחילה את אותו שיעור ניצול של 0.92 על זיכרון המערכת, ומקצה ל־KV cache את מה שהמשקלים משאירים. לכן כברירת מחדל היא תופסת את רוב זיכרון המכונה בעת האתחול, אלא אם מגבילים את המטמון באמצעות --kv-cache-memory-bytes. זהו יחס עלות־תועלת שגוי ב־VPS עם 4 עד 8 GB. במקרה כזה, הפתרון הוא מודל קטן יותר עם הקשר קצר יותר ותור שבשליטתכם. ההבדלים בין Ollama לבין vLLM כמנועי serving מסביר את הבחירה במלואה, ו־הרצת Qwen 3 8B ב־VPS מציג את הדרישות של מודל בגודל בינוני לפני שמוסיפים אפילו משתמש נוסף אחד.
הפשרה שהפולקלור מסתיר
Continuous batching מעלה את ה-throughput הכולל, ובדרך כלל משפר גם את ה-median latency, כיוון שבקשה שנמצאת בתור מתחילה מוקדם יותר. ה-tail latency משתנה לכיוון ההפוך, וחצי זה של התמונה מוזכר לעיתים רחוקות.
כל sequence נוסף ב-step מוסיף מעט עבודה, לכן ה-ITL עולה עבור כולם ככל שה-batch מתמלא. ה-prefill של בקשה חדשה שתופס חלק מ-step היה מוקצה אחרת למשתמשי ה-streaming. תחת לחץ על ה-cache, ה-scheduler מבצע preemption, מה ששולח בקשה שנוצרה בחלקה חזרה לתחילת ה-prefill שלה.
ממשק צ'אט מציג זנבות (tails), לא ממוצעים. stream שנעצר לשתי שניות באמצע משפט נתפס כמשובש, גם כאשר הזמן הכולל לסיום הוא טוב. מדדו p95 TTFT ו-p95 ITL תחת העומס הצפוי, והתייחסו ל-mean tokens per second כמדד לקיבולת ולא כתיאור של חוויית המשתמש.
ההגדרה המעשית נגזרת מכך. הגבילו את ה-concurrency מעט מתחת למה שהזיכרון מאפשר, כדי שה-engine לעולם לא יצטרך לבצע preemption. תור קצר וצפוי עדיף על batch עמוק שגורם ל-thrashing, כיוון שמשתמש שממתין ארבע שניות ואז מקבל stream חלק, מרוצה יותר ממשתמש שמתחיל מיידית ונתקע פעמיים.
מה לבדוק כשהביצועים איטיים
כל משתמש מתנהל כרגיל, אך זמן ההמתנה ארוך. מדובר בתור, לא בבעיית מהירות. בדקו תחילה את הגדרת המקביליות. המודל מגיש בקשות בצורה תקינה, אחת בכל פעם.
שגיאת HTTP 503 מ-Ollama. התור מלא. ייתכן שהשרת הגיע לקיבולת המקסימלית שלו, או שהערך OLLAMA_MAX_QUEUE הוגדר נמוך בכוונה כדי להפחית עומס, שזו התנהגות רצויה במקרה כזה.
קצב ה-tokens לשנייה צונח תחת עומס בשרת מבוסס CPU. הריצו את vmstat 1 בזמן שהעומס מתרחש. ערכים שאינם אפס בעמודות si ו-so מעידים על כך שהמכונה מבצעת swapping, כלומר משקולות המודל נקראות מהדיסק עבור כל token. שום שינוי בתצורה לא יפתור זאת. הקטינו את גודל המודל או את מספר ה-slots.
משתמש אחד מתוך עשרה ממתין זמן רב משמעותית מהאחרים. חפשו בלוג של vLLM את preempted. הסיבה השכיחה לכך היא preemption וחישוב מחדש (recompute), מה שמעיד על כך שה-cache עמוס מעבר ליכולתו עבור אורך ה-context שאתם מאפשרים.
זמן ה-TTFT גרוע גם כשהשרת אינו עמוס. מדובר ב-prefill, לא ב-concurrency. פרומפטים ארוכים דורשים זמן עיבוד ממשי לפני הופעת ה-token הראשון; לכן, בדקו את גודל הפרומפט ואת ה-prefix caching לפני שאתם בוחנים את החומרה. אם ההמתנה הארוכה מתרחשת רק עבור המשתמש הראשון לאחר תקופת שקט, וכל המשתמשים שאחריו מקבלים מענה תקין, אין מדובר ב-prefill, אלא ב-Ollama שפורק את המודל מהזיכרון וקורא את המשקולות מהדיסק מחדש. כדאי לשלול אפשרות זו על ידי שמירת המודל בזיכרון בין בקשות.
FAQ
מדוע מודל LLM באירוח עצמי נעשה איטי יותר כאשר אדם נוסף משתמש בו?
ברוב המקרים הוא אינו נעשה איטי יותר. הבקשה נכנסת לתור. Ollama מגיע עם OLLAMA_NUM_PARALLEL בערך 1, ולכן הבקשה השנייה ממתינה עד שהראשונה תפיק את ה־token האחרון שלה. כדי להבחין בין שני המצבים, מדדו את זרם הפלט של משתמש אחד בזמן שמשתמש אחר ממתין: אם קצב ה־tokens לשנייה תקין לאחר שהזרם מתחיל, מדובר בתור, והגדלת מספר הבקשות המקבילות תפתור את הבעיה. אם שני הזרמים פועלים בחצי מהמהירות, אתם אכן חולקים את רוחב הפס של הזיכרון, וזוהי מגבלת חומרה.
כמה משתמשים מקבילים יכול GPU קטן אחד לשרת?
ספרו את הזיכרון, לא את המשתמשים. תחילה יש להביא בחשבון את ה־weights, ולאחר מכן את מטמון ה־KV, שעלות האחסון שלו היא 2 כפול מספר השכבות כפול מספר ראשי ה־key/value כפול ממד הראש כפול מספר הבתים, לכל token ולכל שיחה פעילה. מודל טיפוסי בגודל 8B, עם 36 שכבות, 8 ראשי key/value וממד ראש 128, צורך כ־144 KiB לכל token ב־16-bit. לכן שיחה באורך 8,192 tokens דורשת בערך 1.2 GB. כרטיס בנפח 24 GB שמחזיק את המודל הזה ב־16-bit משאיר לכל היותר כ־6 GB למטמון, כלומר מקום לכחמש שיחות בהקשר מלא, או ליותר שיחות אם מקצרים את ההקשר.
האם continuous batching הופך את התשובה לכל משתמש לאיטית יותר?
זמן ההשהיה החציוני בדרך כלל משתפר, משום שהבקשות מפסיקות להמתין עד לסיום של אצווה שלמה. זמן ההשהיה בזנב נעשה גרוע יותר. כל sequence נוסף מוסיף עבודה לכל שלב decoding, ה־prefill של בקשה חדשה גוזל חלק משלב מהמשתמשים שמקבלים זרם, ובקשה שנעצרה זמנית צריכה לבצע prefill פעמיים. מדדו את זמן ההשהיה p95 בין tokens, ולא את הממוצע, משום שבחלון צ'אט ההפסקות בולטות באופן שהממוצעים מסתירים.
האם כדאי להגדיל את OLLAMA_NUM_PARALLEL או לעבור ל־vLLM?
תחילה הגדילו את מספר הבקשות המקבילות. הפעולה אינה עולה דבר ודורשת קובץ drop-in אחד, והיא פותרת את המקרה הנפוץ שבו ארבעה אנשים ממתינים מאחורי תשובה ארוכה אחת. הזיכרון הוא המגבלה: בקשות מקבילות מגדילות את ההקשר שעליכם להחזיק, לכן שימו לב לשכבות שגולשות ל־CPU. עברו ל־vLLM כאשר יש לכם GPU עם VRAM פנוי ויותר מארבע בקשות פעילות באמת, משום שבשלב זה paged cache ותזמון לכל token מספקים תועלת גדולה יותר מעלותם.
האם מספר גדול יותר של ליבות CPU יפתור שרת LLM איטי?
לא בחלק שהמשתמשים מרגישים בעיקר. Decode קורא את המודל כולו מהזיכרון עבור כל token, ולכן הוא מוגבל על ידי רוחב הפס של ה־RAM. ליבות נוספות מפסיקות לעזור כאשר רוחב הפס רווי. Prefill כן נהנה ממספר גדול יותר של ליבות, ולכן הוא מקצר את הזמן עד ל־token הראשון בפרומפטים ארוכים. ב־VPS עם 4 עד 8 GB, המגבלה העיקרית היא בדרך כלל קיבולת הזיכרון, והפתרון היעיל הוא לרוב מודל קטן יותר או הקשר קצר יותר, ולא יותר vCPUs.