Science and AI with Mike

ה-AI עזר לפתור הרגע בעיה מתמטית בת 70 שנה (החסמים של קבוע גרותנדיק), אבל הדרך מרתקת יותר מהתוצאה. חוקרים הוכיחו גבולות חדשים ומדויקים יותר ל"קבוע גרותנדיק" (וקבעו שהוא נמצא בין 1.7135 ל-1.7819 שזה מדד מתמטי שמתאר את הפער בין בעיות חישוב סופר-מורכבות לבין הגרסאות ה"מרוככות" והקלות יותר לפתרון שלהן זה לא היה כפתור קסם של "פרומפט -> פתרון". זו הייתה עבודת צוות של שנה שלמה: חוקרים אנושיים וסוכני AI. התפקיד של ה-AI: "הפועל השחור" החכם כתיבת קוד, בחינה שיטתית של אלגוריתמים והרכבת המהלכים הלוגיים. התפקיד של האדם: "טעם מחקרי" . לדעת אילו כיוונים שווים בדיקה ומתי להתערב (40 פעמים במהלך חודש של ריצת מודלים!). המסר של החוקרים מבריק: חברות ענק מציגות לעיתים קרובות את ה-AI כקוסם שלוקח את כל הקרדיט. אבל כדי לשמור על המדע "אנושי", האקדמיה חייבת לעצב את הכלים האלה כשותפים. עתיד המחקר הוא לא AI שמחליף מדענים, אלא מדענים שמשתמשים באינטואיציה שלהם כדי לנצח על תזמורת של סוכנים מלאכותיים. #איי_איי_עם_מייק

אנחנו שורפים מיליוני דולרים על אימון מודלי שפה, מפתחים ארכיטקטורות מטורפות לבלוקים הפנימיים אבל מתברר שהפשלה הכי גדולה שלנו מסתתרת דווקא בשכבה האחרונה והכי בנאלית של המודל. מאמר מלפני חצי שנה (הגרסה השנייה לפני חודש) שנסקור היופ חושף ששכבת הפלט של המודל שלנו היא לא סתם צוואר בקבוק, אלא "משמדת גרדיאנטים" סדרתית שמוחקת בין 95% ל-99% מהסיגנל של האימון! למה זה משנה לנו?עד היום, חוקרים ומפתחים התייחסו לפער הממדים: בין ממד חבוי (ייצוג פנימי של המודל) קטן יחסית מול מספר איברים ענק (מימד) של אוצר מילים (Vocabulary) כבעיה של יכולת ביטוי (אקספרסיביות). כלומר, חשבנו שהאילוץ של פונקציית הסופטמקס פשוט מונע מהמודל לייצג התפלגויות מורכבות של מילים אם המימד החבוי לא גדול מספיק. אבל המאמר הנוכחי הופך את הקערה ומוכיח שהכשל האמיתי הוא בכלל בתחום האופטימיזציה: אנחנו פשוט זורקים לפח את רוב הפידבק שהמודל אמור ללמוד ממנו. פסקת העמקה: מה קורה שם מתחת למכסה המנוע? תחשבו על תהליך הלמידה (Backprop). כשהמודל טועה, הוא מחשב את שגיאת החיזוי שלו במרחב הלוג'יטים שהוא בגודל של כל אוצר המילים שזה מרחב בעל עשרות רבות (יש כאלו מעל מאה) אלפי ממדים. אבל כדי שהשגיאה הזו תחזור אחורה אל תוך הרשת ותעדכן את המשקולות, היא חייבת לעבור דרך שכבת הפלט אל הממד החבוי שהוא קטן משמעותית (למשל 4,096 ). המעבר הזה מאלץ דחיסה אגרסיבית שמוחקת כמעט את כל הגרדיאנט. זה בערך כמו לנסות לדחוף זרם של צינור כיבוי אש דרך קש של טרופית. כדי להוכיח שזו נטו בעיית אופטימיזציה, החוקרים יצרו שפה סינתטית בשם SpamLang. החוקיות שלה? פשוט לחזור על אותו טוקן שוב ושוב לכל אורך הרצף. מודלים אמורים ללמוד את זה מתוך שינה ויש להם את כל ה-Expressivity הדרוש לכך. אבל הנה הפאנץ': ככל שהגדילו את אוצר המילים והשאירו את המימד החבוי קבוע, המודל פשוט קרס ולא הצליח ללמוד את התבנית הכי מטופשת בעולם, כי הפידבק נמחץ לחלוטין בדרך חזרה. ולאן הולך כל המידע שאבד בדחיסה הזו? מסתבר שהוא מומר לרעש שמבלבל את המודל. החוקרים הראו שכשהמודל אמור לקבל פידבק שאומר לו שהמילה הבאה היא "Wayne" (כמו ג'ון וויין), הגרדיאנט המעוות מעביר בטעות חלק מהסיגנל למילים לא קשורות בעליל, כמו "Rooney" (הכדורגלן וויין רוני) או "Detroit" (בגלל מחוז וויין במישיגן). במקום לקבל כיוון עדכון מדויק, המודל מקבל סלט של משמעויות. התוצאה בשטח?בניסויים על מודלים של 2 מיליארד פרמטרים התגלה שככל שצוואר הבקבוק צר יותר, המודל מתכנס הרבה יותר לאט: עד פי 16! סיכומון של מייק :הדחיסה של הגרדיאנט אל המימד החבוי משמידה מעל 95% מסיגנל האימון. כדי לאמן מודלים מהר יותר, התעשייה חייבת להפסיק להתעלם מבעיית האופטימיזציה של ה-LM Head (השכבה האחרונה) ולהתחיל להנדס לו חלופות. #אייאיי_עם_מייק

אני מדי פעם מפרסם הודעות לחיפוש עבודה מחברות שאני מכיר באופן אישי. והנה מגיע תור של orion security שייעצתי להם בעבר ומלווה אותם בהדיקות היום. החברה מבוססת היטב וצומחת בקצב פסיכי: ML Team Lead What you'll actually do? Lead, mentor, and grow a multidisciplinary team composed of Data Scientists, Data Analysts, and DLP Analysts.Define and lead the team's technical vision and execution strategy, driving technical excellence and ensuring alignment with business priorities and product objectives.Oversee the design, development, validation, and deployment of advanced machine learning solutions for customer-facing products.Hands-on ownership of current AI services.Establish and enforce best practices for model development, experimentation, evaluation, documentation, and code quality.Collaborate closely with Product Managers, Data Engineers, Software Engineers, and domain experts to translate business challenges into scalable ML solutions.Drive execution and delivery, balancing innovation, technical quality, and time-to-market considerations.Promote operational excellence by improving the reliability, scalability, and maintainability of production machine learning systems.Establish scalable engineering processes, workflows, and best practices.Lead the team transformation from an early-stage organisation into a mature, production-grade AI engineering team. מי שמעוניין ועומד בדרישות שלחו cv בפרטי. תודה!

חברות ה-AI הגדולות היו בטוחות שהן הצליחו לנעול את ה"מחשבות" של המודלים שלהן בכספת. תחשבו שוב! המאמר חדש בעל שם קליט Stealing Reasoning Traces from Proprietary LLM APIs חושף פריצת אבטחה ארכיטקטונית שמפרקת את האשליה הזו לחלוטין. כדי למנוע ממתחרים לגנוב את תהליך החשיבה שלהם לצורך אימון מודלים מתחרים בתהליך של דיסטילציה, מודלים כמו Opus או GPT-5.6 מצפינים את שרשרת המחשבה (Chain-of-thought או CoT) ושולחים אותה ללקוח בתור בלוק אטום של טקסט. למה אלינו? כי API הוא חסר-מצב (stateless) והחברות לא רוצות לאחסן את כל המידע הזה אצלן בשרתים, אז הן דורשות מהלקוח לשלוח את הבלוק המוצפן חזרה בכל בקשה עוקבת. מתברר שהבלוקים הללו תואמים וניתנים להעברה בין שיחות (Sessions), בין משתמשים, ואפילו בין מודלים שונים מאותה משפחה. פסקת העמקה: פענוח דרך מודל חלש כאן מגיע הפאנץ' ההנדסי. מודל חזק ויקר מוגן היטב על ידי מנגנוני בטיחות ייעודיים שנועדו למנוע ממנו להדליף את שרשרת החשיבה שלו. אבל אם לוקחים את הבלוק המוצפן שלו, ומזריקים אותו לתוך חלון ההקשר של מודל הרבה יותר חלש וזול (כמו Haiku), אפשר לעקוף את ההגנות האלו לחלוטין. המודל הקטן מתייחס לבלוק התואם כאילו הוא היה החשיבה של עצמו. בעזרת עקיפת מנגנוני הגנה (Jailbreak) פשוטה, החוקרים הכריחו את המודל החלש לתמלל את המידע החסוי החוצה, טוקן אחר טוקן. ככה, בלי להתעמת ישירות עם המודל המתקדם, המודל הקטן הופך לאורקל פענוח שעושה עבור התוקף את העבודה. למה זה כזה אסון טכנולוגי ופרקטי? מעבר לסכנה של גניבת קניין רוחני, יש כאן חור אבטחה מטורף ברמת המשתמש. מפתחים משתפים לוגי פעילות של הסוכנים שלהם ברשת כל הזמן, והם כלל לא מודעים לכך שיש בתוכם בלוקים מוצפנים מלאים במידע רגיש. החוקרים סרקו 315 אלף בלוקים כאלה ממאגרים ציבוריים, וחילצו מתוכם מאות סודות שהמודל חשב עליהם בטעות במהלך העבודה: מפתחות גישה (API keys), סיסמאות של משתמשים ומידע אישי רגיש. מסתבר שלהפוך את הלקוח למכונת אחסון חינמית זה קצת כמו לתת לו לשמור על מפתחות הכספת בלי לומר לו מה זה. 💡סיכומון של מייק: ארכיטקטורה חסרת-מצב שזורקת את ניהול הזיכרון על הלקוח אולי חוסכת בעלויות ענן, אבל היא יוצרת משטח תקיפה חמור; כשאפשר להעביר טוקנים מוצפנים בין מודל חלש לחזק, כל ההגנות של המודל המוביל קורסות כמו מגדל קלפים, ומסכנות את המידע הפרטי של כולנו. #איי_איי_עם_מייק

בינה מלאכותית התקרבה לראשונה לאחת משתי השאלות הפתוחות המפורסמות במתמטיקה (השנייה היא P עפ NP). התקרב. לא פתר. הסיפור בקצרה. ב-1859 רימן ניחש ניחוש: לפונקציה מסוימת יש אינסוף נקודות מיוחדות, וכולן לדעתו יושבות על קו ישר אחד. 167 שנה אף אחד לא הצליח להוכיח את זה. הניחוש הזה שווה מיליון דולר. כשלא מצליחים להוכיח "כולן", מוכיחים "לפחות אחוז מסוים מהן". האחוז הזה תקוע שנים על 41.66%. קלוד, גרסת מחקר שעדיין לא שוחררה, הביא אותו ל-67.25%. להשוואה: בני אדם הצליחו להזיז אותו 0.8 נקודות ב-37 שנה. זו קפיצה אמיתית. אבל היא לא "שני שליש מהדרך", ומשתי סיבות: סיבה ראשונה: האחוז מודד אותנו, לא את המתמטיקה. 67% לא אומר ששני שליש מהנקודות על הקו והשאר מחוצה לו. בפועל בדקו כבר 20 טריליון נקודות ואף אחת לא חרגה. כולם משוכנעים שהתשובה היא כל הנקודות. פשוט אין הוכחה. סיבה שנייה: אפילו 100% לא היה מוכיח את הניחוש. נשמע מוזר, אז דוגמה. קחו את כל המספרים, ומתוכם רק את 10, 100, 1000, 10000... יש אינסוף כאלה. ובכל זאת, אם תספרו כמה אחוז הם מכל המספרים, תקבלו כמעט אפס. הם דלילים מדי מכדי להירשם. עכשיו החזרה לענייננו: גם אם נוכיח "100% מהנקודות על הקו", עדיין יכולים להסתובב שם אינסוף חריגים. פשוט דלילים מדי מכדי להוריד את האחוז. לכן הפער בין 67% למיליון דולר הוא לא 33 נקודות אחוז. זו שאלה אחרת לגמרי. אנטרופיק אומרים את זה בעצמם: הם לא מצפים שהשיטה תגיע להוכחה. ומה כן קרה כאן, בעיניי: קלוד לא המציא מתמטיקה. הוא לקח מאמר מ-2000 וחיבר אותו לעבודה עדכנית של ארבעה חוקרים. מישהו כבר הגיע ל-67% קודם אבל רק בהנחה נוספת. כאן ההנחה ירדה. שני החלקים ישבו על המדף שנים, בשני חדרים שונים, ואף אחד לא הכניס אותם לאותו חדר. כלומר: מה שחסר לא היה גאונות. מה שחסר היה מישהו שקרא הכל. מה עוד לא סגור: אין ביקורת עמיתים רגילה, ואי אפשר לשחזר את הריצה כי המודל לא שוחרר. מצד שני ההוכחה נכתבה בצורה שמחשב יכול לבדוק, ושני מומחים חיצוניים עברו עליה. על התהליך אפשר להתווכח. על ההוכחה עצמה פחות. ולסיום, הפרט האהוב עליי: הניסיון הראשון נכשל אחרי 650 רעיונות. סוף סוף AI שחווה דוקטורט אמיתי.   https://www.anthropic.com/research/riemann-zeta

שמעתם פעם את הטענה שהמודלים של היום פשוט ענקיים מדי ולכן קשה לכווץ אותם? אז מאמר שנסקור היום חושף אמת די מטורפת: ככל שהמודל גדול יותר, הוא דווקא יותר דחיס. מאמר די טכני - לקח לי זמן להפנים (בתקווה הבנתי נכון).... בואו נדבר רגע על הכשל בשטח. כשאנחנו רוצים לכווץ מודל היום, אנחנו בדרך כלל משתמשים בשיטות מבוססות פרמטרים כמו Post-training quantization (PTQ). הבעיה? גודל המודל הדחוס גדל באופן ליניארי ביחס לגודל המודל, ולא משנה בכלל כמה מידע המודל באמת למד. מנגד, שיטות כמו Prequential Coding (או PC) דוחסות דרך תהליך האימון עצמו, אבל מכריחות אותנו לשמור את רצף הדאטה המדויק. התוצאה היא תשלום מופקע (בביטים שבהם נמדד גודל המודל הדחוס) על האנטרופיה של דאטה טהור כלומר רעש אקראי בדאטה שאי אפשר באמת ללמוד במקום על המידע שהמודל באמת שמר. קצת רקע על PC: במקום לדחוס את הפרמטרים של המודל, PC דוחס אותו על ידי קידוד סדרת דאטה האימון שלו צעד אחר צעד. המטרה היא לשדר מצד אחד (האנקודר) לצד השני (הדקודר) במינימום תקשורת אפשרית. במקום לשלוח משקולות כבדות או דאטה אמיתי מלא ברעש, אנחנו הופכים את האימון ל״משחק ניחושים״. בכל שלב בתהליך, האנקודר משתמש במה שהוא כבר הצליח ללמוד כדי לקודד את הבאץ' הבא, ואז מתעדכן. וכאמור הכשל המרכזי טמון בעובדה שהיא מחייבת אותנו לשמור ולשחזר את דאטה המקורי במדויק וללא שום אובדן מידע, גם אם המודל לא באמת הפיק מהם ערך חדש. כאן נכנס הפתרון: Requential Coding. מודל מורה בוחר דוגמאות אימון שנוצרו מההתפלגות של מודלים. קצת העמקה מתחת למכסה המנוע 🧠: במקום לשמור את המידע העצום של הדאטה, הקוד (המשודר בין האנדוקר לדקודר) מתעד רק איזו דוגמה המורה בחר מ״ההצעות״ שמודל הסטודנט ייצר. הטריק פה נשען על Relative Entropy Coding(או REC). אנחנו משלמים בביטים רק במקומות שבהם המורה והסטודנט לא מסכימים. אם הסטודנט מייצר בדיוק את מה שהמורה היה בוחר, העלות של העברת המידע הזה היא כמעט אפס. עוד קצת עומק הנדסי לחובבי האופטימיזציה: איך מוודאים שהמורה לא יברח רחוק מדי ויעלה לנו ביוקר? החוקרים השתמשו בטריק אלגנטי שנקרא Iso-loss projection. המורה חייב להישאר ״צעד אחד קדימה״ כדי למשוך את הסטודנט, אבל פער גדול מדי ביניהם אומר שנצטרך לשלם הרבה יותר ביטים. הפתרון? מדי פעם עושים למורה "ריסט" למצב המדויק של הסטודנט באותו רגע. לאחר מכן, מקפיאים את הסטודנט, ומאמנים את המורה קצת עד שהוא חוזר לרמת הלוס שהייתה לו קודם. התוצאה היא שהמורה עכשיו הרבה יותר קרוב לסטודנט (מה שחוסך המון ביטים בהמשך), אבל שומר על אותם ביצועים טובים שהיה. אופטימיזציה במיטבה. למה כל זה משנה? כי השיטה הזו מנתקת את הקשר המסורבל בין גודל המודל הדחוס לכמות הפרמטרים. פתאום מתגלה שמודלים גדולים יותר מתכווצים לגדלים קטנים בהרבה. הקוד מספק חסמי PAC-Bayes חסרי תקדים עבור מודלי שפה Compute-optimal עם מיליארדי פרמטרים (אציין שלא עשרות או מאות, מודלים קטנים), מנצח חסמים של PTQ אגרסיבי, ומוכיח שטקסט מכיל הרבה יותר מבנה שניתן ללמידה מאשר תמונות. בנוסף, יש פה זווית פרקטית למפתחים: איך מזהים אוברפיט? כשמאמנים במספר אפוקים, נראה שלוס האימון יורד, אבל בפועל המודל מתחיל לעשות Memorization. מכיוון שקידוד Requential מודד ״כמה המודל לומד״, הוא משמש כרדאר: ככל שחוזרים על אותו דאטה, "הקנס" על המורכבות קופץ הרבה יותר מהר מהירידה בלוס. סיכומון של מייק: הדחיסה האמיתית של מודלים היא פונקציה של מה שהם למדו בפועל. Requential Coding מאפשר לדחוס מודל בלתי תלוי בפרמטרים ובאקראיות הדאטה, ומוכיח מתמטית ופרקטית שככל שנגדיל LLMs, הם למעשה הופכים להרבה יותר ניתנים לדחיסה. #איי_איי_עם_מייק

אמר חדש ב-Science: חוקרים ביקשו ממודל AI לתכנן וירוסים שתוקפים חיידקים. ייצרו במעבדה כמעט 300 תכנונים, 16 באמת עבדו וזה שיעור הצלחה של 5%, כלומר גם למודל יש תיקיית טיוטות. הווירוסים שעבדו לא זהים לשום וירוס טבעי מוכר. והמעניין: תערובת שלהם חיסלה חיידקים שכבר פיתחו הגנה מפני הווירוס הטבעי המקורי, בזמן שתערובת טבעית לא הצליחה. לפרופורציה המודל התחיל מווירוס קיים כתבנית, לא מדף ריק. אבל זו כן הפעם הראשונה שמכונה כותבת גנום שלם שבאמת עובד. בינה מלאכותית עושה פלאים #אייאיי_עם_מייק

חוקי סקיילינג מבטיחים לנו שהמודל משתפר בצורה חלקה ככל שדוחפים לו יותר נתונים ופרמטרים. אז זהו, שזו אשליה מנחמת שגורמת לנו לשרוף מיליונים. מתחת לפני השטח, היכולות הכי מתקדמות של מודלי שפה לא נבנות בהדרגה "עדינה". הן פשוט "נדלקות" בפתאומיות גמורה, ולפעמים הופעתן תלויה במזל נטו בסיד האקראי של תחילת האימון. הכשל האמיתי בשטח הוא שחברות מבזבזות הרים של כוח חישוב וזמן יקר על איטרציות אימון ארוכות, רק מתוך תקווה שיכולות מורכבות כמו למידת In-context או השלמת תבניות (Pattern completion) יצוצו לפתע. מאמר הנסקור היום שובר את המיתוס הזה לחלוטין וחושף שאין פה שום קסם. מה שבאמת תוקע את הרשת זה צוואר בקבוק הנדסי קשוח: הקושי העצום של המודל ללמוד תבניות של Attention דלילה (Sparse Attention patterns). פסק(או)ת העמקה: מה באמת מתרחש בתוך הקופסה השחורה? 🕵️‍♂️ כדי לפצח את התעלומה, החוקרים לקחו סדרה של מודלים תחת זכוכית מגדלת וחיפשו את אותן קפיצות פתאומיות. הם גילו שברגע שיכולת חדשה מופיעה יש מאין, הדבר חופף בדיוק לשלב שבו מספר קטן של ראשי Attention מצליח להינעל על תבנית ספציפית למשימה. כדי להוכיח שזו באמת הסיבה המרכזית ולא קורלציה מקרית, הם עשו התערבות "כירורגית" פנימית לתוך המודל: הם לקחו צ'קפוינט מוקדם של מודל שעדיין היה "טיפש" ולא רכש את היכולת, והזריקו לתוכו באופן ישיר רק את מפות Attention שנלקחו ממודל שכבר פתר את הבעיה. התוצאה: היכולת החדשה קפצה והופיעה מיד במודל הישן. זה בעצם מוכיח שהידע, הייצוגים החבויים והלוגיקה כבר היו שם מזמן, אבל החיפוש העיוור אחר attention הנכונה הוא מה שתקע את המודל במישור מייאש של חוסר התקדמות (Loss plateau). כדי לאמת את התופעה הזו תחת תנאי מעבדה סטריליים, החוקרים יצרו סביבות סינתטיות ובדקו באיזה תנאים המודל פשוט קורס ומוותר. הם מצאו שהגדלת אורך ההקשר מאריכה באופן ״מעריכי״ (בערך) את הזמן שלוקח למודל למצוא את התבנית, עד כדי כך שמשימות ארוכות הופכות לבלתי אפשריות לפיצוח. יותר מזה, התברר שתבניות בעלות רמת ביניים של דלילות הן הקשות ביותר לפיצוח עבור רשתות סטנדרטיות. כאן נכנסים לתמונה הפתרונות המעשיים שיכולים לשנות את כללי המשחק. מתברר שהגדלת מספר ראשי Attention מאפשרת למודל למצוא את התבנית הרבה יותר מהר, פשוט כי יש לו יותר "סוכנים" שמגששים באפלה במקביל עד למציאת הפתרון. בנוסף, במשימות שדורשות ערבוב טוקנים מורכב וקבוע, נרשמה הפתעה: ארכיטקטורה חלופית ושונה כמו MLP-Mixer פשוט השמידה את מודל הטרנספורמר הסטנדרטי וסיימה את הלמידה מהר יותר בסדר גודל שלם. סיכומון של מייק :היכולות המתפרצות (Emergent capabilities) ב-AI אינן קסם שנוצר מעצמו כשהמודל נהיה מספיק גדול, אלא פשוט הרגע המדויק שבו הוא צולח את צוואר הבקבוק הנסתר של גילוי התבנית הנכונה. מתברר שכדי לאמן מודלים מתקדמים בצורה יעילה ומהירה יותר, ״מהנדסים חייבים לחשוב מחוץ לקופסה ולשבור פרדיגמות״. #איי_איי_עם_מייק

במשך שנים אנחנו דוחפים למודלים שלנו עוד דאטה ועוד פרמטרים ומתפללים לטוב. אבל מה אם פספסנו לגמרי ציר סקיילינג שלישי, ועל הדרך הסתמכנו על פרדיגמה שבורה של אימון מודלים גנרטיביים? חוזרים למודלי דיפוזיה (מזמן לא היו).... התרגלנו שמודלים מבוססי דיפוזיה או אוטורגרסיביים עובדים שלב-אחרי-שלב (למשל, חיזוי טוקן בודד או צעדי הסרת רעשים (Denoising). למה? כי אם נבקש מהם לייצר פלט שלם בבת אחת, המודל ינסה למצע את כל התוצאות האפשריות ונקבל עיסה מטושטשת. הפתרון עד היום היה לשבור את תהליך היצירה לחתיכות קטנות (Generation factorization בלועזית), אבל המחיר כבד: תהליך האימון לא חופף לאינפרנס (חוזים רעש שמתווסף למשל), נוצרות שגיאות נגררות, וזמן הריצה איטי להחריד. מאמר המסוקר מציע לשבור את הכללים, ולעשות תהליך מקצה לקצה אמיתי. במקום לפרק את גנרוט הם מפרקים את לולאת האימון. פסקת העמקה: הבעיה המרכזית היא התמודדות עם התפלגויות מולטימודליות המון תשובות נכונות לאותו קלט. במקום לקבל פלט מרוח שממוצע בין כולן, בגישת המידול החקרני המודל מייצר K מועמדים שונים בכל צעד אימון. משווים את כולם לנתונים האמיתיים, אבל מעבירים גרדיאנטים ומעדכנים משקלים אך ורק דרך המועמד שהיה הכי קרוב לתשובה. כך המודל לא מנסה לרצות את כולם, אלא לומד להתחייב למודים ספציפיים וחדים. ברמת ההנדסה, יש כאן הברקה אמיתית לאיך עושים לזה סקיילינג. המחקר מציג שני כיוונים: באקספלורציה קדמית (Forward XM) המודל מייצר K מועמדים לדוגמת דאטה בודדת (יקר חישובית, אבל מבטיח כיסוי מלא של כל האפשרויות). לעומת זאת, באקספלורציה אחורית (Reverse XM) המודל מייצר דוגמה אחת בלבד ומחפש את ה-K דוגמאות הכי דומות לה מתוך הדאטסט. אם בונים נכון את מנגנון החיפוש, אפשר להקפיץ את ערך ה-K לשמיים ולקבל התאמה מדויקת, כמעט בלי לשרוף כוח חישוב נוסף על יצירת עוד ועוד מועמדים. למה זה כל כך משנה את חוקי המשחק? כי עד היום התבססנו על שני צירי סקיילינג עיקריים: להגדיל את המודל או להוסיף נתונים. המחקר מראה שאקספלורציה היא למעשה ציר שלישי שמשפר ישירות את ההכללה ומונע אוברפיט. במקום סתם לזרוק עוד דאטה על הקיר ולקוות שמשהו ידבק, אנחנו מרוויחים את היכולת להמיר כוח חישוב בזמן האימון לביצועים פסיכיים ואמיתיים בשטח. בפועל, זה מתורגם לחיסכון משמעותי: שיפור של פי 4.1 פלופס, זינוק של 47% ביעילות הפרמטרים ובמשימות בקרה הושגו ביצועים של מודלי דיפוזיה מורכבים בעזרת צעד denoising קדמי בודד חיסכון של עד פי 256 בחישובי האינפרנס! 💡 סיכומון של מייק: הגישה הזו מקדמת אותנו בצורה פרקטית למודלי AI גנרטיבי שעובדים End-to-End באופן מלא. על ידי שינוי פשוט בתהליך אימון שמונע מיצוע מטושטש ומחייב את המודל למודים ברורים, מתקבל ציר סקיילינג חדש שמייעל את האימון ומפחית משמעותית את זמן האינפרנס. #אייאיי_עם_מייק

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

תמיד לימדו אותנו שהאויב הכי גדול של מודלים הוא Catastrophic Forgetting. רוב המחקר בתחום ה-Continual Learning (או למידה המשכית) מניח שהמטרה העליונה והברורה מאליה היא לגרום למודל לזכור הכל. אבל מה אם המרדף האובססיבי הזה אחרי זיכרון מושלם הוא בדיוק מה שתוקע את המערכות שלכם? מאמר חדש הופך את השולחן על הפרדיגמה הזו. עד היום, גישת ברירת המחדל הייתה Joint-Task Learning שזו אסטרטגיה שבה המודל מנסה לשמר ביצועים גבוהים על כל משימות העבר שהוא אי פעם ראה. הגישה הזו מניחה בסתר שהעתיד תמיד ייראה בדיוק כמו העבר. אבל בעולם האמיתי, הנתונים זזים ויש לנו Distribution drift (במאמר זה נקרא distributional shift) מתמיד. כשמכריחים מודל לזכור מידע ישן בסביבה שמשתנה מהר, העבר הופך למשקולת, המווה סוג של הטיה (או רגולריזציה), שמונעת הסתגלות מהירה למידע חדש. זה כמו לנסות לכתוב קוד מודרני, בזמן שהמוח שלכם מתעקש לשלב בו סינטקס של קובול (סליחה אם יש בקהל אנשים שצעירים מדי כדי לדעת מה זה קובול). בואו נצלול פנימה לעומק הטכני: החוקרים מפרקים את הדילמה הזו דרך מטריקה מעניינת שהם מכנים Transfer Efficiency. בפועל, מתנהל כאן סוג של קרב בין שני כוחות הנדסיים. מצד אחד, ללמוד משימה חדשה לגמרי מאפס גובה קנס כבד של זמן ומשאבים שמכונה Transient Error.כמובן זיכרון מהעבר מעניק לנו יתרון של Warm-start שעוזר לאופטימיזציה להמריא. מצד שני, כשהדאטה החדש כבר לא תואם לישן, הזיכרון הזה מתחיל לייצר אי יציבות שפשוט גורר את הביצועים למטה. המאמר מוכיח שיש נקודת סף, סוג של פג תוקף, שמעבריה הידע ההיסטורי מפסיק להיות יתרון והופך לנטל שמפריע לאופטימיזציה. אז איך בעצם יודעים מתי הזיכרון מתחיל לפגוע בנו? כאן החוקרים מכניסים למשוואה מדד שנקרא קצב גדילה או growth rate, שמתאר את הקצב שבו הסביבה שלנו משתנה. אם הסביבה זזה מהר (למשל התנהגות משתמשים או טרנדים שמשתנים מיום ליום) הפער בין מה שהמודל למד פעם לבין המציאות הנוכחית הופך לבלתי ניתן לגישור. הניסיון לאלץ את המשקולות של הרשת למצוא פשרה טובה גם לעבר וגם לעתיד פשוט נועד לכישלון. במצבים כאלה, אופטימיזציה שמתחילה מדף חלק מצליחה לעקוף מהר מאוד פתרונות שמנסים להישען בכוח על ידע קודם שפג תוקפו. הם מציגים כהוכחת היתכנות את אלגוריתם ה-Window , שיודע להתאים את עומק הזיכרון שלו באופן דינמי לקצב ההשתנות של הסביבה. הוא פשוט מבין לבד מתי הגיע הזמן לשחרר. 💡 סיכומון של מייק :הגיע הזמן להפסיק להתייחס לשכחה כאל מחלה שחייבים לרפא בכל מחיר. בסביבות דינמיות ומשתנות, שחרור של ידע לא רלוונטי הוא פיצ'ר הישרדותי הכרחי כדי לשמור על גמישות. במקום לאלץ את המודלים שלנו להיות אגרנים כפייתיים של דאטה היסטורי, אנחנו צריכים לתת להם את הכלים לחזות מה באמת שווה את הזיכרון שלהם. #אייאיי_עם_מייק

כולנו היינו בטוחים ש-Chain-of-Thought (או CoT בקצרה) פתר לנו את בעיית השקיפות. רציתם לדעת איך המודל הגיע לתשובה? פשוט תבקשו ממנו להסביר שלב אחר שלב. אבל מה אם נגלה לכם שמודלי שפה מסוגלים לחשוב מאחורי הגב שלנו, בעזרת טקסט ג'יבריש מוחלט? בתעשייה שלנו יש הנחת עבודה די בסיסית: כדי לפקח על מודלים ולשמור על AI Safety, אנחנו קוראים את צעדי ההיגיון שהם פולטים בטקסט. אבל החוקרים במאמר הנסקר מראים שזו תפיסה קצת נאיבית. הם חושפים תופעה מעניינת שנקראת הנמקה בלתי נראית או Invisible reasoning בלועזית. מתברר שמודלים חזקים, כמו אופוס וג'מיני, מסוגלים לבצע חישובים ולקבל החלטות גם כשהם מייצרים טקסט שהוא לכאורה חסר משמעות. החוקרים לקחו משימות שדורשות חשיבה ״עמוקה״, כמו כפל של מספרים ארוכים או ספירת משתנים בקטעי קוד. במקום לתת למודל לכתוב CoT טבעי וקריא, הם דחפו לו לקונטקסט טוקני Filler שזה סדרות קבועות וחסרי משמעות לחלוטין עבור הבעיה הספציפית, כמו רשימת חיות, שמות של צבעים, או פשוט המילה "pause" שחוזרת על עצמה שוב ושוב. התוצאה? המודלים רשמו זינוק של עד 13 אחוזים בדיוק. המודל פשוט ניצל את "הנפח" של הטוקנים המיותרים האלה כדי לעשות את החישובים האמיתיים שלו מתחת למכסה המנוע. זה ממש לא מסתכם בזה שהמודל מקבל "יותר זמן לחשוב". ניתוח מכניסטי שעשו החוקרים גילה שהקסם קורה עמוק במרחב הלטנטי. ה-Forward pass של המודל (כלומר גנרוט) מתייחס לטוקנים האקראיים האלו כמעין טיוטת עבודה פנימית. הייצוגים של הטוקנים הללו מתחילים להתעצב כבר בשכבות הרדודות (בהתחלה) של הרשת, ומנגנון ה-Attention שואב מהם מידע שרלוונטי (משקלי attention גבוהים) לפתרון המשימה. יותר מזה, החוקרים הוכיחו שבעזרת טוקני ה-Filler, המודל יכול במקביל לספק ״יעד חבוי ( Hidden goals) כמו לבדוק בסתר תנאים מתמטיים מורכבים על התשובה הסופית מבלי להשאיר אף סימון (עקבה) בטקסט שהמשתמש קורא. ולמה שזה יעניין אותנו כמפתחים? כי יש פה תמריץ ״כלכלי״ עצום. להריץ אינפרנס בשלב ה-Decode (גנרוט טוקנים חדשים) זה עסק יקר שמוגבל על ידי רוחב פס של זיכרון (vram), לעומת שלב ה-Prefill שהוא הרבה יותר יעיל וזול. מודל שמסוגל לעשות את החישובים שלו על גבי טוקנים קיימים וריקים, במקום לייצר מגילת הסברים, יחסוך לחברות המון כסף. החוקרים אפילו הראו שכשמנסים לאמן מודלים בעזרת שיטות RL להסתיר מידע, הם לומדים להשתמש במילים תמימות כמו "wait" או "however" בתוך הטקסט הטבעי כדי לאותת לעצמם ולעקוף מנגנוני פיקוח. סיכומון של מייק: החוקים השתנו. להסתמך רק על טקסט הפלט כדי לנטר את תהליך החשיבה של מודלים זה פשוט כבר לא מספיק. מודלי שפה יכולים לבצע עבודת עיבוד סמויה ומשמעותית מבלי להדפיס אף מילה רלוונטית אחת. אולי העתיד של אבטחת AI יחייב אותנו לנטר את האקטיבציות הפנימיות עצמן, אחרת אנחנו פשוט נמשיך לקרוא רק את מה שהמודל רוצה שנראה. #אייאיי_עם_מייק

תפסיקו למדוד משקלים, הם משקרים לכם. 🛑 רובנו עדיין חושבים שמשקל גבוה אומר שהנוירון חשוב, אבל דיפמיינד הרגע פרסמו מאמר שמוכיח עד כמה הגישה הזו שבורה, ומציעים פתרון שמשנה לחלוטין את כל מה שידענו על דחיסת מודלים. כשאנחנו מנסים לכיווץ מודלים (Pruning), הגישה הקלאסית והפשוטה היא להסתכל על הגודל של המשקלים כאינדיקציה לחשיבות שלהם. אבל הנה הכשל האמיתי בשטח: בגלל מנגנונים בסיסיים כמו BatchNorm, המספרים האלה הם לרוב סתם תופעת לוואי של תהליך האופטימיזציה. נוירון יכול להיות עם משקלים עצומים ועדיין להיות כמעט חסר משמעות לתוצאה הסופית, פשוט כי המודל "משחק" איתנו עם הסקאלות ומנרמל אותן רגע אחרי. 🔬כאן נכנס לתמונה הפריימוורק החדש – HOPE (Hilbert Operator for Progressive Encoding)(נותן תקווה עם הילברט) במקום להסתכל על הפרמטרים הפיזיים, החוקרים מעבירים את הניתוח למרחב רציף, ומתייחסים לכל נוירון כפונקציה מתמטית בתוך מרחב הילברט (Rank-1 operator). הפאנץ'? המערכת עובדת לחלוטין בתצורת Data-free. בעזרת הסטטיסטיקות שכבר קיימות ב-BatchNorm, הם מייצרים התפלגות וירטואלית מדויקת מבלי להעביר דאטה אמיתי אחד דרך הרשת. המעבר הזה מאפשר לאחד פעולות של Pruning ו-Merging תחת אותה מטריה של הטלה לתת מרחב, כך שנוירונים כפולים פשוט מתמזגים בצורה חלקה לתוך נוירון ״אבא״(או אמא איך שאתם רוצים) אחד יעיל. 🧠 פסקת העמקה: אז איך זה פותר את כאב הראש של פיינטיון? עד היום, הגישות לאימון מחדש היו בעייתיות: או שמקפיאים הכל והמודל נוקשה מדי, או שמאמנים הכל והוא מאבד ידע קודם (Catastrophic forgetting). בעזרת המדידה של HOPE, המערכת מפעילה אלגוריתם (DEFT) שחותך את הרשת לשניים: ה-Frozen Core (הנוירונים החזקים שסוחבים את הידע הישן) וה-Plastic Slack (הנוירונים החלשים שאפשר "למחזר"). אבל הנה הקסם ההנדסי: כדי שהמידע החדש לא ירעיל את הישן, המערכת משתמשת במסכה שממש חותך פיזית את החיבורים מה-Slack אל ה-Core רגע לפני האימון. זה אומר שאפשר להזרים גרדיאנטים אגרסיביים ומידע חדש לתוך האזורים הגמישים, בזמן שליבת הידע המקורית יושבת בבועה מוגנת לחלוטין, עם אפס זליגת רעש. 💡 סיכומון של מייק: HOPE מוכיח שכדי באמת לכווץ ולאמן רשתות ניורונים בצורה חכמה, אנחנו חייבים להפסיק לספור משקלים בדידים ולהתחיל למדוד את ההשפעה הפונקציונלית שלהם. תחום דחיסת המודלים עשה הרגע קפיצת מדרגה מניחושים סטטיסטיים להנדסת תוכנה כירורגית. #אייאיי_עם_מייק

תחשבו על זה רגע: רוב סוכני ה-AI שלנו היום הם או היפראקטיביים שבוהים בטלוויזיה עם רעש סטטי, או עצלנים שמתחבאים בחדר חשוך. למה? כי פונקציות המטרה שלנו ללמידה, או חיפוש אינסופי של Novelty, או צמצום טעויות חיזוי (Free-energy, מזעור אנטרופיה) פשוט שבורות. מאמר חדש ומבריק מפרק את הפרדיגמה הזו ומשנה את חוקי המשחק לגבי איך מודלים חוקרים ולומדים. הבעיה האמיתית בשטח היא שפונקציות המטרה קלאסיות לא מבדילות בין מידע חדש שאשכרה אפשר ללמוד ממנו, לבין רעש טהור ואקראי. סוכן שמחפש רק הפתעות נתקע על "רעש לבן" (כמו טלוויזיה מקולקלת) כי זה תמיד חדש ומפתיע, ולעומתו, סוכן שמנסה למזער טעויות פשוט נשאר בפינה חשוכה שבה שום דבר לא קורה, כי הכי קל לחזות את הכלום. 2 הגישות נכשלות כי הן מתייחסות להפתעה כאל בלוק אחד, במקום להפריד בין מה שהמודל יכול להפוך לידע, לבין מה שלעולם לא נוכל ללמוד. כאן בדיוק נכנס המושג של Learnable Novelty(חדשנות שניתן ללמוד). במקום סתם לחפש דברים חדשים, המטרה היא למקסם רק את כמות המבנה שאפשר באמת לדחוס ולהבין. אז איך עושים את זה הנדסית?(פסקאות העמקה): 🤿המושג המקורי של Epiplexity הוצג לאחרונה כמדד שמתאר כמה "מוח״(מודל) עם משאבי חישוב מוגבלים מסוגל לזקק מתוך דאטה שכבר קיים בידיו. הבעיה? המדידה המקורית דרשה לאמן רשת נוירונים שלמה מאפס עבור כל מערכת שרוצים לבדוק, תהליך יקר שאי אפשר לעשות לו אופטימיזציה ישירה בגלל שאינו מעביר גרדיאנטים. כאן מגיעה פריצת הדרך של המאמר הנוכחי: החוקרים לקחו את המושג הזה והפכו אותו למשערך חכם המבוסס על Reservoir computer שהיא רשת רנדומלית קפואה לחלוטין שמחוברת לשכבת Readout (למה זה נקרא ככה, אין לי מושג) לינארית אחת בלבד(נלמדת). במקום לאמן מודל כבד לכל בדיקה, הם פותרים את הבעיה בצורה אנליטית, זולה וסגורה בעזרת רגרסיית Ridge(עם רגולריזציה). התוצאה היא פונקציית מטרה שהיא גזירה לחלוטין, מה שמאפשר לדחוף את הגרדיאנטים ישירות חזרה לתוך המערכת שמייצרת את הנתונים, ולגרום לה לייצר סדר, למידה ויצירתיות לגמרי בעצמה. וכשנותנים למערכת למקסם את המדד הזה, הקסם פשוט קורה לבד, סוג של (לגמרי Unsupervised): ה-Exploration (ב-RL): כדי שהסוכן ימשיך לקבל את ה"פרס" שלו, הוא לא יכול סתם לעמוד במקום (משעמם) והוא לא יכול לקפוץ לתוך סופה אקראית (רועש מדי ולכן לא נלמד). הוא חייב לחפש אקטיבית סביבות חדשות שיש בהן חוקיות שעוד לא פוענחה וזה בדיוק מה שמייצר חקר אמיתי ואדפטיבי בסביבה. ה-Abstraction (בלמידה ייצוגים): כשהמודל מנסה לקודד תמונה כדי למקסם את המדד הזה, הוא חייב לזרוק החוצה פיקסלים רנדומליים ומידע רקע מיותר, ולשמור רק את התכונות החזקות והמובהקות ביותר. התוצאה הספונטנית של זה היא הפשטה – המודל מפריד בעצמו בין הספרות השונות למרות שלא ראה שום תווית. ה- Complexity (במערכות דינמיות): מערכת שממקסמת את המדד הזה תברח ממצבים של סדר מוחלט (כי אין מה ללמוד) ומכאוס מוחלט (כי אי אפשר ללמוד ממנו), ותתייצב בדיוק על קו התפר. שם בדיוק נוצרות תבניות מורכבות שנעות ויוצרות אינטראקציה אחת עם השנייה. המדהים הוא שעד היום, כל אחד מהתחומים האלה נחקר בנפרד לגמרי, עם פונקציות מטרה שונות לחלוטין. המאמר מוכיח שברגע ששמים במרכז מערכת עם משאבים מוגבלים שמנסה לסחוט כמה שיותר סדר ומשמעות מהסביבה – סקרנות, קידוד מופשט ומורכבות הם בעצם רק תופעות לוואי שנובעות מאותה משוואה מתמטית. 💡סיכומון של מייק: אנחנו לא צריכים מערכות שמחפשות רק את ה"שונה", אלא מערכות שמחפשות את מה שניתן ללמידה. כשאנחנו הופכים את ה-Learnable Novelty ליעד אופטימיזציה בעזרת Reservoir קל וגזיר, היכולות של חקר, קידוד מופשט וייצור מורכבות פשוט נובעות מעצמן מתוך מתמטיקה אחת. #אייאיי_עם_מייק

🛑 אנחנו מאמנים מודלי LLMs עם עין אחת עצומה, והגיע הזמן לדבר על זה. מודל שמצליח לנחש את הטוקן הבא זה נחמד, אבל מתחת למכסה המנוע, הייצוגים שלו הופכים לעצלים וקורסים לתוך עצמם. הפרדיגמה השולטת כיום בתעשייה, גישת Next-Token Prediction (או בקיצור NTP), מסתכלת רק על התוצאה הסופית במרחב הבדיד. כל עוד המודל פולט את הטוקן הנכון, אנחנו נותנים לו טפיחה על השכם וממשיכים הלאה. אבל פה בדיוק נמצא הכשל האמיתי בשטח, כי ההשגחה הזו היא דלילה מדי. בגלל שאנחנו מענישים את המודל רק על הטעות בשלב הפלט הסופי, הייצוגים החבויים שלו בתוך המרחב הלטנטי (השכבות הפנימויות של המודל) מקבלים יותר מדי חופש ופשוט מתחילים לחפף. התופעה הזו נקראת Representation degeneration (ניוון ייצוגים): הייצוגים קורסים לתוך מרחב צר, דל ומקובץ, מה שפוגע ביכולת ההכללה של המודל במשימות מורכבות בעולם האמיתי. במילים פשוטות: המודל צודק, אבל לגמרי מהסיבות הלא נכונות. 🧠 צוללים פנימה: להכריח את המודל להבין, לא רק לנחש כאן נכנס לתמונה המאמר החדש שמציג את שיטת NITP (המונח המלא הוא Next Implicit Token Prediction). במקום לתת למודל להסתפק בניחוש של הטוקם הבא בעזרת וקטור 1hot יבש, החוקרים הוסיפו לו משימה מקבילה: לחזות את המשמעות הסמנטית והרציפה של המילה הבאה. איך זה עובד בפועל בלי להוסיף רכיבים כבדים? החוקרים משתמשים בשכבות ההתחלתיות של המודל עצמו בתור עוגן סמנטי יציב. מסתבר שהשכבות הראשונות ברשת שומרות על עושר סמנטי ומילוני אדיר, רגע לפני שהשכבות העמוקות יותר דורסות אותו רק כדי לצלוח את משימת החיזוי הספציפית. שיטת NITP דורשת מהשכבה האחרונה להתיישר גיאומטרית מול הייצוג הסמנטי של הטוקן הבא, בדיוק כפי שהוא נתפס בשכבות המוקדמות של המודל. זה אילוף מושלם שמבטיח כי המרחב הלטנטי נשאר עשיר, מסודר ומקודד משמעות אמיתית, במקום סתם לשנן הסתברויות. 🔍 פינת העמקה: מה קורה שם מבחינה גיאומטרית?תחשבו על המחרב הלטנטי כעל חדר ענק. בשיטה הישנה, המודל דוחף את כל המילים לאותה הפינה (מצב הנקרא Anisotropic cone), פשוט כי אין שום עונש על צפיפות כל עוד הניחוש המילולי נכון. שיטת ה-NITP מכריחה את המודל להשתמש בכל החדר. היא מוסיפה עוגן שמפעיל לחץ כיווני ומונע מהייצוגים הפנימיים לקרוס אחד לתוך השני. הפעולה הזו מאלצת אותם לשמור על מרחק ומבנה סמנטי מובחן, כך שהמודל לא רק זוכר סטטיסטיקה, אלא ממש מבודד משמעויות שונות בתוך המרחב. 🚀 המספרים מדברים היופי פה הוא שלא צריך לשרוף חוות שרתים בשביל התענוג הזה: ביצועים: שיפור עקבי גם במודלי MoE וגם בסוגי Dense models (עד 9B פרמטרים), כולל זינוק אכזרי של 5.7% במדד MMLU-Pro. עלויות: כל הטוב הזה עולה בערך ב-2% תוספת של Training FLOPs בלבד, עם אפס תקורה בשלב האינפרנס כי ארכיטקטורת המודל נשארת זהה לחלוטין. 💡 סיכומון של מייק:הסתמכות על Next-Token Prediction לבדה משאירה את המודלים שלנו חכמים מבחוץ אבל חלולים מבפנים. הוספת רגולציה סמנטית רציפה על הייצוגים הפנימיים, בעזרת הייצוגים העשירים מהמודל עצמו, משפרת את ביצועי ה-Pre-training כמעט בחינם. #אייאיי_עם_מייק

ברמה האישית, זה סוג המחקר שאני מקווה להיכנס אליו עמוק יותר בזמן הקרוב. יש כאן מפגש נדיר בין שאלות פילולוגיות אמיתיות לבין כלים חישוביים שמתפתחים במהירות, ואני מקווה שבהמשך אצליח גם לפרסם עבודות אקדמיות בתחום הזה, לא רק סקירות וקריאות ראשונות. מימוש, גיט וכאלו החוקרים שחררו את הקוד שלהם ב-GitHub ואת מאגר הנתונים ב-Hugging Face, מה שמאפשר לכל אחד להתנסות ולחקור את הטקסטים הללו בעצמו. שיתוף פעולה כזה בין סטטיסטיקה, מקרא ומדעי המחשב מראה איך מדעי הרוח הדיגיטליים יכולים להפוך לכלי מחקר ממשי. קוד המקור: https://github.com/yonatanlou/QumranNLP מאגר הנתונים: https://huggingface.co/datasets/yonatanlou/QumranDataset קישור למאמר: https://aclanthology.org/2025.alp-1.2/

מה זה אומר בעצם? המשמעות היא שאלגוריתם ממוחשב, שמנתח מילים ומבנים לשוניים בלבד בלי להבין את התיאולוגיה או ההיסטוריה של הטקסט, הצליח לזהות באופן עצמאי הבדלים סגנוניים מובהקים בין שני חלקי המגילה. זה מחזק את הסברה המחקרית שמגילת ההודיות אינה יצירה אחידה של מחבר יחיד, אלא אסופה המורכבת משכבות ספרותיות שונות וממקורות שונים שהתמזגו יחד לאורך זמן. המודל לא רק אומר "יש שתי קבוצות". הוא מצביע על חלוקה פנימית שמזכירה את ההצעה המחקרית הקיימת, וגם משאיר מקום לרעיון של עריכה מאוחרת שניסתה לאחד חומרים שונים בתוך מגילה אחת. כיתתי, לא-כיתתי, או פשוט ז'אנר אחר? המקרה השני הוא השאלה הרחבה יותר: אילו חיבורים שייכים לעולם הכיתתי של קומראן, ואילו מגיעים ממעגלים יהודיים רחבים יותר? כדי להבין את הרקע, כדאי להסביר למה הכוונה במונח "כיתתי" (sectarian) בהקשר של קומראן. חוקרי המגילות נוהגים לחלק את החיבורים שנמצאו במערות לשתי קבוצות עיקריות: טקסטים כיתתיים: חיבורים שנכתבו על ידי חברי הכת הספציפית שחיה בקומראן (המזוהה לרוב עם האיסיים, ומכנה את עצמה במגילות בשם "עדת היחד"). טקסטים אלו משקפים את החוקים הנוקשים של הקהילה, את השקפת עולמם המיוחדת (כמו חלוקת העולם לבני אור ובני חושך), ואת התיאולוגיה הייחודית שלהם (למשל "סרך היחד" או "מגילת המלחמה"). טקסטים לא-כיתתיים: ספרות יהודית כללית של ימי הבית השני (כמו ספרי המקרא, ספר היובלים או ספר טוביה) שנשמרו בספרייה של קומראן אך לא נכתבו על ידי הכת עצמה ואינם מייצגים את אמונותיה הייחודיות. כאן התוצאה מעניינת דווקא משום שהיא לא נקייה מדי. המודל מזהה קבוצות של חיבורים כיתתיים, ובהן סרך היחד, מגילת המלחמה, הפשרים ומקצת מעשי התורה. חיבורים שנויים במחלוקת כמו "מוסר למבין" ו"רזים" מוקמו קרוב לגרעין הכיתתי, מה שמחזק את האפשרות שהם קשורים לעולמה של עדת היחד. אבל לא כל דבר מסתדר לפי החלוקה הפשוטה של כיתתי מול לא-כיתתי. יש חיבורים שמתקרבים לגרעין הכיתתי, ויש חיבורים שמתקרבים זה לזה מסיבות אחרות לגמרי. ספר טוביה, ספר היובלים, מגילת המקדש וטקסטים של "מקרא משוכתב" אינם בהכרח קרובים בגלל אותה זהות חברתית, אלא בגלל ז'אנר וסגנון. זו בעיניי אחת התוצאות החשובות במאמר. המודל לא רק מזהה "שייכות חברתית". לפעמים הוא מזהה קודם כול צורת כתיבה. לכן התשובה לשאלה "האם זה כיתתי?" אינה יכולה להיות רק כן או לא. צריך לשאול גם אם המחשב מודד רעיונות, לשון, ז'אנר, מסורת ספרותית או שילוב שלהם. מה בן-דב מדגיש מעבר למספרים? בהרצאות של פרופ' יונתן בן-דב על העבודה הזו, הנקודה המעניינת אינה רק "המחשב הצליח" או "המחשב לא הצליח". במקרה של מגילת ההודיות, לפי בן-דב, התוצאה הייתה מרשימה במיוחד: המודל נכנס לאזור של ויכוח פילולוגי ותיק וזיהה הפרדה ברורה בין מזמורי המורה לבין מזמורי העדה. לעומת זאת, בשאלת המגילות הכיתתיות התמונה פחות חדה: המחשב מזהה דפוסים, אבל לא תמיד ברור אם הם משקפים שייכות חברתית, ז'אנר, סגנון או קרבה לשונית. כאן הדימוי של בן-דב למחשב כ"גולם" עובד היטב. הוא חזק ומהיר, אבל זקוק להכוונה: צריך לומר לו מהו טקסט, איך להפוך אותו לנתונים, אילו תכונות למדוד, ואיך לפרש את התוצאה. במדעי המחשב דיוק יכול להיות הישג בפני עצמו. במדעי הרוח הוא חייב לחזור אל שאלה פרשנית. לכן המילה האחרונה נשארת אצל המחקר הפילולוגי-טקסטואלי. המחשב יכול להאיר אזור חשוך. הוא לא מחליף את הקריאה. איפה צריך להיזהר? המאמר אינו טוען שהמודל מחליף חוקרים. הוא מראה למה צריך לשלב בין חישוב לבין מומחיות אנושית. יש כאן כמה מגבלות ברורות: המגילות מקוטעות מאוד, וחלק מהטקסטים נשמרו בצורה חלקית בלבד. התוויות המשמשות להערכה - למשל "כיתתי" או "לא-כיתתי" - הן תוויות מחקריות, לא אמת מוחלטת. חלק מהחיבורים מפוזרים מאוד מבחינה סגנונית, ולכן ממוצע אחד לכל חיבור עלול להטעות. המודל עובד עם מה שיש: קורפוס אלקטרוני קיים, תעתיקים קיימים, ושחזורים קיימים. כל שינוי עתידי במהדורות הטקסט יכול לשנות מעט את התמונה. לכן צריך לקרוא את התוצאות כהצעה מחקרית חזקה, לא כפסק דין סופי. המודל יכול להצביע על דפוסים, לקרב חיבורים ולהבליט חריגים. הוא לא אומר לבדו מי כתב מה. הזווית של שמוליק מה שאני אוהב במאמר הזה הוא שהוא לא נופל לפנטזיה הפשוטה של "מודל גדול יפתור הכול". אחת המסקנות החזקות היא ש-BERT לבדו לא מספיק. דווקא החיבור בין מודל שפה, סטטיסטיקה בסיסית וגרף הוא מה שמייצר את התוצאה החזקה. זו בעיניי תזכורת טובה למדעי הרוח הדיגיטליים בכלל. כשעובדים עם טקסטים עתיקים, השאלה אינה רק איזה מודל הכי מתקדם, אלא איזה ייצוג מתאים לשפה, לקורפוס ולבעיה המחקרית.

סקירות עומק חוזרות, סקירה מס 614 עם שותפי הנאמן שמוליק - 410 סקירות עד 1024 לפצל את השברים: בינה מלאכותית ומגילות קומראן המאמר היומי של שמוליק ומייק: סקירה 614, 410 סקירות עד 1024 Integrating Semantic and Statistical Features for Authorial Clustering of Qumran סקירה של מאמר כחול לבן, משותפת מס' 5 עם שמוליק שתמיד כיף לשתף כוחות איתו. גם לא יוצא לי הרבה (אם בכלל) לסקור מאמרים הקשורים לטקסטים דתיים (פותח אפיקים ללא ספק). אחד התחומים המרתקים ביותר כיום הוא מדעי הרוח הדיגיטליים: המפגש שבין טקסטים עתיקים, שאלות היסטוריות וכלים חישוביים מודרניים. המאמר של היום מציג דוגמה מצוינת לשילוב עדין בין מומחיות פילולוגית לבין כלי עיבוד שפה מתקדמים. יונתן לוריא, פרופ' יונתן בן-דב ופרופ' רודד שרן מאוניברסיטת תל אביב מתמודדים עם אחת המשימות המורכבות בחקר מגילות מדבר יהודה: כיצד לסווג ולנתח חיבורים מקוטעים, עתיקים ולא אחידים, השמורים לעיתים רק כשברי טקסט קטנים. דמיינו פאזל של 10,000 חלקים שרובו אבד. מה שנשאר קרוע, חלקי, נטול ניקוד ובעל כתיב לא אחיד. כדי להרגיש את החומר, הנה חידה קטנה: איזה מהקטעים הבאים לקורפוס המגילות נשמע לכם הכי "כיתתי" (שייך לכת קומראן)? א. לדרוש אל בכול לב ובכול נפש לעשות הטוב והישר לפניו... ולעשות אמת וצדקה ומשפט בארץ ב. ראשית משלוח יד בני אור להחל בגורל בני חושך בחיל בליעל... ג. וכאשר שלמו להמה ארבעת עשר ימי החתנה... שלחני... והלכתי אל אבי התשובות: הראשון הוא מ"סרך היחד", השני מ"מגילת המלחמה", והשלישי מ"ספר טוביה". בקריאה אנושית קל להבחין שהשניים הראשונים משתמשים בעולם מושגים ייחודי (ברית, בני אור, בליעל, מאבק קוסמי). השאלה היא האם מחשב מסוגל לזהות דפוסים כאלה בצורה שיטתית, גם בטקסטים מקוטעים. איך זה עובד בפועל? החוקרים מתחילים מתעתיקי המגילות של מרטין אבג (חוקר מוביל שהכין את תעתיקי המגילות הדיגיטליים), מנקים את הטקסט ומחלקים אותו למקטעים של 100 מילים עם חפיפה של 15 מילים (978 מקטעים בסך הכל). לכל מקטע מופקים שני סוגי מידע: מידע סמנטי: ייצוג שהופק ממודל BEREL, מודל שפה ממשפחת BERT שאומן מאפס על קורפוס ענק של עברית רבנית. עברית רבנית (לשון חז"ל) אינה זהה לעברית של המגילות, אך היא מייצגת רובד לשוני היסטורי שקרוב אליהן בהרבה מאשר העברית המודרנית. מידע סטטיסטי: מאפיינים כמו tf-idf (חשיבות המילים) וטריגרמות של תווים (הלוכדות דפוסי כתיב ומורפולוגיה). החלק החכם הוא החיבור ביניהם. החוקרים בונים גרף שבו כל מקטע הוא צומת, והקשתות נוצרות לפי הדמיון הסטטיסטי. אחר כך הם מאמנים GNN שלומד ייצוג חדש לכל מקטע, כזה שמנסה לשמר גם משמעות סמנטית וגם את מבנה הקשרים בגרף. למה זה מעניין וכיצד מודדים את ההצלחה? במגילות קומראן השפה עצמה היא חלק מהאתגר: מודל שפה מודרני מתקשה להתמודד עם כתיב עתיק וטקסט מקוטע. דווקא שיטות סטטיסטיות "פשוטות" משלימות אותו מצוין. כדי לבחון את המודל, החוקרים קיבצו (קליסטרו) את המקטעים באופן אוטומטי והשוו את התוצאות לחלוקה ההיסטורית הידועה לנו באמצעות שני מדדים: מדד ג'אקארד): בודק את מידת החפיפה בין הקבוצות שהמחשב הציע לבין החלוקה האמיתית של המגילות (בטווח של 0 עד 1). מדד דאסגופטה (Dasgupta): מודד עד כמה המודל מצליח לשמור על קטעי טקסט עוקבים מאותה מגילה קרובים זה לזה בעץ ההיררכי. החוקרים השוו את הביצועים של המודל המשולב שלהם (GNN) מול מודלים שהשתמשו במידע חלקי בלבד: רק ייצוג סמנטי (של BEREL או AlephBERT) או רק מאפיינים סטטיסטיים (כמו tf-idf). התוצאות הראו שהשילוב של השניים בתוך גרף (GNN) הניב ציונים גבוהים משמעותית בכל המדדים בהשוואה לכל אחת מהשיטות בנפרד (כפי שניתן לראות באיור התוצאות). כדי לוודא שההצלחה אינה מקרית או ייחודית לקומראן, הם ביצעו בדיקה דומה על טקסט המקרא (תנ"ך עברי) וקיבלו תוצאות עקביות. מזמורי המורה במגילת ההודיות אחד ממקרי הבוחן המרכזיים הוא מגילת ההודיות (מגילה המכילה שירי הודיה ותפילה), ובפרט השאלה האם יש בה קבוצה מובחנת של "מזמורי המורה". במשך שנים חוקרים דנו בשאלה האם יש במגילה הבדל ממשי בין מזמורי המורה (שירים המיוחסים למנהיג הרוחני של הכת, "מורה הצדק", ומאופיינים בנימה אישית של רדיפה, סבל והתגלות אלוהית) לבין מזמורי העדה (שירים המבטאים את הקול הקיבוצי של הקהילה ועוסקים ברעיונות תיאולוגיים כלליים יותר). כאן המודל נותן תמיכה מעניינת בחלוקה המסורתית. מזמורי המורה מתרכזים בעיקר בעמודות 10-16, ואילו מזמורי העדה מופיעים כקבוצה אחרת. החלקים הסמוכים אינם נעלמים לתוך אחת הקבוצות בצורה נקייה, אלא נראים כמו חומר מעבר. בעיניי זו תוצאה יפה דווקא משום שהיא אינה "מסדרת" את הטקסט יותר מדי. היא משמרת את האזור האפור שהחוקרים ממילא מכירים מן הקריאה הפילולוגית.

😎 הסקירות חוזרות! תפסיקו להאשים את הפיינטיון שלכם בזה שהמודל "טיפש". הוא לא ״איבד או שכח״ את הדאטה שדחפתם לו, הוא פשוט לא יודע לאן להעביר אותו. מאמר חדש ומרתק חושף למה LLMs זוכרים עובדות בצורה מושלמת, אבל נכשלים לחלוטין ברגע שצריך באמת להשתמש בהן. כולנו מכירים את הכשל הזה מהשטח: אנחנו עושים פיינטיון למודל כדי ללמד אותו ידע ארגוני חדש או עובדות ספציפיות. בשלב הראשון, המודל מגיע לממוריזציה כמעט מושלמת. אם נשאל אותו ישירות על העובדה, הוא ידקלם אותה בדיוק מרשים. אבל ברגע שנבקש ממנו לבצע משימת מורכבת שדורשת ריזונינג מולתי-שלבי (למשל, לחבר את העובדה הזו עם עובדה אחרת כדי להסיק מסקנה חדשה), הוא קורס, מגמגם או הוזה. הפער המתסכל הזה קיבל עכשיו שם רשמי: Knowing-Using Gap. אז למה זה קורה ואיך מתקנים את זה? (פסקת העמקה 🧠) החוקרים לא עצרו בתיאור הבעיה, אלא צללו לתוך הקרביים של המודל עם טכניקת התערבות חדשה בשם Self-patching. במקום רק למדוד את הפלט, הם לקחו ייצוגים פנימיים של מידע והזיזו אותם באופן אקטיבי בין שכבות שונות בזמן הריצה כדי לראות איפה הידע "נתקע". המסקנה שלהם משנה את צורת החשיבה שלנו: הבעיה היא לחלוטין לא קיבולת. המידע נמצא שם! הוא פשוט נשמר בשכבות מוקדמות או מאוחרות מדי, ולא מנותב פנימה אל ה-Mid-layers – שזה בדיוק האזור שבו מתבצעים תהליכי הריזונינג האמיתיים של המודל. זה קצת כמו להוריד עדכון תוכנה קריטי, אבל לשמור אותו בתיקיית ההורדות במקום להתקין אותו איפה שהמערכת באמת רצה. ברגע שהחוקרים התערבו ידנית וביצעו Routing של אותם הייצוגים לשכבות הנכונות, המודל פתאום "נזכר" איך לחשוב. החדשות הטובות למהנדסים ולמפתחים שבינינו? מתוך התגלית הזו הם הצליחו לפתח יוריסטיקה פשוטה וקבוע שמנצל את הארכיטקטורה הזו, ומצליח לשחזר בין 58% ל-75% מהיכולת האבודה של המודל, וזה מבלי להזדקק לחיפוש ידני כבד עבור כל פרומפט מחדש. 💡סיכומון של מייק: הכשל בהזרקת ידע למודלים גדולים הוא לא בעיית אחסון, אלא לחלוטין בעיית Routing. כשאתם מאמנים מודל על דאטה חדש, האתגר האמיתי של התעשייה יהיה לא רק לדחוף את המידע פנימה אל המשקלים, אלא לוודא שיש Alignment למעגלי החישוב שלו. בפעם הבאה שהמודל שלכם נופל בלוגיקה פשוטה על ידע שאך הרגע לימדתם אותו, תזכרו - הוא יודע את התשובה, הוא פשוט מסתכל במקום הלא נכון. #אייאיי_עם_מייק

הודעה על משרה סופר מעניינות (לא אומר זאת הרבה - זו חברה שאין הרבה דומיה). אני גם מייעץ להם: Truelogic AI מגייסת Senior Applied Researcher לפיתוח מערכות AI מתקדמות המבוססות על LLMs, Neurosymbolic AI, ‏Multi-Agent Workflows ו-Knowledge Graphs. התפקיד משלב מחקר יישומי, פיתוח Hands-on והעברת רעיונות מחקריים למערכות Production אמינות ומדידות. דרישות - תואר שני או דוקטורט במדעי המחשב או בתחום מקביל. - מעל 7 שנות ניסיון ב-Data Science או NLP. - לפחות שנתיים של ניסיון מעשי ומחקרי עם LLMs. - ניסיון בפיתוח ובהפעלת Multi-Agent Workflows ב-Production, כולל Observability, ניטור והערכה. - יכולת מחקרית ואלגוריתמית גבוהה לצד ניסיון מעשי בפיתוח מוצרים ב-production. יתרון - ניסיון עם Knowledge Graphs, בפרט RDF, ‏SPARQL ואונטולוגיות. - ניסיון ב-Neurosymbolic AI ובשילוב LLMs עם ידע מובנה. חושבים שמתאימים? שלחו קח בפרטי: Truelogic AI מגייסת Senior Applied Researcher לפיתוח מערכות AI מתקדמות המבוססות על LLMs, Neurosymbolic AI, ‏Multi-Agent Workflows ו-Knowledge Graphs. התפקיד משלב מחקר יישומי, פיתוח Hands-on והעברת רעיונות מחקריים למערכות Production אמינות ומדידות. דרישות - תואר שני או דוקטורט במדעי המחשב או בתחום מקביל. - מעל 7 שנות ניסיון ב-Data Science או NLP. - לפחות שנתיים של ניסיון מעשי ומחקרי עם LLMs. - ניסיון בפיתוח ובהפעלת Multi-Agent Workflows ב-Production, כולל Observability, ניטור והערכה. - יכולת מחקרית ואלגוריתמית גבוהה לצד ניסיון מעשי בפיתוח מוצרים ב-production. יתרון - ניסיון עם Knowledge Graphs, בפרט RDF, ‏SPARQL ואונטולוגיות. - ניסיון ב-Neurosymbolic AI ובשילוב LLMs עם ידע מובנה.