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

איך למדוד tokens per second ב-LLM מקומי בצורה מדויקת

השכרת GPU משתלמת רק מעל רף תפוקה מסוים בהשוואה לתשלום לפי API. למדו כיצד לבצע concurrency sweep כדי למדוד tokens per second אמיתיים ולקבל החלטה כלכלית מבוססת נתונים.

מדוע מספר ה-tokens לשנייה קובע אם השכרת GPU משתלמת

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

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

מדוע נתון ה־tokens per second שפורסם אינו המספר שלכם

ביולי 2026 פרסמה DigitalOcean נתוני תפוקה עבור NVIDIA H200 בודד המריץ את llama3.3-70b-instruct בפורמט FP8 (נקודה צפה של 8 סיביות) תחת vLLM. הנתונים שימושיים, אך הם אינם הנתונים שלכם.

תרשיםPublished DigitalOcean H200 figures, llama3.3-70b-instruct FP8, July 2026
הנתונים שמאחורי התרשים
[
  {
    "config": "H200, one stream",
    "tok_s": "47"
  },
  {
    "config": "H100, saturated",
    "tok_s": "236"
  },
  {
    "config": "H200, saturated",
    "tok_s": "2,036"
  },
  {
    "config": "H200, saturated, in+out",
    "tok_s": "4,071.6"
  }
]

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

נתחיל בשתי השורות האחרונות. הכותרת היא 4,071.6 tok/s, בעוד שקצב הפלט בלבד הוא 2,036 tok/s. הכותרת סופרת אסימוני קלט ופלט יחד. הבדיקה ההיא השתמשה ב-1,024 אסימוני קלט מול 1,024 אסימוני פלט, כך שכמעט בדיוק מחצית מהכותרת היא פלט. החלוקה הזו חשובה כי הפלט הוא החצי האיטי. שלב ה-Prefill (קריאת ה-prompt) מעבד את כל אסימוני הקלט במעבר אחד. שלב ה-Decode (כתיבת התשובה) מייצר אסימון אחד בכל פעם. כותרת של תפוקה כוללת עושה ממוצע בין מספר "זול" למספר "יקר".

כעת לשורה הראשונה. אותו H200 המשרת בקשה אחת בכל פעם מייצר 47 tok/s, כך שהנתון במצב רוויה גבוה פי ארבעים על גבי חומרה זהה. הפער הזה קיים מכיוון ששלב Decode בודד מותיר את ה-GPU בהמתנה לזיכרון ברוב הזמן, ובקשות במקביל ממלאות את זמן ההמתנה הזה. השורה השנייה, 236 tok/s, היא H100 בודד על אותו מודל, המוגבל על ידי ה-KV cache (זיכרון המטמון של ה-key וה-value, הזיכרון לכל בקשה ששיחה פעילה שומרת על הכרטיס). כרטיס של 80 GB מחזיק פחות בקשות במקביל עבור מודל של 70B, ולכן הוא מגיע לרוויה בערך נמוך יותר.

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

ארבעת המדדים הקריטיים

  • זמן עד לטוקן ראשון, TTFT. העיכוב בין שליחת בקשה לבין הגעת הטוקן הראשון. מדד זה מורכב מזמן ה-prefill ומזמן ההמתנה בתור. המשתמש חווה עיכוב זה באופן ישיר.
  • טוקנים בשנייה לכל stream. המהירות שבה נכתבת תשובה מרגע שהחלה הכתיבה. מעל כ-20 טוקנים לשנייה, המהירות גבוהה יותר מקצב הקריאה של רוב האנשים, ולכן שיפור נוסף כאן אינו מורגש.
  • סך תפוקת הפלט ברוויה. סכום כל ה-streams המקבילים כאשר השרת נמצא בעומס מלא. זהו מדד הקיבולת, והוא המדד שקובע את הכדאיות הכלכלית של ה-GPU.
  • ערכי p50 ו-p99 עבור TTFT תחת עומס. ה-p50 מייצג את הבקשה החציונית. ה-p99 מייצג את הערך ש-99 מתוך 100 בקשות עומדות בו. השפעת התור באה לידי ביטוי תמיד קודם כל ב-p99.

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

התאמת אורכי הקלט והפלט לפני המדידה

קצב העברת הנתונים (throughput) תלוי במבנה התעבורה. הנחיה (prompt) של 4,000 אסימונים (tokens) עם תשובה של 50 אסימונים היא עבודה עתירת prefill. הנחיה של 200 אסימונים עם תשובה של 2,000 אסימונים היא עבודה עתירת decode. אותו שרת יציג נתונים שונים מאוד של אסימונים לשנייה עבור שני המקרים הללו, לכן יש לבחור יחס אחד, לתעד אותו לצד כל מספר שאתם רושמים, ולעולם לא להשוות בין יחסים שונים. יחס של 1,024 אסימוני קלט מול 1,024 אסימוני פלט הוא ברירת מחדל סבירה, כיוון שספקים רבים מפרסמים נתונים לפי יחס זה. אם ידוע לכם אופי התעבורה האמיתי שלכם, השתמשו בו.

יש לכפות גם את אורך הפלט. מודל שמגיע לאסימון עצירה (stop token) לאחר 60 אסימונים יפיק הרצה קצרה שלא ניתן להשוותה להרצה מלאה: ה-TTFT יהפוך לחלק גדול יותר ממנה, מה שיוריד את קצב הפלט כפי שהוא נמדד ב-benchmark, אף על פי שכל בקשה מסתיימת מוקדם יותר. הדגל --ignore-eos בלקוח ה-benchmark של vLLM גורם לכל בקשה לייצר בדיוק את כמות האסימונים המבוקשת, כך ששתי הרצות נשארות בנות השוואה. בחירת המודל משפיעה על המספרים הללו יותר מכל דגל: התאמת מודל Qwen 3 ל-GPU בודד ב-VPS מכסה את היבט הזיכרון של בחירה זו.

מדידת זרם בודד תחילה

התחילו במקרה הפשוט ביותר. זוהי בדיקת תקינות, והיא מהווה את תקרת הביצועים. Ollama מציגה את זמני העיבוד שלה.

ollama run llama3.1:8b --verbose "Write 200 words about disk scheduling."

השורה שיש לקרוא היא eval rate, המייצגת את מספר הטוקנים שנוצרים בשנייה. prompt eval rate הוא קצב ה-prefill, ו-load duration הוא הזמן שהושקע בטעינת המודל ל-VRAM. בקריאה הראשונה לאחר הפעלה קרה, load duration הוא ערך גבוה, ולכן total duration עלול להטעות. הריצו את הפקודה פעמיים וקראו את התוצאה השנייה. כברירת מחדל, Ollama פורקת מודל לא פעיל מהזיכרון לאחר חמש דקות, כך שהפסקה ארוכה בין הרצות תחזיר אתכם למצב של הפעלה קרה.

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

curl -s http://127.0.0.1:11434/api/generate -d '{
  "model": "llama3.1:8b",
  "prompt": "Write 200 words about disk scheduling.",
  "stream": false
}' | jq '{eval_count, eval_duration,
         tok_s: (.eval_count / (.eval_duration / 1000000000))}'

eval_duration נמדד בננו-שניות, לכן חלוקה ב-1,000,000,000 תיתן את הערך בשניות. חלוקה זו היא בדיוק מה שתיעוד ה-API של Ollama מורה לבצע עבור חישוב טוקנים לשנייה. אם השרת עדיין אינו פעיל, אירוח עצמי של LLM עם Ollama על גבי VPS מכסה את תהליך ההתקנה ואת יחידת ה-systemd.

מדד ה-TTFT דורש בקשת streaming, וניתן להשתמש ב-curl כדי למדוד זאת עבורכם.

curl -s -o /dev/null -N \
  -w 'ttfb=%{time_starttransfer}s  total=%{time_total}s\n' \
  http://127.0.0.1:8000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"Qwen/Qwen3-8B",
       "messages":[{"role":"user","content":"Write 200 words about disk scheduling."}],
       "stream":true,"max_tokens":256}'

time_starttransfer הוא הרגע שבו מגיע הבית הראשון של גוף התגובה. בבקשת chat completion עם streaming, בית זה שייך לאירוע ה-server-sent event הראשון, שהוא או טוקן התוכן הראשון או delta המכיל תפקיד בלבד שנשלח רגע לפניו. לכן, התייחסו לערך זה כאל ה-TTFT בסטייה של אירוע אחד. הוא מדויק מספיק כדי להשוות בין שתי הרצות על אותו שרת.

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

כיצד מריצים בדיקת עומסים (concurrency sweep)?

בדיקת עומסים מריצה עומס עבודה קבוע ברמות במקביליות עולות ומתעדת את התוצאות בכל שלב. vLLM מספקת את הלקוח הנדרש לכך, והוא תומך ב-OpenAI API, לכן הוא עובד גם מול Ollama וכל שירות אחר התואם ל-OpenAI.

vllm bench serve \
  --backend openai-chat \
  --base-url http://127.0.0.1:8000 \
  --endpoint /v1/chat/completions \
  --model Qwen/Qwen3-8B \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --ignore-eos \
  --num-prompts 160 \
  --max-concurrency 16 \
  --percentile-metrics ttft,tpot,itl,e2el \
  --metric-percentiles 50,99

--max-concurrency מגביל את מספר הבקשות הפעילות, וזהו המשתנה שאתם בודקים. --num-prompts הוא סך הבקשות שנשלחו, לכן שמרו עליו ברמה של פי עשרה מהמקביליות כדי לקבל ממוצע יציב. הסיכום מדפיס את Output token throughput (tok/s): ואת Total token throughput (tok/s):, ולאחר מכן את Mean TTFT (ms):, Median TTFT (ms): ו-P99 TTFT (ms): תחת הכותרת Time to First Token.

אין בנתונים אלו קצב לכל stream, אך ניתן לחשב זאת בחילוק פשוט. Mean TPOT (ms): הוא הזמן הממוצע לכל token פלט לאחר ה-token הראשון, כך ש-25 מילי-שניות ל-token שוות ל-40 tokens לשנייה לכל stream. חילוק של תפוקת הפלט במקביליות ייתן את אותה התוצאה.

לאחר מכן בצעו לולאה ושמרו כל הרצה.

for C in 1 4 16 32 64 128; do
  vllm bench serve \
    --backend openai-chat \
    --base-url http://127.0.0.1:8000 \
    --endpoint /v1/chat/completions \
    --model Qwen/Qwen3-8B \
    --dataset-name random \
    --random-input-len 1024 \
    --random-output-len 1024 \
    --ignore-eos \
    --num-prompts $(( C * 10 )) \
    --max-concurrency "$C" \
    --percentile-metrics ttft,tpot,itl,e2el \
    --metric-percentiles 50,99 \
    --save-result --result-filename "sweep-c$C.json"
done
קריאת קובצי JSON שמורים

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

for f in sweep-c*.json; do
  jq -r --arg f "$f" \
    '[$f, .output_throughput, .total_token_throughput,
      .median_ttft_ms, .p99_ttft_ms] | @tsv' "$f"
done

output_throughput הוא מספר ה-tokens של הפלט לשנייה. total_token_throughput מוסיף את ה-tokens של הקלט בחזרה, כך שביחס של 1:1 התוצאה קרובה לכפול. p99_ttft_ms יופיע גם ללא --metric-percentiles, כיוון שערך ברירת המחדל של דגל זה הוא 99. ה-50 בפקודה הוא שמוסיף את p50_ttft_ms לצד ה-median_ttft_ms שכל מדד המצוין ב---percentile-metrics מקבל. אם תבקשו אחוזון שלא צוין, כגון .p90_ttft_ms, jq ידפיס null.

מה מראה בפועל סריקת מקביליות (concurrency sweep)?

תרשיםIllustrative sweep shape: 8B model, one 24 GB GPU, 1024 in / 1024 out
הנתונים שמאחורי התרשים
[
  {
    "label": "1 stream",
    "per_stream_tok_s": 92,
    "total_tok_s": 92,
    "ttft_p50_ms": 48,
    "ttft_p99_ms": 61
  },
  {
    "label": "4 streams",
    "per_stream_tok_s": 88,
    "total_tok_s": 352,
    "ttft_p50_ms": 71,
    "ttft_p99_ms": 96
  },
  {
    "label": "16 streams",
    "per_stream_tok_s": 71,
    "total_tok_s": 1136,
    "ttft_p50_ms": 152,
    "ttft_p99_ms": 244
  },
  {
    "label": "32 streams",
    "per_stream_tok_s": 54,
    "total_tok_s": 1728,
    "ttft_p50_ms": 287,
    "ttft_p99_ms": 498
  },
  {
    "label": "64 streams",
    "per_stream_tok_s": 34,
    "total_tok_s": 2176,
    "ttft_p50_ms": 611,
    "ttft_p99_ms": 1240
  },
  {
    "label": "128 streams",
    "per_stream_tok_s": 18,
    "total_tok_s": 2304,
    "ttft_p50_ms": 1490,
    "ttft_p99_ms": 3820
  }
]

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

קראו את הצורה, כיוון שהצורה היא מה שניתן להכללה. בזרם (stream) אחד, השרת כולו מפיק 92 טוקנים לשנייה עם p99 TTFT של 61 מילי-שניות. ב-128 streams התפוקה הכוללת מגיעה ל-2304 טוקנים לשנייה, פי עשרים וחמישה, בעוד שכל זרם בודד יורד ל-18 טוקנים לשנייה וערך ה-p99 TTFT מגיע ל-3820 מילי-שניות. התפוקה הכוללת עולה מכיוון שעיבוד באצ'ים (batching) הופך זמני המתנה של זיכרון פנוי לעבודה מועילה. המהירות לכל זרם יורדת מכיוון שאותם משאבי חישוב מתחלקים כעת בין יותר בקשות.

הכפלת הזרמים האחרונה היא נקודת המפתח. מעבר מ-64 ל-128 זרמים מוסיף פחות משישה אחוזים לתפוקה הכוללת, בעוד שערך ה-p99 TTFT משלש את עצמו בערך; המשמעות היא שבקשות נמצאות בתור במקום לעבור עיבוד, או בגלל שזיכרון ה-KV cache מלא, או בגלל שהשרת הגיע למגבלת תזמון כמו max_num_seqs של vLLM. נקודת העבודה היעילה נמצאת מוקדם יותר: ב-32 זרמים השרת עדיין מחזיר 1728 טוקנים לשנייה, 75 אחוזים מהשיא שלו, בקצב של 54 טוקנים לשנייה לכל זרם ו-p99 TTFT של 498 מילי-שניות. דווחו על נקודה זו כקיבולת שלכם. שיא העקומה הוא מספר שלא ניתן לספק ממנו שירות למשתמשים.

Ollama ו-vLLM אינם מודדים את אותו הדבר

הריצו את הבדיקה הזו מול שרת Ollama בהגדרות ברירת מחדל, והתוצאה הכוללת כמעט לא תשתנה. OLLAMA_NUM_PARALLEL מוגדר כברירת מחדל ל-1, לכן בקשה אחת רצה בזמן שהשאר ממתינות, והתור הוא הגורם לעלייה ב-p99 TTFT בעוד שהתפוקה הכוללת נשארת קבועה. העלו ערך זה לפני שתבצעו מדידה כלשהי.

sudo systemctl edit ollama.service
[Service]
Environment="OLLAMA_NUM_PARALLEL=8"

בצעו הפעלה מחדש עם sudo systemctl restart ollama, ולאחר מכן ודאו שהמודל עדיין נכנס בזיכרון. כל slot מקבילי מקבל חלק משלו מחלון ההקשר (context window), לכן התיעוד של Ollama מציין כי הקשר של 2K עם 4 בקשות מקבילות מקצה 8K. אם תעלו את מספר ה-slots גבוה מדי, המודל יגלוש אל מחוץ ל-VRAM. בדקו את ollama ps: עמודת PROCESSOR שמציגה ערך כמו 48%/52% CPU/GPU משמעותה שחלק מהמודל נמצא ב-CPU, ובמקרה כזה התפוקה תרד ככל שתוסיפו במקביליות במקום לעלות. מעבר ל-slots המקביליים, בקשות נכנסות לתור עד OLLAMA_MAX_QUEUE, שערכו 512 כברירת מחדל, ולאחריו השרת משיב בשגיאת 503.

vLLM משתמש ב-continuous batching, לכן הוא מכניס בקשות חדשות ל-batch הרץ ככל שמתפנים slots, והעקומה שלו ממשיכה לעלות עד שמשהו אוזל: בדרך כלל ה-KV cache, אם כי מגבלה מוגדרת כמו max_num_seqs או תקורה של תזמון CPU יכולות לשטח אותה מוקדם יותר. Ollama מותאם למודל אחד, למכונה אחת, ועלות הקמה נמוכה. שני המנועים מספקים לכן תשובות שונות לאותה בדיקה, וזהו הנושא האמיתי של השוואה בין Ollama ל-vLLM כמנועי הגשה. תעדו איזה מנוע ואיזו גרסה הפיקו כל מספר.

חמש דרכים למדוד את הדבר הלא נכון

  • הלקוח מרוחק מדי. ביצוע benchmarking מהמחשב האישי דרך האינטרנט מוסיף את זמן ה-round trip לכל TTFT, כך שאתם מודדים את איכות החיבור הביתי שלכם. הריצו את הלקוח באותו אזור (region) שבו נמצא השרת.
  • המודל היה "קר". הבקשה הראשונה כוללת את טעינת המשקולות, וב-vLLM היא עשויה לכלול גם graph capture. שלחו batch לחימום המערכת והתעלמו מהתוצאה שלו.
  • מנגנון ה-prefix caching ענה במקומכם. vLLM מפעיל prefix caching אוטומטי כברירת מחדל, לכן שליחת אותו ה-prompt שוב ושוב מודדת את המטמון במקום את ה-prefill, וה-TTFT צונח לשבריר מהערך האמיתי. --dataset-name random מונע זאת כיוון שכל prompt שונה. כדי לוודא זאת, הפעילו את השרת עם --no-enable-prefix-caching.
  • הפלט היה קצר מדי. עם תשובות של 32-token, ה-TTFT משתלט על כל בקשה ומדד ה-tokens per second שלכם מתאר למעשה רק את ה-prefill. השתמשו ב---ignore-eos עם אורך פלט ריאלי.
  • דיווחתם רק על concurrency 1. זה נותן את ה-TTFT האופטימלי ביותר בטבלה, וזהו קלט העלות הנכון רק אם הבקשות האמיתיות שלכם לעולם אינן חופפות. אם הן אכן חופפות, העלות תלויה ב-throughput שאתם מקיימים ב-concurrency שהתעבורה שלכם מייצרת בפועל, לכן מדדו גם שם.

הפיכת הנתונים שנמדדו להחלטה עסקית

קחו את תפוקת הפלט שמוצגת בבדיקה ברמת המקביליות של התעבורה האמיתית שלכם, והשוו אותה למחיר לכל token. זהו נתון הרוויה רק אם מספיק בקשות חופפות כדי לשמור על ה-batch מלא; עומס עבודה ששולח בקשה אחת בכל פעם חייב להשתמש בקצב של stream בודד. נקודת האיזון היא פעולת חילוק אחת, לאחר שתתמחרו את ה-tokens של הקלט שמגיעים עם כל token של פלט:

cost_per_million_output = price_out + price_in * (input_tokens / output_tokens)
break_even_tok_s = (price_per_hour / cost_per_million_output) * 1000000 / 3600

בצעו את החישוב לפי המחירים של DigitalOcean מיולי 2026. נקודת הקצה הייעודית להסקה (inference) מסוג H200 עלתה 4.47 דולר לשעה, ושירות ה-serverless של Llama 3.3 70B עלה 0.65 דולר למיליון tokens עבור קלט ו-0.65 דולר למיליון עבור פלט. ביחס של 1:1 שצוין לעיל, כל מיליון tokens של פלט מביאים איתם מיליון tokens של קלט, לכן המחיר האפקטיבי הוא 1.30 דולר למיליון tokens של פלט. מכאן ש-4.47 חלקי 1.30 הם כ-3.44 מיליון tokens של פלט בשעה, וחילוק ב-3,600 שניות נותן כ-955 tokens של פלט לשנייה, או כ-1,910 tokens לשנייה בחישוב משולב של קלט ופלט. המחירים הם שלהם. החילוק הוא שלנו. כשבדקנו ב-25 באוקטובר 2026, נקודת הקצה של H200 עדיין עלתה 4.47 דולר לשעה, אך DigitalOcean הפסיקה את שירות ה-serverless של Llama 3.3 70B ב-18 באוגוסט 2026 והפנתה משתמשים ל-Llama 4 Maverick, שמתומחר ב-0.25 דולר למיליון tokens של קלט ו-0.87 דולר למיליון tokens של פלט. זהו מודל שונה, ולכן הוא דורש בדיקה משלו לפני שההשוואה תהיה בעלת משמעות.

המילה המכריעה כאן היא מתמשך (sustained). הגעה ל-955 tokens של פלט לשנייה ברוויה למשך שעתיים ביום אינה שווה ל-955 tokens של פלט לשנייה באופן מתמשך, כיוון שאתם משלמים גם על עשרים ושתיים השעות הנותרות. השכרת הכרטיס כ-GPU Droplet אינה מורידה את הרף: ב-25 באוקטובר 2026, מחירון ה-Droplet של DigitalOcean הציג את ה-H200 ב-4.47 דולר לשעה לפי דרישה, כמו נקודת הקצה, וכרטיסי ה-NVIDIA הזולים ביותר שלהם, ה-RTX 4000 ב-0.76 דולר לשעה וה-L40S או ה-RTX 6000 ב-1.57 דולר לשעה, קטנים מדי כדי להריץ מודל 70B ב-FP8. לכן, לפי הנתונים לעיל, H200 שמגיע לרוויה ב-2,036 tokens של פלט לשנייה צריך להגיע לממוצע של כ-47 אחוזים מהשיא הזה לאורך כל שעה שאתם משלמים עליה רק כדי להשוות למחיר של 0.65 דולר למיליון tokens (קלט ופלט), ומתחת לזה המחיר לכל token משתלם יותר. שעות GPU לא מנוצלות, ולא איטיות של tokens, הן בדרך כלל מה שמכשיל אירוח עצמי.

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

FAQ

מהו קצב tokens per second טוב עבור LLM באירוח עצמי?

ישנן שתי תשובות, כיוון שהמדד משרת שתי מטרות. עבור אדם יחיד הקורא את הפלט, כל קצב הגבוה מ-20 tokens לשנייה לכל stream הוא מהיר יותר מקצב קריאה אנושי, ולכן תוספת מהירות אינה מועילה. מבחינת עלות, המספר הקובע הוא סך תפוקת הפלט שניתן לשמר תחת עומס העבודה בפועל, ו"טוב" מוגדר כקצב המאפשר הגעה לנקודת איזון. מול עלות של $0.65 למיליון tokens, עבור קלט ופלט כאחד, על שרת בעלות של $4.47 לשעה, רף זה עומד על כ-955 tokens לשנייה בממוצע ביחס של 1:1, לפי מחירי יולי 2026. stream יחיד במודל גדול לעולם לא יגיע לרף זה, וזו הסיבה לקיומו של batching.

מדוע התפוקה של Ollama נשארת קבועה כשאני מוסיף בקשות במקביל?

OLLAMA_NUM_PARALLEL מוגדר כברירת מחדל ל-1, לכן השרת מריץ בקשה אחת בכל פעם לכל מודל ומעביר את השאר לתור, עד למקסימום של OLLAMA_MAX_QUEUE (512 כברירת מחדל) לפני החזרת שגיאת 503. סך הפלט נשאר קבוע בעוד ה-p99 TTFT עולה; זהו סימן מובהק לתור ולא לעומס יתר על ה-GPU. הגדירו את המשתנה ב-systemd drop-in ובצעו restart, לאחר מכן בדקו את ollama ps, כיוון שכל slot מקבילי מכפיל את ה-context המוקצה ועלול לדחוף חלק מהמודל אל ה-CPU.

האם עליי למדוד time to first token או tokens per second?

יש למדוד את שניהם, כיוון שהם נעים בכיוונים מנוגדים ככל שהעומס עולה. TTFT הוא מה שהמשתמש חווה, ותפוקת פלט רוויה היא מה שמשתקף בחשבונית שלך. תעדו את ה-p50 וה-p99 TTFT בכל שלב של concurrency, ולאחר מכן בחרו את רמת ה-concurrency הגבוהה ביותר שבה ה-p99 TTFT עדיין מקובל עליכם. דווחו על התפוקה בנקודה זו כקיבולת שלכם, ולא על הערך המקסימלי מראש העקומה.

האם מספר tokens per second גבוה יותר אומר תמיד עלות נמוכה יותר ל-token?

לא. עלות ל-token היא המחיר השעתי חלקי כמות ה-tokens שהשרת הפיק בפועל באותה שעה, לכן שרת מהיר שנמצא ב-idle רוב היום עדיין מתאפיין בעלות גבוהה ל-token. הניצולת (utilisation) היא הקובעת, לא המהירות בשיא. שימו לב גם ליחידות: סך תפוקת ה-tokens המצוטטת כוללת tokens של קלט, לכן ביחס של 1:1 בין קלט לפלט, מדובר בכמעט כפול מקצב הפלט. אם ה-API שאתם משווים מחייב על tokens של קלט ופלט כאחד, תמחרו את שני החלקים לפני שתבצעו השוואה.

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

#benchmarking#tokens-per-second#vllm#ollama#gpu-vps