TTFT ו-FLOPs: למה המודל מחכה רגע לפני שהוא עונה, ואז זורם

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

בואו נתחיל מהרגע הכי מתסכל, השנייה שאנחנו בוהים במסך ריק ומחכים.

מה זה TTFT: השנייה שאנחנו מחכים

נתחיל מהמושג הראשון. TTFT, ראשי תיבות של Time To First Token, הוא הזמן מרגע ששלחנו את הפרומפט ועד שהטוקן הראשון של התשובה מופיע על המסך. זה בדיוק משך ה"בהייה במסך ריק" לפני שהטקסט מתחיל לזרום.

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

למה זה קורה: שלב ה-Prefill

הנה הלב של העניין, וזה מה שרוב האנשים לא יודעים. לפני שהמודל יכול לפלוט אפילו טוקן אחד, הוא חייב לקרוא ולעבד את כל הפרומפט שלנו במכה אחת. השלב הזה נקרא prefill, והוא זה שקובע את ה-TTFT. המודל בונה מעין "זיכרון עבודה" (שנקרא KV cache) מכל מילה בקלט, ורק אז הוא מוכן לייצר את הטוקן הראשון.

וכאן הכלל שכדאי לזכור, שגם NVIDIA מדגישה: ככל שהפרומפט ארוך יותר, כך ה-TTFT גדול יותר. פרומפט של 4000 מילים ייקח הרבה יותר זמן להתחיל לענות מפרומפט של 20 מילים, כי יש יותר לעבד לפני הטוקן הראשון.

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

עכשיו FLOPs: היחידה שמודדת עוצמת חישוב

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

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

הנה המספרים הרשמיים מדפי הנתונים של NVIDIA, וההבדלים ענקיים:

תראו את הקפיצה. כרטיס A100 עושה 312 טרה-FLOPs לשנייה, ה-H100 קופץ ל-989, וה-B200 החדש מגיע ל-2,250, כלומר 2.25 פטה-FLOPs. עובדה מגניבה: ה-H200 זהה ל-H100 בעוצמת החישוב, כי זה אותו שבב בדיוק, השדרוג שלו הוא רק בזיכרון. ובדיוק הדקויות האלה קובעות כמה מהר נקבל את הטוקן הראשון.

הגשר: איך FLOPs קובעים את ה-TTFT

עכשיו נחבר את שני המושגים, וזה החלק היפה. כל טוקן שהמודל מעבד עולה בערך פעמיים מספר הפרמטרים שלו בפעולות חישוב (כלל ה-2N). מודל של 70 מיליארד פרמטרים שורף כ-140 מיליארד פעולות על כל טוקן.

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

בואו נעשה דוגמה מספרית אחת, כי היא ממחישה הכל. פרומפט של 1000 טוקנים למודל 70B דורש 140 טרה-FLOPs של עיבוד. על H100 שעושה בערך 989 טרה-FLOPs לשנייה (ובניצולת מציאותית של כ-50 אחוז), זה יוצא בערך 280 מילי-שניות רק כדי להתחיל לענות. וזו הסיבה שהטוקן הראשון הוא ה"יקר", ואילו כל השאר זורמים.

וכמה זה בעולם האמיתי

בשביל פרופורציה, הנה זמני TTFT מדווחים מ-API מהירים ב-2026: מודלים מהירים כמו Mistral Large נותנים טוקן ראשון בכ-300 מילי-שניות, GPT-5.2 בכ-550, ומודלי חשיבה כבדים יכולים לקחת כמה שניות שלמות.

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

איך מודדים TTFT בעצמנו

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

import time
from anthropic import Anthropic

client = Anthropic()
start = time.time()
ttft = None

with client.messages.stream(
    model="claude-haiku-4-5",
    max_tokens=500,
    messages=[{"role": "user", "content": "Explain TTFT in one line."}],
) as stream:
    for event in stream.text_stream:
        if ttft is None:                 # first chunk arrived
            ttft = time.time() - start
            print(f"TTFT: {ttft*1000:.0f} ms")
            break

שורה תחתונה, ובעיניי

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

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

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