llama.cpp מול MLX של אפל — מה ההבדל, ומתי כדאי מה

"אותו מודל, אותו מק, שני מנועים — ושני עולמות"

מסתבר שאפשר להריץ את אותו מודל שפה בדיוק, על אותו מק בדיוק, בשתי דרכים שונות לגמרי — וכל אחת מהן מרגישה אחרת. ישבנו על זה ברצינות בריפו שלנו שקראנו לו apple-silicon-arena, הרצנו בנצ'מארק אמיתי על שבב M, ויצאנו משם בלי "מנצח" גורף אבל עם תמונה הרבה יותר ברורה. אז בואו נפרק את זה לאט, כי שני השמות האלה — llama.cpp ו-MLX — צפים בכל פינה היום, ורוב האנשים לא באמת יודעים מה ההבדל ביניהם.

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

מה זה llama.cpp, ולמה כל העולם בנוי עליו

נתחיל בהגדרה נקייה: llama.cpp הוא מנוע הסקה בקוד C/C++ שמריץ מודלי שפה ביעילות על המעבד או הכרטיס הגרפי, עבור כל מי שרוצה להריץ מודל מקומית בלי ענן ובלי תלות בפלטפורמה אחת. הוא נכתב במקור על ידי מפתח בשם ggerganov, והפך מאז לתשתית שעליה יושב חצי מהעולם של ה-AI המקומי.

הקטע המדליק הוא שאנחנו כבר כנראה משתמשים בו בלי לדעת. אם הרצנו פעם Ollama או LM Studio — שני הכלים הפופולריים להרצת מודלים על המחשב — אז הרצנו את llama.cpp מתחת למכסה המנוע. הוא המנוע שמסתתר שם.

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

ויש עוד נקודה קריטית: llama.cpp רץ בכל מקום. מק, וינדוס, לינוקס, אפילו טלפון. אם יש לנו צי של מכונות שונות, llama.cpp הוא השפה המשותפת שכולן מדברות. על המק הוא יודע לנצל את ה-GPU של אפל דרך שכבה שנקראת Metal (זו הדרך של אפל לתת לתוכנות לדבר ישירות עם הכרטיס הגרפי), אבל הוא לא נבנה במיוחד לאפל — הוא נבנה להיות אזרח העולם.

מה זה MLX, והקסם של הזיכרון המאוחד

עכשיו נעבור לצד השני. MLX הוא פריימוורק של אפל למחשוב מערכי ולמידת מכונה, שתוכנן במיוחד לשבבי M של אפל, עבור מי שעובד על מק ורוצה לסחוט מהחומרה את המקסימום. שימו לב להבדל בניסוח: llama.cpp הוא מנוע הסקה ממוקד; MLX הוא פריימוורק רחב יותר, שיודע גם להסיק וגם לאמן.

מה שאפל הביאה לשולחן זה ניצול מלא של תכונה שנקראת זיכרון מאוחד (unified memory). בואו נסביר למה זה כזה עניין. במחשב רגיל עם כרטיס מסך נפרד, יש שני סוגי זיכרון: זיכרון של המעבד וזיכרון של הכרטיס הגרפי. כדי שהם יעבדו יחד, צריך כל הזמן להעתיק נתונים מצד לצד — וזה איטי ויקר. בשבבי M של אפל, המעבד והכרטיס הגרפי חולקים את אותו מאגר זיכרון פיזי. אין העתקות, אין בזבוז — כולם יושבים סביב אותו שולחן ואוכלים מאותה צלחת.

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

יתרון נוסף של MLX הוא ה-API שלו — הדרך שבה מתכנתים מדברים איתו. הוא פייתוני ונוח, מאוד דומה ל-NumPy ו-PyTorch (הספריות שכל מי שעוסק בלמידת מכונה מכיר). אם רוצים לא רק להריץ מודל אלא גם לחקור, לשנות, או לאמן משהו משלנו — MLX מרגיש ביתי.

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

אז מי ניצח בבדיקה שלנו?

עכשיו נגיע לחלק שכולם מחכים לו, ונאכזב אתכם בכוונה: בעיניי אין מנצח גורף, ומי שמוכר לנו תשובה חד-משמעית פשוט לא הריץ את שניהם ברצינות. בבנצ'מארק שלנו בריפו apple-silicon-arena ראינו שכל אחד מבריק בסיטואציה שלו, ושכל ניסיון לכתר אלוף אחד מפספס את הנקודה.

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

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

בעיניי: זו שאלה של צורך, לא של אגו

שורה תחתונה, ההתלבטות בין llama.cpp ל-MLX היא לא שאלה של "מה יותר טוב", אלא של "מה אנחנו צריכים עכשיו". זה כמו לשאול אם פטיש טוב יותר ממברגה — תלוי אם יש לפנינו מסמר או בורג.

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

ואם לסכם את כל הכתבה בשורה אחת: llama.cpp הוא הדרך להריץ בכל מקום עם הכי הרבה מודלים מוכנים; MLX הוא הדרך לסחוט מהמק שלנו כל טיפה של כוח. שניהם חינמיים, שניהם פתוחים, ושניהם רצים על המחשב שלנו בלי לשלוח אף בייט לענן.

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