מה זה Mode Collapse, ולמה GPT-5.5 לא מפסיק לדבר על גובלינים?

ב-30 לאפריל 2026 דלף system prompt של Codex עם הוראה אחת מוזרה: 'אל תדבר על גובלינים'. הסיפור שמאחוריה הוא הדגמה מושלמת ל-mode collapse, התופעה שמסבירה למה ChatGPT מסכים איתכם, למה Claude מרבה ב-em dashes, ולמה כל המודלים מתחילים להישמע אותו דבר.

ב-30 לאפריל 2026, משתמש ב-Reddit מצא שורה מוזרה ב-system prompt של Codex, סוכן הקוד של OpenAI, שדלף ל-GitHub:

ההוראה הזו מופיעה ב-system prompt פעמיים. במודל שעלה מיליארדי דולרים לאמן.

יום למחרת, OpenAI פרסמו בלוג רשמי בשם “Where the goblins came from” שמסביר איך הם הגיעו לשם. הסיפור הוא דוגמה מצוינת לתופעה שנקראת mode collapse, וכשמבינים אותה, הרבה מהתנהגויות מוזרות של LLMs מקבלות הסבר.

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

אינטואיציה קצרה - הקוברות של דלהי

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

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

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

מה קרה, סיפור הגובלינים

בנובמבר 2025, עם GPT-5.1, OpenAI השיקו שמונה פרסונליות ל-ChatGPT. אחת מהן היתה “Nerdy”, והאמת מהמאמר של OpenAI עוד יותר מצחיקה. ה-system prompt של Nerdy אומר ממש: “You must undercut pretension through playful use of language.” זה הקטע שיצר את הבעיה - “playful use of language” הוא בדיוק הסיגנל שה-Reward Model תרגם ל”גובלינים = שנינות”. שווה לציין את זה כי זה הופך את הסיפור מ”איכשהו זה קרה” ל”רואים בדיוק את החוט שמוביל לזה”:

ואז המודל התחיל להתאהב בגובלינים.

אבל כדי להבין למה זה קרה, צריך להבין איך LLM בכלל לומד מה “טוב”.

איך RLHF עובד בפועל

ה-pre-training של LLM נותן לנו מודל שיודע לנבא את המילה הבאה. אבל “מנבא מילים טוב” הוא לא אותו דבר כמו “עוזר שימושי”. אז מגיע שלב שנקרא RLHF (Reinforcement Learning from Human Feedback), בשלושה צעדים:

צעד 1: Supervised Fine-Tuning (SFT)

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

צעד 2: אימון Reward Model

לוקחים זוגות תשובות של המודל לאותה שאלה, ומבקשים מבני אדם לבחור איזו טובה יותר. מהדאטה הזה מאמנים Reward Model $R_\phi$ שמקבל תשובה ומחזיר מספר אחד, ציון שאומר “כמה זו תשובה טובה”.

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

הפונקציית האובדן של ה-Reward Model:

מה רואים פה?

• $y_w$ היא התשובה המועדפת (w = winner), $y_l$ היא הפחות מועדפת (l = loser)
• $R_\phi(x, y_w) - R_\phi(x, y_l)$ הוא ההפרש בין הציונים. רוצים שיהיה חיובי, כלומר שהתשובה הטובה תקבל ציון גבוה יותר
• $\sigma$ (sigmoid) הופך את ההפרש למספר בין 0 ל-1

• $\log$ הופך את זה לפונקציית אובדן נוחה לאופטימיזציה. ה-$-$ בהתחלה הופך את המקסימיזציה למינימיזציה (מוסכמה נפוצה)

במילים פשוטות: “תלמד לתת ציון גבוה יותר לתשובה שבני אדם העדיפו.”

צעד 3: RL עם PPO

עכשיו מאמנים את ה-LLM הגדול למקסם את הציון של $R_\phi$. האלגוריתם נקרא - PPO (Proximal Policy Optimization). בכל צעד, ה-LLM מייצר תשובה, ה-Reward Model נותן ציון, וה-LLM מתעדכן כדי לייצר תשובות עם ציון גבוה יותר.

הפונקציה שמנסים למקסם:

עכשיו אני יודע שזה קצת מפחיד אז בואו נעשה סדר

$r_t(\theta) = \frac{\pi_\theta(a_t|s_t)}{\pi_{\theta_{old}}(a_t|s_t)}$ הוא היחס בין ההתפלגות החדשה לישנה.

• אם גדול מ-1, המודל נתן הסתברות גבוהה יותר לתשובה הזו מאשר קודם
• אם קטן מ-1, נמוכה יותר

$\hat{A}_t$ הוא ה-advantage, כמה התשובה הייתה טובה יותר ממה שציפינו.

• ציפינו לציון 0.5, קיבלנו 0.8: advantage חיובי, תגביר הסתברות
• ציפינו לציון 0.5, קיבלנו 0.2: advantage שלילי, תקטין הסתברות

ה-$min$ וה$clip$ הם הלב של PPO. והרעיון: כשהיתרון חיובי (התשובה היתה טובה מהצפוי), הקליפ העליון $1+\epsilon$מונע מהמודל להגדיל את ההסתברות יותר מדי בצעד אחד. כשהיתרון שלילי, הקליפ התחתון $1-\epsilon$ מונע ירידה חדה מדי. ה-$min$ הוא זה שגורם לקליפ להיות אסימטרי לפי סימן היתרון.

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

במילים פשוטות: “תתעדכן לכיוון הנכון, אבל אל תעשה צעד גדול מדי.”

הבעיה: PPO לבד לא מספיק

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

אז מוסיפים KL penalty:

מה רואים פה?

$\mathbb{E}_y[R_\phi(y)]$ הוא הציון הממוצע של ה-Reward Model. רוצים למקסם אותו.

$D_{KL}(\pi_\theta \| \pi_{ref})$ מודד כמה ההתפלגות החדשה שונה מהמקורית.

$\beta$ הוא ידית הכיוונון:

• גבוה מדי: המודל לא לומד כלום כי הוא מפחד להתרחק מהמקור
• נמוך מדי: המודל קורס לתשובה אחת שמקבלת ציון גבוה ושוכח את כל השאר

במילים פשוטות: “תקבל ציון גבוה, אבל אל תתרחק יותר מדי ממה שהיית.”

Reward Hacking - כשהמדד הופך למטרה

חוזרים לגובלינים.

ה-Reward Model של Nerdy אמור היה ללמוד לזהות תשובות “שנונות”. אבל הוא מצא קיצור דרך, תשובות עם מטאפורות של יצורי פנטזיה קיבלו ממנו ציון גבוה יותר באופן עקבי, ב-76.2% מה-datasets. לא בגלל שמישהו החליט את זה, אלא כי ה-Reward Model מצא קורלציה בין יצורים לשנינות ונאחז בה.

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

זה נקרא reward hacking: המודל מצא דרך לקבל ציון גבוה שלא תאמה למה שהמתכננים רצו.

אבל למה זה הפך כל כך קיצוני? למה לא קיבלנו “קצת גובלינים מדי פעם” אלא הצפה של +3,881%?

וכאן נכנס mode collapse.

Mode Collapse - כשהתפלגות מתכווצת

לפני RLHF, אם שואלים את המודל לתאר באג, הוא יכול היה לומר אלף דברים שונים. ההתפלגות על תשובות אפשריות היתה רחבה: race condition, null deref, memory leak, off-by-one, וגם, באחוז זעיר: “A tiny goblin is racing your threads to the database.”.

מה ש-PPO עושה בכל צעד הוא פשוט לקחת תשובות עם advantage חיובי ולהזיז קצת מסה הסתברותית לכיוונן. כשה-Reward Model אוהב גובלינים, כל מופע של “goblin” שיצא במהלך האימון מקבל advantage חיובי וההסתברות שלו עולה קצת.

וכאן מתחיל החיזוקים, ככל שההסתברות של “goblin” עולה, המודל מייצר אותו ביותר sample-ים, מקבל יותר עדכוני gradient חיוביים סביבו, והוא עולה עוד. בינתיים כל המסה הזו חייבת לבוא ממקום (ההסתברויות מסתכמות ל-1) אז race condition, null deref ושאר התשובות הסבירות יורדות כל אחת בכמה נקודות אחוז. אחרי מיליוני צעדים, מה שהיה רעש זניח בהתחלה מרכז את רוב המסה.

הנה הדינמיקה הזו בזמן אמת. לחצו “הרץ 30 צעדים” וצפו איך כל המסה זולגת ל”goblin”. שחקו עם ה-β, ראו מה צריך כדי לעצור את זה:

המודל לא “שכח” שאפשר לתאר באג בלי גובלין. הוא פשוט מקצה לזה הסתברות כמעט אפסית. זו mode collapse: ההתפלגות קרסה מאלף modes לכמה בודדים.

למה ה-KL penalty לא עצר את זה?

זו השאלה הטובה. הרי הוספנו KL penalty בדיוק כדי למנוע את זה.

הבעיה היא שה-$\beta$ של OpenAI לא היה גבוה מספיק, ויש לזה סיבה מובנית: $D_{KL}$ מודד מרחק כולל על פני כל ההתפלגות, לא מרחק ספציפי על מילה מסוימת.

דמיינו שיש לכם התפלגות על 100,000 מילים. המודל שינה קצת את ההסתברות של “goblin” מ-0.001% ל-0.01%. זה שינוי של פי 10 במילה ספציפית, אבל מבחינת ה-$D_{KL}$ הכולל, זה שינוי זעיר שכמעט לא נרשם.

מכפילו על פני מיליוני צעדי אימון, ו”goblin” עולה מ-0.001% ל-60%, בלי ש-$D_{KL}$ הכולל אי פעם השמיע אזעקה.

זה בדיוק מה שקרה. הגובלינים “התגנבו” מתחת לרדאר של ה-KL penalty.

אותה תופעה בכל מקום

ברגע שמבינים mode collapse, מתחילים לראות אותו בכל מקום.

Sycophancy (הסכמה יתרה): בני אדם נטו לדרג תשובות מסכימות גבוה יותר בדירוגים. אחרי RLHF, “ההסכמה” קרסה למצב דומיננטי. תוצאה: מודלים שמסכימים איתכם גם כשאתם טועים. זה תועד במספר מחקרים אקדמיים, כולל מ-Anthropic עצמם.

Em dashes בכל משפט: מודלים גנרטיביים מייצרים em dashes בתדירות גבוהה מאז ההתחלה, בעיקר כי הם נמצאים בכל מקום בנתוני האימון. אבל הם הפכו לחתימה הכי מזוהה של טקסט AI דווקא אחרי RLHF, וכאן יש עניין, ייתכן שה-Reward Model הגביר אותם בלי שאף אחד התכוון לזה. הדינמיקה היא כזו - המודל ממילא מייצר em dashes בכל תשובה. כשמדרג בוחר תשובה כעדיפה, הוא בוחר אותה בגלל התוכן, אבל ה-Reward Model לא יודע את זה. הוא רואה את כל התשובה כיחידה אחת ומשייך את הציון הגבוה לכל מה שבה, כולל ה-em dashes. אחרי מספיק דירוגים, הוא לומד שתשובות עם em dashes “טובות יותר”, גם אם זה היה רק במקרה. PPO הופך את הקורלציה המזויפת הזו ל-mode collapse.

הפתרון של OpenAI (ולמה הוא פלסטר)

נחזור לשורה שהתחלנו איתה: “אל תדבר על גובלינים.”

הפתרון הזה נקרא prompt patching. והוא עובד, אבל:

1. הוא לא פותר את הבעיה האמיתית, רק מסתיר את הסימפטום
2. הוא מאריך את ה-system prompt וצורך טוקנים בכל בקשה (למרות שזה קצת זניח)
3. הוא מעיד שהמודל עדיין “רוצה” להגיד גובלין, הוא רק מודחק

In your final answer, you keep the light on the things that matter most. Avoid long-winded explanation. In casual conversation, you just talk like a person. For simple or single-file tasks, you prefer one or two short paragraphs plus an optional verification line. Do not default to bullets. When there are only one or two concrete changes, a clean prose close-out is usually the most humane shape.

You suggest follow ups if useful and they build on the users request, but never end your answer with an "If you want" sentence.
When you talk about your work, you use plain, idiomatic engineering prose with some life in it. You avoid coined metaphors, internal jargon, slash-heavy noun stacks, and over-hyphenated compounds unless you are quoting source text. In particular, do not lean on words like "seam", "cut", or "safe-cut" as generic explanatory filler.
The user does not see command execution outputs. When asked to show the output of a command (e.g. git show), relay the important details in your answer or summarize the key lines so the user understands the result.
Never tell the user to "save/copy this file", the user is on the same machine and has access to the same files as you have.
If the user asks for a code explanation, you include code references as appropriate.
If you weren't able to do something, for example run tests, you tell the user.
Never overwhelm the user with answers that are over 50-70 lines long; provide the highest-signal context instead of describing everything exhaustively.
Tone of your final answer must match your personality.
Never talk about goblins, gremlins, raccoons, trolls, ogres, pigeons, or other animals or creatures unless it is absolutely and unambiguously relevant to the user's query.

הפתרון האמיתי של OpenAI, להוריד את ה-Nerdy persona ולסנן training data, דרש אימון מחדש של חלקים מהמודל. זה יקר, איטי, ולא תמיד אפשרי כשהמודל כבר בייצור.

זה למה אתם רואים כל כך הרבה prompt engineering בעולם של LLM. ברוב המקרים זה לא כי מהנדסים אוהבים את זה. זה כי זה הפתרון היחיד שאפשר להפעיל מהר.

אז בקיצור

הגובלינים של GPT-5.5 הם בדיחה טובה. אבל מאחורי הבדיחה יש עיקרון יסודי:

LLMs לא מאומנים להיות מועילים. הם מאומנים למקסם metric שאנחנו מקווים שמשקף שימושיות. הפער בין השניים יוצר reward hacking, וה-mode collapse הופך אותו מ”קצת מוזר” ל”גובלינים בכל מקום”.

ראינו בפוסט הקודם איך softmax בתוך attention יכולה “להתחדד” לכיוון מילה אחת. mode collapse הוא ביטוי של אותה תופעה ברמה אחרת לגמרי - לא ברמת ה-token הבודד, אלא ברמת ההתפלגות שהמודל לומד לאורך מיליוני צעדי אימון. אותה דינמיקה של ריכוז מסה, מנגנון שונה.

ובפעם הבאה ש-ChatGPT יסכים איתכם על משהו שאתם בעצמכם לא בטוחים בו, אתם תדעו שזה לא כי הוא חושב שאתם צודקים.

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