Safetensors, CKPT, ONNX, GGUF ופורמטים מרכזיים נוספים של מודלי בינה מלאכותית [2025]

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

דוח זה בוחן את פורמטי הסריאליזציה המובילים, כולל Safetensors, CKPT, ONNX ו-GGUF. הוא מדגיש את תכונותיהם הייחודיות, שימושיהם הנפוצים, וכיצד הם משתווים זה לזה.

1. מבוא לסריאליזציה של מודלים בבינה מלאכותית ולמידת מכונה

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

התפקיד החיוני של פורמטים של מודלים במחזור החיים של AI/ML

שמירת מודלים בפורמט סטנדרטי היא קריטית מכמה סיבות:

• יכולת שחזור (Reproducibility): היא מאפשרת לשחזר ולאמת ניסויי מחקר באופן מדויק.
• שיתוף פעולה: פורמטים סטנדרטיים מקלים על צוותים לשתף מודלים, ומאפשרים להם לעבוד יחד ולשלב מודלים במערכות גדולות יותר.
• פריסה (Deployment): סריאליזציה הופכת מודל מאומן לקובץ נייד שניתן לטעון ולהריץ בסביבות שונות, משרתי ענן ועד להתקני קצה.
• למידת העברה (Transfer Learning): היא מאפשרת שימוש במודלים שאומנו מראש כבסיס למשימות חדשות, מה שחוסך זמן אימון ונתונים משמעותיים.

סקירה כללית של האתגרים שפורמטים מודרניים מתמודדים איתם

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

• אבטחה: דאגה מרכזית היא סיכון האבטחה בשיטות מסורתיות, במיוחד אלו המשתמשות במודול ה-pickle של פייתון. שיטות אלו עלולות לאפשר הרצת קוד זדוני בעת טעינת מודל, מה שיוצר איום אבטחה חמור אם המודל מגיע ממקור לא מהימן.
• ביצועים: המודלים הגדולים והמורכבים של ימינו דורשים טעינה מהירה מאוד וניהול זיכרון יעיל. זה חשוב במיוחד עבור התקנים עם משאבים מוגבלים, כמו טלפונים ניידים, ועבור יישומים הדורשים תגובות מיידיות.
• ניידות ותאימות בין-מערכתית: עולם למידת המכונה משתמש במספר רב של סביבות פיתוח (כמו PyTorch, TensorFlow ו-JAX). נדרשים פורמטים המאפשרים למודלים לעבור בקלות בין סביבות אלו ולרוץ על חומרות שונות (GPUs, TPUs) ללא עבודה משמעותית מחדש.

בשנים האחרונות, קהילת הבינה המלאכותית עברה לפורמטים יעילים ומאובטחים יותר כמו GGUF ו-Safetensors, מה שמשקף מאמץ קולקטיבי לטפל בבעיות אלו.

שיטות מוקדמות לשמירת מודלי ML, כמו השימוש של PyTorch במודול ה-pickle של פייתון עבור קובצי ה-.pt וה-.pth שלה, נבחרו בשל קלות השימוש בהן. הן יכלו לשמור בקלות אובייקטים מורכבים של פייתון, כולל עיצוב המודל ומצב האימון שלו (כמו האופטימייזר). אף שזה היה נוח למחקר בסביבת פייתון, זה יצר פרצת אבטחה חמורה. מודול ה-pickle מתוכנן באופן המאפשר לו להריץ כל קוד המוטמע בתוך קובץ במהלך תהליך הטעינה. משמעות הדבר היא שטעינת מודל שנראה לא מזיק ממקור לא מהימן עלולה לסכן מערכת שלמה.

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

פורמטים ייעודיים לסביבת הפיתוח (framework-native), כמו .pt/.pth עבור PyTorch ו-.ckpt/.h5 עבור TensorFlow/Keras, משולבים באופן הדוק עם הסביבות הספציפיות שלהם. בעוד שזה הופך אותם ליעילים בתוך מערכת אקולוגית אחת, זה גורם לבעיות משמעותיות של תאימות בין-מערכתית. מודל שאומן בסביבת פיתוח אחת לא יכול לשמש בקלות באחרת ללא המרות מורכבות או תחזוקת מערכות נפרדות לכל סביבה. זה מוביל לתהליכי פיתוח ופריסה מנותקים.

פורמט Open Neural Network Exchange (ONNX) נוצר כדי לשבור את המחסומים הללו. הוא מספק תקן "חוצה-פלטפורמות" ו"אגנוסטי לספקים" עבור מודלים. הוא משיג זאת על ידי הגדרת מבנה המודל (גרף החישוב שלו) באופן מופשט שאינו תלוי באף סביבת פיתוח אחת. באופן דומה, GGUF, אף שנוצר במקור עבור פרויקט llama.cpp, מתמקד גם בשיפור התאימות של מודלי שפה גדולים (LLMs) על פני פלטפורמות שונות.

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

2. הכרת Safetensors

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

הגדרה ועקרונות ליבה

Safetensors הוא פורמט סריאליזציה מודרני, מאובטח ומהיר למודלי למידה עמוקה, שנוצר על ידי Hugging Face. מטרתו העיקרית היא לספק דרך בטוחה לאחסן ולשתף טנזורים – המערכים הרב-ממדיים שהם אבני הבניין הבסיסיות של למידת המכונה. הפורמט מתוכנן להיות בטוח ומהיר יותר מפורמטים ישנים כמו pickle.

עקרון ליבה של Safetensors הוא ההפרדה המחמירה שלו בין משקולות המודל (טנזורים) לבין כל קוד בר-הרצה. עיצוב זה מתמודד ישירות עם פרצות האבטחה שנמצאו בשיטות סריאליזציה ישנות יותר.

תכונות עיקריות

• אפס-העתקה וטעינה עצלה (Zero-copy and Lazy Loading): מפתח לביצועי Safetensors הוא יכולת ה"אפס-העתקה" שלו. היא מאפשרת למפות נתוני מודל ישירות מהדיסק לזיכרון מבלי ליצור עותקים נוספים, מה שחוסך זיכרון ומאיץ את הטעינה. הוא תומך גם ב"טעינה עצלה", כלומר רק החלקים הדרושים של מודל גדול נטענים ל-RAM בעת הצורך. זה שימושי מאוד עבור מודלים גדולים במיוחד או מערכות עם זיכרון מוגבל.
• טיפול מובנה במטא-דאטה: כל קובץ Safetensors כולל קטע מטא-דאטה נפרד בפורמט JSON. קטע זה מפרט את כל הטנזורים במודל עם פרטים כמו צורתם, סוג הנתונים ושמם. המטא-דאטה מצביע על מיקום אחסון נתוני הטנזור בפועל, מה שמשפר הן את הקריאות והן את האבטחה.
• אחסון נתוני טנזורים בלבד: תכונת האבטחה החשובה ביותר של Safetensors היא שהוא מתוכנן להכיל "רק נתוני טנזורים גולמיים ומטא-דאטה משויך". במבנהו, הוא "אינו מאפשר סריאליזציה של קוד פייתון שרירותי". בחירת עיצוב בסיסית זו מבטלת את הסיכון להרצת קוד זדוני בעת טעינת מודל.
• תמיכה בקוונטיזציה: Safetensors יכול להתמודד עם טנזורים שעברו קוונטיזציה, מה שעוזר להקטין את גודל המודלים ולהשתמש בפחות זיכרון. עם זאת, תמיכת הקוונטיזציה שלו "אינה גמישה כמו של GGUF" מכיוון שהיא תלויה בתכונות שמספקת סביבת PyTorch.

יתרונות עיקריים

• אבטחה משופרת (מניעת הרצת קוד שרירותי): זהו היתרון הגדול ביותר של Safetensors. על פי עיצובו, הוא מונע לחלוטין שמירת קוד פייתון בקובץ. זה מבטל את סיכון האבטחה החמור ביותר שנמצא בפורמטים מבוססי pickle: הרצת קוד זדוני בעת טעינת מודל. זה הופך את Safetensors לבחירה הטובה ביותר לשיתוף ושימוש במודלים ממקורות ציבוריים או לא מהימנים. הפורמט כולל גם תכונות אבטחה נוספות כמו "טכניקות הצפנה מתקדמות" ובקרות גישה למניעת שיבוש נתונים.
• אופטימיזציה של ביצועים: השימוש באפס-העתקה וטעינה עצלה מביא ל"זמני טעינה מהירים יותר וצריכת זיכרון נמוכה יותר". מבחני ביצועים מראים שהוא הרבה "יותר מהיר" מ-pickle ויכול להיות "מהיר פי 76.6 במעבד (CPU) ופי 2 במעבד גרפי (GPU) בהשוואה לשיטת השמירה המסורתית של PyTorch".
• ניידות: הפורמט מתוכנן להיות נייד, כלומר הוא עובד על פני שפות תכנות שונות. זה מקל על שיתוף ושימוש במודלים במערכות תוכנה שונות.
• שילוב חלק: ל-Safetensors יש "שילוב חלק עם סביבות פיתוח וספריות קיימות של למידת מכונה". זה מאפשר למפתחים לאמץ בקלות את הפורמט הבטוח יותר הזה, מבלי לבצע שינויים גדולים בתהליכי העבודה הנוכחיים שלהם.

השוואה לסריאליזציה מסורתית (למשל, Pickle)

מודול ה-pickle של פייתון, המשמש לקובצי ה-.pt וה-.pth של PyTorch, אינו בטוח מטבעו. הוא מאפשר להסתיר כל קוד בתוך קובץ שעבר סריאליזציה ולהריץ אותו אוטומטית בעת טעינת הקובץ. זוהי פגיעות ידועה וחמורה, במיוחד בעת שימוש במודלים שהורדו מאתרים ציבוריים. בעוד שכלים כמו picklescan יכולים לזהות דפוסים זדוניים מסוימים, הם אינם חסינים בפני תקלות ואינם יכולים להבטיח בטיחות.

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

פרצת האבטחה ב-pickle של פייתון פירושה שהורדת קובץ .pt או .pth ממקור לא מהימן אינה רק הורדת נתונים; זה כמו להריץ תוכנית שעלולה להזיק. ידוע כי "אין פתרון חסין ב-100% לאימות בטיחותו של קובץ pickle ללא הרצה". זה מטיל את נטל בדיקת בטיחות הקובץ על המשתמש, דבר שהוא קשה ולא אמין.

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

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

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

3. סקירה כללית של פורמטים מרכזיים של מודלים

בנוסף ל-Safetensors, מספר פורמטים אחרים חשובים בעולם למידת המכונה, כל אחד עם תכונות ושימושים משלו.

3.1. CKPT (Checkpoints)

נקודת ציון (Checkpoint) בבינה מלאכותית אינה סוג קובץ יחיד, אלא תמונת מצב של מצב המודל שנשמר בנקודה מסוימת במהלך האימון. נקודות ציון חיוניות לשמירת התקדמות במהלך עבודות אימון ארוכות.

מאפיינים ושימושים טיפוסיים

נקודת ציון מכילה בדרך כלל את הפרמטרים הנלמדים של המודל, כמו המשקולות וההטיות שלו. היא יכולה גם לאחסן מידע חשוב אחר הדרוש לחידוש האימון, כמו מצב האופטימייזר, מספר האיטרציה (epoch) הנוכחי ולוח הזמנים של קצב הלמידה. סיומות הקבצים של נקודות ציון משתנות לפי סביבת הפיתוח. עבור PyTorch, הן בדרך כלל .pt או .pth, בעוד שעבור TensorFlow/Keras, הן .ckpt או .h5.

יתרונות מרכזיים של קובצי CKPT כוללים:

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

שימושים נפוצים לקובצי CKPT כוללים:

• חידוש אימון: המשך סבב אימון שהופסק, מה שחוסך זמן ומשאבי חישוב משמעותיים.
• כוונון עדין (Fine-Tuning): שימוש במודל שאומן מראש כנקודת התחלה לאימון על מערך נתונים חדש וספציפי יותר.
• הערכת מודל: בדיקת ביצועי מודל בשלבים שונים של האימון מבלי צורך לאמן אותו מחדש.
• הסקה (Inference): טעינת מודל מאומן במלואו למערכת ייצור כדי לבצע תחזיות.
• מחקר וניסויים: ניתוח התפתחות המודל לאורך זמן וכוונון שיטתי של הפרמטרים שלו.
• למידת העברה: שימוש כנקודת התחלה עוצמתית למשימות קשורות, מה שמפחית את זמן האימון ודרישות הנתונים.
• התאוששות מאסון: שימוש כגיבוי לחידוש העבודה לאחר כשל במהלך תהליך אימון ארוך.

שיקולי אבטחה

סיכון האבטחה הגדול ביותר בקובצי CKPT, במיוחד בפורמטי .pt ו-.pth של PyTorch, נובע מהסתמכותם על מודול ה-pickle של פייתון. משמעות הדבר היא שניתן לתכנן קבצים אלה כך שיכילו ויריצו קוד פייתון זדוני בעת טעינתם (אם משתמשים בפונקציה torch.load ללא ההגדרה weights_only=True). לפגיעות זו (CWE-502: Deserialization of Untrusted Data) יכולות להיות השלכות חמורות, כמו גניבת נתונים, שינוי התנהגות המודל, או אפילו השתלטות מלאה על המערכת.

התעשייה הכירה בסיכון זה, ו-Safetensors הופיע כאפשרות בטוחה יותר. כפי שצוין, "רוב נקודות הציון של Stable Diffusion AI נשמרות בפורמטים כמו .ckpt או .safetensors... .safetensors היא חלופה בטוחה יותר, שנועדה למנוע הרצת קוד זדוני." זה מראה מגמה ברורה לעבר פורמטים מאובטחים יותר לשיתוף מודלים.

CKPTs, במיוחד בפורמט .pt/.pth של PyTorch, ידועים כ"גמישים מאוד". גמישות זו מאפשרת להם לשמור לא רק את משקולות המודל, אלא גם את מצב האופטימייזר ואפילו מחלקות פייתון מותאמות אישית, דבר שימושי מאוד לחידוש אימון באופן מדויק.

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

הפתרון של התעשייה הוא לאמץ פורמטים כמו Safetensors להפצת מודלים, גם אם פורמטי .pt/.pth הגמישים יותר עדיין משמשים לאימון בסביבות מבוקרות. זה מראה על הבנה גוברת ששלבים שונים במחזור החיים של ML דורשים רמות שונות של אבטחה. את הכוח של שמירת מצב האימון המלא עדיף לשמור בסביבת פיתוח מהימנה, בעוד ששיתוף ופריסה דורשים פורמטים עם הבטחות אבטחה מובנות.

3.2. ONNX (Open Neural Network Exchange)

ONNX, קיצור של Open Neural Network Exchange, הוא פורמט תקן פתוח למודלי למידת מכונה. הוא נועד לאפשר למודלים לעבוד על פני סביבות פיתוח שונות של למידה עמוקה.

מאפיינים ושימושים עיקריים

קובץ ONNX מכיל את המבנה המלא של המודל, כולל רצף הפעולות שלו (גרף החישוב), המשקולות הנלמדות שלו ומטא-דאטה אחר. חוזק מרכזי של ONNX הוא שהוא פועל כמתרגם אוניברסלי. מודלים שאומנו בסביבות פיתוח כמו PyTorch, TensorFlow או scikit-learn ניתנים להמרה לפורמט ONNX, מה שמאפשר גישת "אמן פעם אחת, פרוס בכל מקום".

בניגוד לפורמטים שמאחסנים רק משקולות מודל (כמו Safetensors או GGUF), ONNX כולל את גרף החישוב של המודל. מבנה מבוסס-גרף זה מספק "יותר גמישות בעת המרת מודלים בין סביבות פיתוח שונות". ONNX מציע ניידות מצוינת על פני פלטפורמות, התקנים ומאיצי חומרה רבים (מעבדים, מעבדים גרפיים, שבבי AI). המודלים מאוחסנים בפורמט Protobuf, שהוא דרך יעילה ונייטרלית לפלטפורמה לשמירת נתונים מובנים.

שימושים עיקריים ל-ONNX כוללים:

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

שיקולי אבטחה

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

כדי להפחית איומים אלה, מומלץ לנקוט במספר שיטות:

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

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

חסרונות

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

פורמטים מסורתיים המבוססים על pickle של פייתון (כמו קובצי .pt) שומרים אובייקטים של פייתון, שיכולים לכלול קוד בר-הרצה. זה מתייחס למודל כאל תוכנית. בניגוד לכך, ONNX מתמקד בשמירת "גרף החישוב" של המודל – ייצוג מופשט יותר של הפעולות וזרימת הנתונים שלו, ולא יישום קוד ספציפי.

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

3.3. GGUF (GPT-Generated Unified Format)

GGUF (GPT-Generated Unified Format) הוא פורמט קבצים שתוכנן במיוחד לאחסון והרצה יעילה של מודלי שפה גדולים (LLMs). הוא גרסה משופרת של קודמו, GGML, ומטרתו להפוך את השימוש ב-LLMs לקל יותר, במיוחד במחשבים אישיים.

מאפיינים ושימושים עיקריים

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

תכונה מרכזית של GGUF היא התמיכה המצוינת שלו בקוונטיזציה. קוונטיזציה מפחיתה את הדיוק המספרי של משקולות המודל (למשל, ממספרי 16 סיביות ל-4 סיביות), מה שמקטין באופן דרסטי את גודל הקובץ ואת החישוב הדרוש להרצתו. מודלי GGUF זמינים ברמות קוונטיזציה שונות (מ-Q2 עד Q8), ומציעים מגוון של פשרות בין גודל לאיכות.

• רמות קוונטיזציה נמוכות יותר (כמו Q2 או Q3) מביאות לקבצים קטנים מאוד שיכולים לרוץ על חומרה עם פחות RAM, אך עלולות לגרום לירידה קלה באיכות המודל.
• רמות קוונטיזציה גבוהות יותר (כמו Q6 או Q8) שומרות על איכות טובה יותר אך דורשות יותר שטח אחסון ו-RAM.

שימושים עיקריים ל-GGUF כוללים:

• פריסת LLM מקומית: כלים כמו Ollama משתמשים ב-GGUF כדי להקל על משתמשים להריץ LLMs עוצמתיים במחשבים שלהם.
• עוזרי AI לא מקוונים: יישומים רבים משתמשים במודלי GGUF כדי לספק חלופות מקומיות ופרטיות לכלי AI מבוססי ענן.
• סיוע בכתיבת קוד: סביבות פיתוח משולבות (IDEs) ועורכי קוד מתחילים להשתמש במודלי GGUF להשלמת קוד חכמה.
• צ'אטבוטים מקומיים: מודלי GGUF משמשים לעתים קרובות למערכות AI שיחתיות פרטיות ומגיבות.
• מחקר AI: גמישותו ותמיכתו בקוונטיזציה הופכות אותו לפופולרי בקרב חוקרים לניסויים עם LLMs על חומרה נגישה.

שיקולי אבטחה

בניגוד לדעה הרווחת, לספריית GGML הבסיסית (שעליה מבוסס GGUF) היו פגיעויות מתועדות הקשורות ל"אימות לא מספק של קובץ הקלט". פגמים אלה עלולים להוביל ל"פגיעויות של השחתת זיכרון שניתן לנצל במהלך הניתוח (parsing)". זוהו בעיות אבטחה ספציפיות שבהן קלט משתמש שלא נבדק עלול לגרום לגלישת ערימה (heap overflow), מה שעלול לאפשר לתוקף להריץ קוד זדוני.

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

כדי להפחית סיכונים אלה, מומלץ:

• להשתמש במודלים ובכלים ממקורות ידועים ובעלי מוניטין (כמו Koboldcpp).
• להריץ LLMs בסביבות מבודדות (כמו קונטיינרים של Docker).
• למשימות רגישות במיוחד, לשקול שימוש במכונה ייעודית ללא גישה לאינטרנט.

חסרונות

חיסרון מרכזי של GGUF הוא שרוב המודלים מפותחים תחילה בסביבות פיתוח אחרות (כמו PyTorch) ויש להמירם לפורמט GGUF. תהליך המרה זה אינו תמיד קל, וחלק מהמודלים עשויים שלא להיות נתמכים במלואם על ידי כלים תואמי GGUF. בנוסף, שינוי או כוונון עדין של מודל לאחר שהוא בפורמט GGUF הוא בדרך כלל "לא פשוט".

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

המאפיין המגדיר של GGUF הוא השילוב העמוק שלו עם קוונטיזציה, המאפשר ל-LLMs עוצמתיים לרוץ על "חומרת צרכנים" עם VRAM מוגבל. זה עוזר לדמוקרטיזציה של הגישה לבינה מלאכותית. עם זאת, יעילות זו כרוכה בפשרות. בעוד שקוונטיזציה מקטינה את גודל המודלים, רמות נמוכות יותר עלולות להפחית מעט את איכות המודל. כמו כן, מהירות ההסקה יכולה לפעמים להיות איטית יותר מאשר עם מודלים שלא עברו קוונטיזציה, במיוחד אם הגרסה הלא מקוונטזת נכנסת כולה ל-VRAM.

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

4. ניתוח השוואתי של פורמטים

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

תכונה / פורמט	Safetensors	CKPT (.pt/.pth)	ONNX	GGUF
מטרה עיקרית	אחסון טנזורים מאובטח ומהיר למודלי למידה עמוקה	נקודות ציון לאימון, פרמטרים של מודל, שימור מצב	תאימות בין-סביבות פיתוח, פריסה על חומרה מגוונת	אחסון יעיל של LLMs, הסקה מקומית ממוטבת על חומרת צרכנים
פרופיל אבטחה	גבוה (אין הרצת קוד שרירותי על פי תכנון)	נמוך (הרצת קוד שרירותי באמצעות דה-סריאליזציה של Pickle)	בינוני (אין הרצת קוד שרירותי, אך ייתכנו דלתות אחוריות ארכיטקטוניות)	בינוני (פגיעויות בספרייה הבסיסית, אך הקובץ עצמו אינו קוד פייתון בר-הרצה)
מהירות טעינה	מהירה מאוד (אפס-העתקה, טעינה עצלה)	משתנה (יכול להיות איטי יותר מ-Safetensors עקב טעינה מלאה)	מהיר (runtime ממוטב, אופטימיזציות גרף)	מהיר (mmap, יעיל עבור LLMs)
שימוש בזיכרון	יעיל (טעינה עצלה, טעינה חלקית)	יכול להיות גבוה (טוען את כל גרף האובייקטים)	יעיל (אופטימיזציות runtime)	יעיל מאוד (קוונטיזציה, חיסכון ב-VRAM)
שטח דיסק	יעיל (דחיסה, טנזורים בלבד)	משתנה (יכול להיות גדול, כולל מצב מלא)	יעיל (פורמט Protobuf)	יעיל מאוד (קוונטיזציה, דחיסה מתקדמת)
תמיכה בקוונטיזציה	כן, אך פחות גמיש מ-GGUF (תלוי ב-PyTorch)	כן (תלוי בסביבת הפיתוח)	תמיכה טבעית מוגבלת (מפרק טנזורים)	חזקה (רמות מרובות, Q2-Q8, גרסאות מיוחדות)
ניידות	גבוהה (בין שפות תכנות שונות)	נמוכה (צמודה מאוד לסביבות פיתוח ספציפיות)	גבוהה מאוד (חוצה-סביבות פיתוח, חוצה-פלטפורמות, חומרה מגוונת)	גבוהה (במיוחד עבור המערכת האקולוגית של llama.cpp)
יישומים עיקריים	שיתוף מאובטח של מודלים, ברירת המחדל של Hugging Face	אימון, כוונון עדין, מחקר, שמירת מודלים	פריסה לייצור, מובייל/קצה, תאימות בין-מערכתית	הסקת LLM מקומית, חומרת צרכנים, יישומי צ'אט
יתרון מרכזי	אבטחה על פי תכנון, טעינה מהירה, טביעת רגל זיכרון נמוכה	שימור מצב אימון, יכולת שחזור מפורטת	פריסה אוניברסלית, אופטימיזציית runtime, אגנוסטיות לסביבת פיתוח	יעילות LLM על חומרת צרכנים, קוונטיזציה גמישה
חיסרון מרכזי	נדרש מנתח JSON למטא-דאטה ב-C++	סיכון להרצת קוד שרירותי, גודלי קבצים גדולים	מורכבות לשכבות מותאמות אישית, קוונטיזציה טבעית מוגבלת	נדרשת המרה לעתים קרובות, האטה אפשרית בהסקה עם קוונטיזציה נמוכה

5. מסקנה

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

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

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

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

בסופו של דבר, הפורמט הטוב ביותר תלוי בהקשר הספציפי.

• Safetensors היא הבחירה המובילה לשיתוף מאובטח ויעיל של מודלי למידה עמוקה.
• ONNX הוא אידיאלי לפריסת מודלים על פני סביבות פיתוח וחומרה שונות.
• GGUF מציע יעילות ללא תחרות להרצת מודלי שפה גדולים על התקנים מקומיים ומוגבלי משאבים.

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