שילמתי על GPU במק שלי. במשך שנתיים כמעט לא השתמשתי בו.

MLX הוא פריימוורק קוד פתוח ל-Machine Learning שנבנה על ידי צוות המחקר של אפל.

יש בו arrays, neural networks, automatic differentiation, optimizers והרצה על CPU ו-GPU. אם עבדתם עם NumPy או PyTorch, הרבה ממנו ירגיש מוכר.

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

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

וזה אומר copies, synchronization, memory management, ועוד כמה מילים שבדרך כלל מופיעות רגע לפני שמפתח אומר: "עזוב, אני ארים EC2".

Apple Silicon עובד אחרת. ה-CPU וה-GPU משתמשים ב-Unified Memory. אותו מאגר זיכרון. MLX תוכנן מראש סביב זה.

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

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

כי במשך שנים "להריץ AI מקומית" בדרך כלל אמר אחד משלושה דברים:

1. 1זה ירוץ לאט על ה-CPU.
2. 2צריך NVIDIA.
3. 3איכשהו ביליתם את שבת עם CUDA, drivers וגרסה ספציפית של Python שאסור לאף אחד לגעת בה.

MLX מציע מסלול אחר למשתמשי Mac. פרויקטים כמו mlx-lm ו-mlx-whisper מאפשרים להריץ LLMs ו-Whisper על stack שנבנה במיוחד ל-Apple Silicon.

וזה כבר מעניין לא רק אנשים שאוהבים benchmarks. Local inference אומר:

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

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

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

אני נותן לו קובץ אודיו או וידאו, והוא מתמלל אותו עם גרסה של ivrit.ai ל-Whisper Large V3 Turbo, מייצר טקסט ו-SRT, ויכול גם לעשות diarization כדי להפריד בין דוברים.

במקרה הזה, הקלט היה פרק של 32 דקות.

הגרסה המקורית של הכלי השתמשה ב-faster-whisper, שרץ מעל CTranslate2. זה מנוע מצוין. על NVIDIA הוא יודע להשתמש ב-CUDA. אבל על Apple Silicon, במסלול שבו השתמשתי, הוא עבד על ה-ARM CPU.

כלומר, בזמן שאני מחכה לתמלול של פרק שלם, ה-GPU במק שלי כמעט לא משתתף במשחק.

אז שאלתי את השאלה המתבקשת: מה יקרה אם אתן לו לעבוד?

הוספתי backend נוסף עם mlx-whisper וגרסת MLX של אותו מודל עברי. ואז, במקום פשוט להחליט ש-MLX "אמור" להיות מהיר יותר, נתתי לכלי להריץ את שניהם ולמדוד.

בפעם הראשונה שהכלי רץ על Mac נתמך, הוא לוקח sample של 60 שניות ומריץ אותו פעמיים:

1. 1פעם אחת עם CTranslate2.
2. 2פעם אחת עם MLX.
3. 3משווה את הזמנים.
4. 4שומר את ה-backend המהיר יותר.
5. 5ומשתמש בו בהרצות הבאות.

אם MLX לא זמין, משתמשים ב-CTranslate2. אם MLX נכשל, חוזרים ל-CTranslate2.

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

הרצתי את שני ה-backends על MacBook Pro עם Apple M5 Max, מעבד 18 ליבות ו-36GB Unified Memory. אותן 60 שניות אודיו. אותו workload. המודלים כבר היו מקומיים לפני המדידה.

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

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

לא, זה לא benchmark מדעי.

לא הוכחתי ש-MLX יהיה מהיר פי 5.81 אצלכם. לא הוכחתי שהפלט זהה מילה במילה. ולא, M1 או M2 שלכם לא בהכרח יתנו בדיוק אותו מספר.

אבל זאת גם לא השאלה. השאלה שלי הייתה: על המכונה הזאת, עבור ה-workload הזה, באיזה backend כדאי להשתמש?

חשבתי שהסיפור פה הוא MLX. אבל הוא לא.

הסיפור הוא לא לבחור backend. לפחות לא לנצח.

חומרה משתנה. ספריות משתנות. מודלים משתנים. מה שהיה נכון על M2 לא בהכרח נכון על M5. ומה שאני רואה אצלי לא בהכרח נכון אצל המשתמש שלכם.

אז במקום להקשיח משהו כזה:

Mac            = MLX
Everything else = CTranslate2

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

זה pattern שאני הולך לקחת איתי גם לדברים אחרים:

• backend נייד כברירת מחדל
• backend אופטימלי לחומרה כשאפשר
• benchmark אמיתי
• cache להחלטה
• override ידני
• fallback תמיד

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

אם אתם מפתחים על Apple Silicon ועושים משהו שקשור ל-AI: לפחות תבדקו.

• במיוחד אם ה-workload הנוכחי שלכם רץ על CPU
• במיוחד אם חשובים לכם latency, privacy או cloud cost
• ובמיוחד אם למודל שלכם כבר יש implementation טוב ב-MLX

• זה לא אומר ש-MLX מחליף CUDA
• זה לא אומר שצריך לזרוק PyTorch
• וזה בטח לא אומר שכל workload פתאום יהיה מהיר פי 6

אבל אם יש לכם מק עם GPU, ואתם עדיין מריצים את כל ה-AI שלכם רק על ה-CPU, יש סיכוי שאתם משאירים הרבה מאוד ביצועים על השולחן.

במשך שנים התרגלנו לחשוב על המק בתור המחשב שעליו כותבים AI. את החישוב האמיתי עושים במקום אחר. GPU server. AWS. NVIDIA. הענן.

MLX מתחיל לערער על ההנחה הזאת.

והחלק המצחיק? לא שיניתי את Whisper. לא אימנתי מודל. לא קניתי GPU. אפילו לא החלפתי מחשב.

פשוט גיליתי שהמחשב שכבר קניתי היה הרבה יותר מהיר ממה שנתתי לו להיות.