Pretraining ל-LLM: נתונים, חישוב, חוקי scaling ועלות

שום דבר במטרה לא משתנה. המודל עדיין חוזה את ה-token הבא, האובדן הוא עדיין ה-cross-entropy של פרק 4 המוחל על הפירוק של פרק 8, והאופטימייזר הוא עדיין AdamW של פרק 6. Pretraining אינו אלגוריתם חדש; זה אותו אלגוריתם שמורץ על קורפוס גדול מספיק כדי שההרצה תדרוש תקצוב. שני דברים מאפשרים זאת: התוויות בחינם, כי היעד עבור המיקום $t$ הוא ה-token ב-$t+1$ וכבר נמצא בטקסט; והסעיף האחרון בפרק 6 הסיר את ההתנגדות, מפני שמודל עם הרבה יותר פרמטרים ממה שהכללים הקלאסיים מאפשרים אינו מתפרק — הוא משתפר. מה שיוצא הוא מודל בסיס — דבר שממשיך טקסט ולא עונה.

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

כאשר $N$ הוא מספר הפרמטרים, $D$ הוא מספר ה-training tokens ו-$C$ הוא סך פעולות הנקודה הצפה. Kaplan ואחרים גוזרים זאת בשני שלבים.¹ Forward: 2 FLOPs לכל פרמטר לכל token, מכיוון שכל פרמטר בכפל מטריצות משמש פעם אחת לכל token, בכפל אחד ובחיבור אחד. Backward: פי שניים מה-forward, מכיוון שה-backward pass של פרק 5 מחשב שני gradients בכל שכבה — ביחס ל-קלטים של השכבה, כדי שהאות ימשיך לנוע, וביחס ל-משקלים שלה — כל אחד מהם כפל מטריצות בגודל של ה-forward, ולכן $4N$.

זו כל הגזירה, וכדאי לבדוק אותה ולא רק להאמין. PyTorch מגיעה עם מונה FLOP אמיתי, torch.utils.flop_counter.FlopCounterMode, שמיירט כל פעולה שמודל שולח ומסכם את העבודה בפועל. מריצים אותו על פני ארבעה סדרי גודל, הגדול שבהם על התקן meta, שמקצה צורות וללא זיכרון:

from torch.utils.flop_counter import FlopCounterMode

counter = FlopCounterMode(display=False)
with counter:                       
    loss = model(x, targets)[1]     
    loss.backward()                 
measured = counter.get_total_flops()
print(measured / (6 * n_params * n_tokens))

היחס forward+backward על פני forward הוא 3.000, בדיוק, בכל קנה מידה: לא קירוב שבמקרה טוב, אלא הזהות האריתמטית שלמעלה מוחזרת כמספר עגול על ידי מונה שאינו יודע דבר על הגזירה.

לאחר מכן הסך הנמדד יושב בין 3% ל-17% מעל $6ND$, ברגע ש-$N$ סופר את מטריצות ה-embedding — והסעיף הזה חשוב, כי שני המאמרים המייסדים סופרים את $N$ אחרת. Kaplan מוציא מן החשבון את ״כל ה-vocabulary וה-positional embeddings״ כי כך ״מתקבלים scaling laws נקיים משמעותית״ (§1.3); Appendix F של Chinchilla אומר ״אנחנו סופרים גם embedding matrices במספר הפרמטרים הכולל״.² עבור vocabulary רחב וממד חבוי צר, ההבדל הוא פי תשעה, כפי שמראה השורה הראשונה.

הפער שנותר הוא מה ש-$6ND$ משמיט במכוון: ציוני ה-attention. משוואה (2.2) של Kaplan כותבת את עלות ה-forward כ-$2N + 2\,n_{\text{layer}} n_{\text{ctx}} d_{\text{model}}$ ומשמיטה את האיבר השני כי $d_{\text{model}} \gg n_{\text{ctx}}/12$ — בטוח ב-2020, פחות בטוח עכשיו, וזו הסיבה שהיחס מטפס כאשר $T/d$ גדל — ולכן שתי שורות כאן חולקות $T$ של 1,024 והיחס יורד, מ-1.145 ל-1.100, כאשר $d$ עולה מ-768 ל-1,600. זו עלות ה-$O(T^2)$ שפרק 9 הציג ופרק 16 הופך למחיר.

Compute קובע כמה זמן הרצה אורכת; זיכרון קובע אם היא יכולה להתחיל. מאמנים עם fp32 AdamW פשוט, וכל פרמטר נושא ארבעה מספרים: המשקל, ה-gradient שלו, והממוצע הנע $m$ והשונות $v$ של Adam — שני הממוצעים שבנינו ביד בפרק 6. ארבעה מספרים בארבעה בתים כל אחד הם 16 בתים לפרמטר, לפני activation יחיד. נמדד על GPU לפטופ של 8 GB, לפי ההקצאה התושבת בנקודה בצעד שבה אין גרף חי:

התחזית והמדידה מסכימות בטווח של 3%. ההפתעה היא העמודה האחרונה: ה-activations מגמדות את המודל. אותו מודל של 5.8 מיליון פרמטרים שצריך 89 MB של מצב מתמיד צריך 4,681 MB של activations ב-batch של 128 — פי חמישים ושניים מהמודל — והרבה מזה בכלל אינו ה-transformer. אלה ה-logits, וקטור אחד בגודל ה-vocabulary לכל token בארבעה בתים לכל כניסה: 512 MB בשורה האחרונה, 393 MB בראשונה. גודל ה-vocabulary נבחר בפרק 7, והוא עדיין קובע מה נכנס לכרטיס.

איזה איבר שולט תלוי בצורה של ההרצה, ולכן Micikevicius ואחרים אומרים שהזיכרון ״נשלט על ידי activations״³ ואילו ZeRO אומר שמודל של 1.5 מיליארד פרמטרים צריך ״לפחות 24 GB״ רק למצבי המודל.⁴ ZeRO מגיע לאותם 16 בתים במסלול אחר — $2\Psi$ למשקלי fp16, ‏$2\Psi$ ל-gradients ב-fp16, ‏$4\Psi$ כל אחד למשקלי master ב-fp32 ולשני המומנטים של Adam — וזה עבור 70 מיליארד פרמטרים הוא 1.12 טרה-בייט, ארבעה-עשר GPUs של 80 GB עוד לפני activation יחיד.

שום דבר מזה לא נכנס להתקן אחד בקנה מידה חזיתי, ולכן ההרצה מפוצלת בארבע דרכים בבת אחת. Data parallelism שם עותק של המודל על כל GPU וממצע את ה-gradients — ברירת המחדל, וזו ש-ZeRO משפר בכך שהוא מסרב לשמור עותקים עודפים של מצב האופטימייזר. Tensor parallelism מפצל מטריצות יחידות בין התקנים. Pipeline parallelism נותן לכל התקן קבוצת שכבות רציפה. Context parallelism מפצל את הרצף עצמו, ונחוץ רק כש-$T$ ארוך מספיק כדי שאיבר ה-attention ישלוט. טבלה 4 של Llama 3 מונה את כל הארבע יחד: tensor 8, context עד 16, pipeline 16, data עד 128, על פני 16,384 GPUs מסוג H100.⁵ זה כל מה שהקורס הזה יאמר על כך; הנדסת training מבוזר היא סמסטר בפני עצמו, ו-CS336 של Stanford הוא הסמסטר הזה, הרצאות 5 עד 8, עם הקוד.⁶ מה שנשאר מההאצלה הוא מספר אחד, model FLOPs utilisation — החלק משיא האריתמטיקה של GPU שהרצה אמיתית משיגה — והוא מה שהופך את $6ND$ המסודר לזמן שעון ולכן לכסף.

בינואר 2020, Kaplan ואחרים אימנו גריד של transformers ומצאו שאובדן הבדיקה עוקב אחרי חוק חזקה בכל אחד משלושת המשאבים על פני יותר משישה סדרי גודל.¹ §1.2 שלהם נותן שלושה חוקים מותאמים:

עם בני לוויה $\alpha_D \approx 0.095$ לנתונים ו-$\alpha_C^{\min} \approx 0.050$ ל-compute מוקצה אופטימלית. הקבועים אינם אוניברסליים, והמאמר אומר זאת: ״הערכים המספריים המדויקים של $N_c$, $C_c^{\min}$ ו-$D_c$ תלויים בגודל ה-vocabulary וב-tokenization ולכן אין להם משמעות יסודית.״

המעריכים זעירים: פי עשרה פרמטרים קונים גורם $10^{0.076} \approx 1.19$ מהאובדן שנותר. זה נשמע כמו כלום, וזה העובדה החשובה ביותר כאן — התשואות גרועות והן לעולם לא נעצרות. חוק חזקה עם מעריך קטן מבטיח שסדר הגודל הבא יעזור, פחות מהקודם, לנצח. קניית compute מפסיקה להיות הימור והופכת לרכישה עם שער חליפין מפורסם, וזה בדיוק הטיעון ששחרר את ההון.

ואז בא המרשם, וכאן המאמר טעה באופן שעלה לתעשייה הרבה מאוד כסף. טבלה 6 של Kaplan נותנת $N_{\text{opt}} \propto C^{0.73}$ ו-$D_{\text{opt}} \propto C^{0.27}$: פי עשרה compute פירושו מודל גדול פי 5.4 שמוזן רק פי 1.9 יותר טקסט. התקציר מפורש — ״training אופטימלי מבחינת compute כולל אימון מודלים גדולים מאוד על כמות נתונים צנועה יחסית ועצירה משמעותית לפני התכנסות.״ התחום עשה בדיוק את זה: GPT-3 הוא 175 מיליארד פרמטרים על 300 מיליארד tokens,⁷ ‏Gopher 280 מיליארד על 300 מיליארד, ‏Megatron-Turing NLG 530 מיליארד על 270 מיליארד.² חצי token עד שני tokens לפרמטר, לכל אורך הדרך.

במרץ 2022, Hoffmann ואחרים אימנו יותר מ-400 מודלים מ-70 מיליון עד 16 מיליארד פרמטרים והגיעו למסקנה ההפוכה בשלושה מסלולים בלתי תלויים.² טבלה 2 שלהם מדווחת על המעריך $a$ ב-$N_{\text{opt}} \propto C^{a}$ כ-0.50, 0.49 ו-0.46, מול 0.73 של Kaplan. במילים פשוטות: גודל המודל ונתוני ה-training צריכים לגדול באותו יחס.

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

אובדן held-out ב-nats לכל token, ‏tokens לפרמטר בסוגריים, מודגש המודל הטוב ביותר בכל תקציב; קו מפריד הוא נקודה שלא הורצה, כי התקציב דרש יותר טקסט מכפי שהקורפוס מכיל או שהגודל היה מחוץ לטווח שנסרק שם.

קראו עמודה כלפי מטה: האובדן יורד, מגיע לתחתית ואז עולה שוב. מודל יכול להיות גדול מדי לתקציב שלו בדיוק באותה קלות שבה הוא יכול להיות קטן מדי — ב-$10^{14}$ הקנס על בחירת 665,280 פרמטרים במקום 295,808 הוא 0.08 nats, שעל המעטפת שהותאמה למעלה הוא האובדן שמודל בגודל נכון מגיע אליו עם 18% פחות compute. בחירת הצורה הלא נכונה זורקת חמישית מהתקציב. זו Figure 3 של Chinchilla אחר צהריים אחד על GPU יחיד במקום עם ארבע מאות מודלים.

עכשיו קראו לרוחב. ב-$10^{13}$ המודל הטוב ביותר הוא הקטן ביותר שנסרק; ב-$10^{14}$ הוא 295,808 פרמטרים, מוקף משני הצדדים. האופטימום זז ימינה כשהתקציב גדל, וזה כל תוכן התיקון. התאימו את הגישה השלישית של המאמר — המשטח $L(N,D) = E + A/N^{\alpha} + B/D^{\beta}$ על פני כל ההרצות — ומזערו בכפוף ל-$C = 6ND$:

L(N, D) = 24.7 / N^0.195 + 46.8 / D^0.169       (E fits to ~0; see below)
implied   N_opt ∝ C^0.464
  compare   Chinchilla 0.46-0.50 · Besiroglu 0.513 · Kaplan 0.73

0.46, מלפטופ, מול 0.73 של Kaplan. התאמה לשלוש ספרות מתקציב של שלושה תקציבים היא מזל; התאמה לספרה הראשונה אינה. המעריך נוסע — הקבוע לא, כי יחס ה-token-לפרמטר באופטימות האלה הוא 170 עד 540, לא 20. שלוש סיבות, כולן מאלפות. $E$ מתאים לאפס כי באובדן מעל 4 nats ההרצה אינה קרובה לרצפת האנטרופיה ששולטת בהתאמה של Chinchilla. גודל ה-batch וקצב הלמידה היו קבועים ולא כוונו לכל נקודה, מה שמקשה על ההרצות שמקבלות הכי מעט צעדים — ואלה המודלים הגדולים: ב-$10^{13}$ FLOPs מודל של 1.28 מיליון פרמטרים מקבל 159 צעדי אופטימייזר בסך הכול, הרבה מתחת לכמה אלפים שאיבר $S_{\min}$ של Kaplan אומר שכל מודל צריך. Scaling law מותאם בתוך משטר, וזה יושב שישה סדרי גודל מתחת ל-Chinchilla.

ומכאן תקציר המאמר: ״current large language models are significantly undertrained״. Chinchilla הוא ההדגמה — 70 מיליארד פרמטרים על 1.4 טריליון tokens, אותו compute כולל כמו Gopher עם 280 מיליארד על 300 מיליארד, ומנצח אותו ב-51 מתוך 57 משימות MMLU, ‏67.5% מול 60%.² קטן פי ארבעה, טקסט רב פי ארבעה וחצי, אותו כסף, מודל טוב יותר.

שתי הסתייגויות לגבי היחס המפורסם הזה. ״עשרים tokens לפרמטר״ אינו משפט במאמר, שאומר רק ש״עבור כל הכפלה של גודל המודל גם מספר ה-training tokens צריך להיות מוכפל״; ה-20 הוא היסק מטבלה 3 ומ-70 B על 1.4 T של Chinchilla עצמו. והדיוק שלו גרוע מהמודפס: Besiroglu ואחרים התאימו מחדש מתוך דיגיטציה של Figure 4, מצאו שהפרמטרים המקוריים ״מתאימים לנתונים המשוחזרים בצורה גרועה״ עם רווחים ״צרים באופן בלתי סביר בהינתן מספר נקודות הנתונים״, והעמידו את הטווח הישר על ״בין 4 ל-40״ tokens לפרמטר.⁸

פרט אחד בשיטה של Chinchilla מקיים הבטחה שפרק 1 נתן לגבי schedules של קצב למידה. ה-cosine schedule חייב להיות מותאם לתקציב ה-token. מודל שיראה 10 מיליון tokens חייב לדעוך את קצב הלמידה שלו לאפס ב-10 מיליון tokens; תנו לו schedule בגודל 100 מיליון, עצרו אותו מוקדם, ואתם קוראים אובדן באמצע ירידה בקצב גבוה מדי. Chinchilla מאמן כל מודל בארבעה אורכי מחזור כדי לשלוט בדיוק בזה; הסריקה למעלה קובעת את ה-schedule שלה מהתקציב מאותה סיבה.

הם התוצאה האמפירית השימושית ביותר בתחום, ומוכרים אותם מעבר למה שהם אומרים. ארבע מגבלות.

הם חוזים אובדן, לא יכולת. אגף שמאל הוא cross-entropy על טקסט held-out. שום דבר במאמרים האלה לא מתיר טענה לגבי האם מודל יכתוב SQL נכון, יסרב לבקשה מזיקה או ישתמש בכלי. זה שוב הלקח של פרק 5: חיזוי של האובדן אינו חיזוי של ההתנהגות שעליה אתם משלמים.

הם מותאמים, לא נגזרים. אין תיאוריה שמייצרת את $\alpha_N = 0.076$. הקבועים זזים עם ה-tokenizer — ולכן השוואת perplexity בין שני tokenizers היא חסרת משמעות, כפי שהסביר פרק 8 — ועם תערובת הנתונים, הארכיטקטורה והאופטימייזר. כל חוק מפורסם הוא חוק של ההתקנה שיצרה אותו, ולכן Meta התאימה מחדש את שלה לפני Llama 3.⁵

הם מניחים token טרי לכל צעד, מה שמניח בשקט קורפוס אינסופי. Muennighoff ואחרים מדדו מה קורה כשהוא נגמר: עד ארבע תקופות של נתונים חוזרים עולות כמעט כלום — מודל של 8.7 מיליארד פרמטרים על 44 מיליארד tokens ייחודיים שנראו ארבע פעמים סיים עם ״רק 0.5% יותר validation loss״ מאותו מודל על 178 מיליארד ייחודיים — בעוד שמעבר לכ-16 תקופות compute נוסף לא קונה כלום.⁹

ואף אחד כבר לא מאמן compute-optimal. Chinchilla ממזער את עלות ה-training; מודל פרוס משלם אחר כך בערך $2N$ FLOPs לכל token שנוצר, לנצח. LLaMA 1 אמר זאת במפורש: ״בהינתן רמת ביצועים יעד, המודל המועדף אינו המהיר ביותר לאימון אלא המהיר ביותר ב-inference״.¹⁰ Sardana ואחרים ניסחו זאת פורמלית על ידי מזעור $6ND_{\text{train}} + 2ND_{\text{inference}}$ במקום זאת, ומצאו שמי שמצפה למיליארד בקשות צריך לאמן ״קטן יותר וארוך יותר מ-Chinchilla-optimal״.¹¹ §9.1 של Llama 3 מסכים: המודלים הקטנים שלו מאומנים ״הרבה מעבר לנקודת ה-compute optimal training, ובפועל מחליפים training compute ביעילות inference״.⁵ היחס אינו מיושן; הוא עונה על שאלה שכבר אינה זו שנשאלת.

האובדן יורד בצורה חלקה. ציוני benchmark לפעמים לא. Wei ואחרים אספו מקרים שבהם משימה יושבת ברמת ניחוש לאורך סדרי גודל של training compute ואז קופצת — אריתמטיקה תלת-ספרתית שמופיעה ב-GPT-3 סביב $2 \times 10^{22}$ FLOPs, ‏MMLU עולה מעל ניחוש בין $3$ ל-$5 \times 10^{23}$ — ונתנו לתבנית שם: ״יכולת היא emergent אם היא אינה קיימת במודלים קטנים יותר אך קיימת במודלים גדולים יותר״.¹² אם זו תכונה אמיתית, אקסטרפולציה מניסויים זולים אינה בטוחה, כי היכולת שאתם קונים עלולה לא להתקיים בשום קנה מידה שאתם יכולים להרשות לעצמכם לבדוק.

Schaeffer, Miranda ו-Koyejo טענו שרוב זה הוא ארטיפקט של מדידה, והמנגנון הוא אריתמטי.¹³ אובדן per-token יורד בצורה חלקה, ולכן ההסתברות ש-token אחד יהיה נכון, $\exp(-\mathcal{L})$, משתפרת בהדרגה. מדרגים את המודל עם exact string match על תשובה באורך $L$ tokens ומעלים את ההסתברות הזאת בחזקת $L$ — עקומה חלקה בחזקה גדולה נראית כמו צוק. החליפו למדד שסופר tokens במקום לדרוש את כולם, על אותם פלטים, ו״ביצועי המשפחה משתפרים בצורה חלקה, רציפה וצפויה עם הגדלת scale״.

הביקורת שלהם היא המספר שצריך לזכור — ״מתוך 39 המדדים המועדפים ב-BIG-Bench, לכל היותר 5 מציגים emergence״, כאשר שני מדדים לא רציפים אחראים ליותר מ-92% מהמקרים הנטענים — וכך גם האזהרה שלהם: ״אין לפרש דבר במאמר זה כטענה ש-large language models אינם יכולים להציג יכולות emergent״. קפיצה בתרשים היא ראיה על המדד עד שיוכח אחרת. פרק 29 הוא המקום שבו זה נהיה הבעיה שלכם, כי בחירת מדד עם cutoff קשיח היא החלטה שתקבלו בלי לשים לב.

הקורפוס הוא החלק בהרצת pretraining שאין לו משוואה צמודה, ושבו נמצאות רוב ההחלטות המשמעותיות. חומר הגלם הוא סריקת web: ארכיון אוגוסט 2026 של Common Crawl מחזיק ״2.14 מיליארד דפי web או 360 TiB של תוכן לא דחוס״, חודש אחד ממנו, בחינם להורדה.¹⁴ כמעט כלום מזה אינו שמיש כפי שהוא. מאמר T5 אומר שהסריקה ״מורכבת ברובה מג׳יבריש או מטקסט boiler-plate כמו תפריטים, הודעות שגיאה או טקסט כפול״, וצינור C4 שהציג הוא רשימת heuristics קהות — לשמור רק שורות שמסתיימות בפיסוק סופי, להשליך דפים עם פחות משלושה משפטים, להשליך כל דף שמכיל סוגר מסולסל או מילה מרשימה ציבורית של גסויות — ולהפוך עשרים טרה-בייט של טקסט חודשי לכ-750 GB.¹⁵

קהות היא המילה. Dodge ואחרים בדקו מה המסננים האלה מסירים ומצאו שרשימת החסימה של גסויות מוחקת 42% מהמסמכים באנגלית אפרו-אמריקאית ו-32% באנגלית המזוהה עם היספנים, לעומת 6.2% באנגלית המזוהה עם לבנים, ומשאירה קורפוס ש-97.8% ממנו בקטגוריה האחרונה.¹⁶ לכלל שלא הייתה לו דעה על דיאלקט הייתה אחת.

ואז deduplication, שאינה ניקיון: Lee ואחרים מצאו משפט בן 61 מילים שחזר 61,036 פעמים ב-C4, והראו ש-deduplication חותכת פי עשרה את הקצב שבו מודלים ״פולטים טקסט משונן״, מ-1.9% מה-generated tokens ל-0.19%.¹⁷ יותר אינו בהכרח טוב יותר — צוות FineWeb ביצע deduplication גלובלי על פני 96 סריקות, קיבל 4 טריליון tokens וללא שיפור מדיד, ואז ביצע deduplication לכל סריקה בנפרד, קיבל 20 טריליון, והשווה לקורפוס הקיים הטוב ביותר.¹⁸

ואז זיהום. Llama 3 מדד את שלו ופרסם אותו: 98% מ-AGIEval, ‏95% מ-BIG-Bench Hard ו-85% מ-HellaSwag חופפים לסט ה-training לפי 8-grams, ועבור MMLU חפיפה כה גבוהה ש״בלתי אפשרי לקבל אומדן טוב של שיפור ביצועים״.⁵ §4 של GPT-3 מדווח על באג סינון שהשאיר benchmarks בתוך הנתונים ללא דרך חזרה: ״בגלל שיקולי עלות לא היה מעשי לאמן מחדש את המודל״.⁷

Provenance הוא החלק הלא פתור. The Pile הגיע עם רכיב של 100.96 GiB בשם Books3 — 12% מהקורפוס, ולפי טבלת ההסכמה של המאמר עצמו, ספרים מ-tracker פרטי של torrents;¹⁹ הוא הורד מהרשת באוגוסט 2023 אחרי תלונת זכויות יוצרים. המצב המשפטי נכון לספטמבר 2026 אינו מוכרע, ושלוש הפסיקות האמריקאיות המצוטטות כמגמה אינן מסכימות זו עם זו. Alsup מצא ש-training על ספרים שנרכשו כדין הוא ״טרנספורמטיבי באופן יוצא דופן״ אך קבע שספרייה שנבנתה מעותקים פיראטיים אינה כזו, ו-Anthropic הסדירה את המחצית הזאת תמורת $1.5 מיליארד המכסים 482,460 יצירות, בערך $3,000 כל אחת, באישור 20 ביולי 2026.²⁰ Chhabria נתן ל-Meta פסק דין מקוצר בעודו כותב שפסיקתו ״אינה עומדת בעד הטענה שהשימוש של Meta בחומרים מוגנים בזכויות יוצרים כדי לאמן את מודלי השפה שלה הוא חוקי״, אלא רק ש״התובעים האלה העלו את הטיעונים הלא נכונים״.²¹ Bibas, שפסק נגד Ross Intelligence, ציין ש״רק AI לא-גנרטיבי נמצא לפניי היום״.²² שום בית משפט לערעורים בארה״ב לא הכריע בשאלה.

אנשים עושים את החלקים שהאובדן לא יכול. TIME דיווח בינואר 2023 שעובדים שסימנו טקסט רעיל עבור OpenAI דרך חברת Sama לקחו הביתה ״בין כ-$1.32 ל-$2 לשעה״ בעודם קוראים קטעים המתארים פגיעה מינית בילדים, עינויים ופגיעה עצמית, בעוד OpenAI שילמה ל-Sama ‏$12.50 לשעה עבור העבודה; Sama חולקת גם על טווח השכר וגם על המכסה.²³ זה הסינון סביב pretraining ולא ה-pretraining עצמו — אבל הוא נמצא באותה חשבונית, ושם יושב אדם.

החשמל אמיתי ובדרך כלל מצוטט לא נכון. הנתון הזהיר ביותר שפורסם הוא של BLOOM: ‏1,082,990 שעות GPU, ‏433 MWh ו-24.7 טונות של שווה-ערך CO₂ להרצה, 50.5 כולל ייצור וצמתים במנוחה;²⁴ Patterson ואחרים מציבים את GPT-3 על 1,287 MWh ו-552 טונות.²⁵ שתי אזהרות. היתרון של BLOOM הוא רשת החשמל הגרעינית בצרפת ב-57 גרם CO₂ לקוט״ש ולא יעילות — הוא השתמש ביותר אנרגיה מ-OPT-175B. והמספר המצוטט ביותר בתחום לפליטות, 626,155 lb של Strubell ואחרים עבור neural architecture search, הוכח אחר כך כגבוה פי 88, כי הניחו שהחיפוש רץ בגודל מודל מלא כשבפועל רץ על proxy.²⁶ המסגור של LBNL הוא המגן: datacentres בארה״ב השתמשו ב-192 TWh ב-2024, ‏4.7% מהחשמל הלאומי — מספר שמוצמד לתעשייה, לא להרצה יחידה.²⁷

קו החיבור הוא מה ש-Bender ואחרים כינו חוב תיעוד: ״להכניס את עצמנו למצב שבו ה-datasets גם לא מתועדים וגם גדולים מכדי לתעד post hoc״.²⁸ כל עובדה למעלה קיימת כי מישהו הסתכל. עבור הקורפוסים שמאחורי המודלים שרוב האנשים משתמשים בהם, אף אחד לא יכול.

עכשיו האריתמטיקה שכולם רוצים, מארבעה קלטים מצוטטים, כך שכאשר הם יתיישנו יהיה ברור מה להחליף.

קראו את שתי העמודות האחרונות יחד. ב-$10,000 מקבלים מודל של 5 מיליארד פרמטרים על צומת שכור אחד בתוך שבועיים. ב-$100,000,000 האריתמטיקה אומרת 546 מיליארד פרמטרים — ושנים-עשר אלף H100s מחווטים יחד לשלושה חודשים, וזה לא משהו ששוכרים בכרטיס אשראי. מעבר לכ-$100,000, האילוץ הכובל מפסיק להיות כסף והופך ל-cluster.

לפני שסומכים על טבלה כזאת, בדקו אותה מול הרצות שהעלות האמיתית שלהן פורסמה — llm.c משחזר GPT-2 124M ב-״~90 דקות״ על צומת 8×A100 ״בערך ב-$20״, ו-GPT-2 1.6B ב-24 שעות על צומת 8×H100 תמורת $672.³¹

$672, against what $672 actually bought (llm.c GPT-2 1.6B, one 8xH100 node, 24 h)
  this table predicts:      168 H100-hours   N = 1.41 B params   D = 28.3 B tokens
  what was actually run:    192 H100-hours   N = 1.558 B params  D = 33.6 B tokens

Llama 3 405B, against Meta's own published GPU-hours
  from the paper's 3.8e25 FLOPs at 40 % MFU:   26.67 M H100-hours
  published in Meta's Llama 3.1 model card:    30.84 M H100-hours    ratio 0.86

שניהם בטווח של כ-15%, שזה בערך הדיוק שאומדן כזה ראוי לו, וטוב בהרבה מהדיוק שבו הוא בדרך כלל מצוטט.

המספר החוזר ביותר בנושא הזה הוא שמודל מסוג GPT-2 שעלותו הייתה בערך $43,000 ב-2019 ניתן לשחזור היום בכמה עשרות דולרים. החצי המודרני מתועד היטב; החצי ההיסטורי לא.

היום. README של nanochat מאת Karpathy: ״אתם יכולים לאמן LLM משלכם ביכולת GPT-2 ... תמורת רק $48 (2 שעות של צומת GPU ‏8XH100) ... על spot instance, העלות הכוללת יכולה להיות קרובה יותר ל-$15.״³² ״יכולת GPT-2״ כאן מדויקת ומפורסמת — ניצחון על CORE score של GPT-2, ‏0.256525 — על leaderboard שהכניסה הטובה ביותר בו נכון ל-14 במרץ 2026 היא 1.65 שעות. ה-$48 מניח $3 לשעת GPU, מתחת למחיר הרשמי של Lambda, ‏$3.99; במחיר הרשמי זה קרוב יותר ל-$64.

ב-2019. אין מקור ראשוני: OpenAI מעולם לא פרסמה משך או עלות. השרשרת עוברת דרך The Register, פברואר 2019, שדיווח על ״256 ליבות Google TPU3״ ללא מחיר וללא משך; ואז Synced, יוני 2019, שציין שהחומרה עלתה $256 לשעה ב-Google Cloud ואמר במפורש ש-״OpenAI didn't specify the training duration״. ‏$43,008 הם $256 לשעה כפול 168 שעות משוערות שאיש מעולם לא ביסס.

לכן הכותרת הישרה היא: מודל התואם את ציון ה-benchmark המפורסם של GPT-2 ניתן לאימון היום בהרבה פחות מ-$100 על חומרה שכורה, מול עלות ב-2019 שמעולם לא פורסמה ושהאומדן המפורסם שלה נשען על ניחוש לא ממוסמך לגבי משך הזמן. הקריסה אמיתית והחצי המודרני ניתן לשחזור לכל מי שיש לו כרטיס אשראי; היחס הוא אריתמטיקה על מספר שאינו קיים. זה מצב עלויות ה-training המפורסמות בכלל. במאמר GPT-3 אין שום סכום בדולרים, רק $3.14 \times 10^{23}$ FLOPs בטבלה D.1;⁷ גם במאמר Llama 3 אין.⁵ כל עלות training שקראתם היא אומדן מתוך ספירת FLOP, הנחת חומרה והנחת מחיר — תמיד כדאי לשאול של מי.

מה שיוצא ראה קורפוס קבוע שנאסף ברגע קבוע, ומכך נובעות שתי תכונות.

הראשונה היא knowledge cutoff. אחרי תאריך האיסוף המודל לא יודע כלום — לא ״לא בטוח״, כלום — והוא ימציא בשטף במקום לומר זאת, כי לומר זאת מעולם לא היה התנהגות שעליה אומן. כרטיס המודל של Llama 3.1 נותן דצמבר 2023;³³ לכל מודל יש אחד, והוא תכונה של נתוני ה-training, לא של הפריסה. עקיפה שלו היא בעיית retrieval, וזה פרק 19.

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

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

להפוך אותו למשהו שעונה דורש שלב שני שעולה שבריר אחוז מהראשון, ומורכב כמעט כולו מהצגת דוגמאות להתנהגות שאתם רוצים ואז השוואת זוגות של הפלטים שלו עצמו. השלב הזה הוא המקום שממנו מגיעים instruction following, chat templates, סירובים וגם — וזה מפתיע אנשים — היכולת לקרוא לכלי. פרק 11 הוא השלב הזה: supervised fine-tuning, ‏RLHF, ‏DPO ו-GRPO, והשאלה מה פירוש ״aligned״ ומי מחליט.

כדאי לקרוא לצד הפרק הזה גם את build-nanogpt של Karpathy ואת הווידאו הנלווה אליו, שמוליכים שחזור מלא של GPT-2 מקצה לקצה בקצב שהפרק הזה לא יכול; וגם את Stanford CS324, ‏Large Language Models, שההרצאות שלו על נתונים ועל השפעה סביבתית מעמיקות יותר מהסעיף שלמעלה בחומר שהקורס הזה מטפל בו פעם אחת ומאציל הלאה.