כיצד לייעל מודלים של בינה מלאכותית

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

נקודות מפתח:

אילוץ : בחרו מדד יעד אחד או שניים; אופטימיזציה היא נוף של פשרות, לא ניצחונות בחינם.

מדידה : פרופיל עומסי עבודה אמיתיים עם p50/p95/p99, תפוקה, ניצול ושיאי זיכרון.

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

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

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

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

🔗 כיצד למדוד ביצועי בינה מלאכותית בעזרת מדדים אמיתיים.
השתמשו באותות של מדדי ביצועים, השהייה, עלות ואיכות כדי להשוות.

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

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

---

1) מה המשמעות של "אופטימיזציה" בפועל (כי כולם משתמשים בזה בצורה שונה) 🧠

כשאנשים אומרים "לייעל מודל בינה מלאכותית", הם עשויים להתכוון ל:

• להפוך את זה למהיר יותר (השהייה נמוכה יותר)

• להפוך את זה לזול יותר (פחות שעות GPU, הוצאות נמוכות יותר על ענן)

• הקטן אותו (שטח זיכרון, פריסה בקצה)

• להפוך את זה למדויק יותר (שיפורי איכות, פחות הזיות)

• להפוך אותו ליציב יותר (פחות שונות, פחות כשלים בייצור)

• להקל על ההגשה (תפוקה, עיבוד אצווה, ביצועים צפויים)

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

אז לפני שנוגעים במשהו, בחרו את האילוץ העיקרי :

• אם אתם משרתים משתמשים בשידור חי, אכפת לכם מהשהייה של p95 ( אחוזוני AWS CloudWatch ) וביצועי הזנב ( שיטות עבודה מומלצות של "השהייה זנב" ) 📉

• אם אתם מתאמנים, אכפת לכם מזמן איכות וניצול GPU 🔥

• אם אתם פורסים על מכשירים, אכפת לכם מזיכרון RAM וכוח 🔋

---

2) איך נראית גרסה טובה של אופטימיזציה של מודל בינה מלאכותית ✅

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

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

• מדד יעד ברור
  "מהר יותר" הוא מעורפל. "לקצץ את זמן ההשהיה של p95 מ-900ms ל-300ms באותו ציון איכות" הוא יעד אמיתי.

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

• מודעות לחומרה.
  מודל "מהיר" על כרטיס מסך אחד יכול לזחול על אחר. מעבדים הם סוג מיוחד משלהם של כאוס.

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

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

---

3) טבלת השוואה: אפשרויות פופולריות לאופטימיזציה של מודלים של בינה מלאכותית 📊

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

כלי / אפשרות	קהל	מְחִיר	למה זה עובד
PyTorch torch.compile ( מסמכי PyTorch )	אנשי PyTorch	לְשַׁחְרֵר	לכידת גרפים + טריקים של מהדר יכולים לחסוך בעלויות... לפעמים זה קסם ✨
זמן ריצה של ONNX ( מסמכי זמן ריצה של ONNX )	צוותי פריסה	חינמי-יש	אופטימיזציות חזקות להסקת מסקנות, תמיכה רחבה, טוב להגשה סטנדרטית
TensorRT ( מסמכי NVIDIA TensorRT )	פריסת NVIDIA	וייבים בתשלום (לעתים קרובות מצורפים)	היתוך ליבה אגרסיבי + טיפול מדויק, מהיר מאוד בלחיצה
DeepSpeed ​​( תיעוד ZeRO )	צוותי אימון	לְשַׁחְרֵר	אופטימיזציות זיכרון + תפוקה (ZeRO וכו'). יכול להרגיש כמו מנוע סילון
FSDP (PyTorch) ( מסמכי PyTorch FSDP )	צוותי אימון	לְשַׁחְרֵר	פיצול פרמטרים/גרדיאנטים של Shards, הופך מודלים גדולים לפחות מפחידים
קוונטיזציה של ביטס ובייטים ( bitsandbytes )	מומחי תואר שני במשפטים	לְשַׁחְרֵר	משקלי ביטים נמוכים, חיסכון עצום בזיכרון - האיכות תלויה, אבל וואו 😬
זיקוק ( הינטון ואחרים, 2015 )	צוותי מוצר	"עלות זמן"	מודל סטודנט קטן יותר יורש התנהגות, בדרך כלל החזר ההשקעה הטוב ביותר בטווח הארוך
גיזום ( מדריך גיזום ב-PyTorch )	מחקר + מוצר	לְשַׁחְרֵר	מסיר משקל מת. עובד טוב יותר בשילוב עם אימון מחדש
תשומת לב פלאש / גרעינים התמזגו ( מאמר תשומת לב פלאש )	חנוני ביצועים	לְשַׁחְרֵר	קשב מהיר יותר, התנהגות זיכרון טובה יותר. ניצחון אמיתי עבור רובוטריקים
שרת הסקת מסקנות טריטון ( אצווה דינמית )	תפעול/תשתיות	לְשַׁחְרֵר	הגשת ייצור, אצווה, צינורות מרובי מודלים - מרגיש ארגוני-אישי

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

---

4) התחילו עם מדידה: צרו פרופיל כאילו אתם מתכוונים לזה 🔍

אם אתם עושים רק דבר אחד מכל המדריך הזה, עשו זאת: מדדו כראוי.

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

• טוען נתונים מרעיב את ה-GPU

• צוואר בקבוק של עיבוד מקדים של המעבד

• גדלי אצווה זעירים גורמים לתקורה של הפעלת הליבה

• טוקניזציה איטית (טוקניזטורים יכולים להיות נבלים שקטים)

• פיצול זיכרון ( הערות על מקצה זיכרון PyTorch CUDA )

• שכבה אחת שולטת במחשוב

מה למדוד (ערך מינימלי)

• חביון (p50, p95, p99) ( SRE על אחוזוני חביון )

• תפוקה (טוקנים/שנייה, בקשות/שנייה)

• ניצול GPU (מחשוב + זיכרון)

• שיאי VRAM / RAM

• עלות לכל 1,000 טוקנים (או לכל הסקה)

חשיבה מעשית על פרופילציה

• תאר תרחיש אחד שאכפת לך ממנו (לא הנחיה בצעצוע).

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

(אם אתם רוצים כלי קונקרטי להתחיל איתו: PyTorch Profiler ( docs torch.profiler ) ו- Nsight Systems ( NVIDIA Nsight Systems ) הם החשודים הרגילים.)

---

5) אופטימיזציית נתונים + אימון: מעצמת העל השקטה 📦🚀

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

ניצחונות קלים שמופיעים מהר

• השתמש בדיוק מעורב (FP16/BF16 היכן שהוא יציב) ( PyTorch AMP / torch.amp ).
  בדרך כלל מהיר יותר, לרוב בסדר - אך שימו לב למוזרויות מספריות.

• הצטברות גרדיאנט כאשר גודל האצווה מוגבל ( 🤗 מדריך להאצה )
  שומרת על יציבות האופטימיזציה מבלי לפוצץ את הזיכרון.

• נקודת ביקור של גרדיאנט ( torch.utils.checkpoint )
  מחליפה חישוב תמורת זיכרון - מאפשרת הקשרים גדולים יותר.

• טוקניזציה יעילה ( 🤗 טוקנייזרים )
  טוקניזציה יכולה להפוך לצוואר בקבוק בקנה מידה גדול. זה לא זוהר; זה חשוב.

• כוונון טוען נתונים:
  יותר עובדים, זיכרון מוצמד, שליפה מוקדמת - לא ראוותני אבל יעיל 😴➡️💪 ( מדריך כוונון ביצועים של PyTorch )

כוונון עדין יעיל מבחינת פרמטרים

אם אתם מכוונים דגמים גדולים, שיטות PEFT (כמו מתאמים בסגנון LoRA) יכולות להפחית באופן דרמטי את עלויות האימון תוך שמירה על חזקות באופן מפתיע ( 🤗 מדריך PEFT של Transformers , מאמר LoRA ). זהו אחד מאותם רגעים של "למה לא עשינו את זה קודם?".

---

6) אופטימיזציה ברמת הארכיטקטורה: גודל המודל הנכון 🧩

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

התקשרו על כמה דברים בסיסיים:

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

• שמור על חלון ההקשר גדול ככל הנדרש, לא גדול יותר.

• השתמש במודל שאומן למשימה שלפניך (מודלי סיווג לעבודת סיווג וכן הלאה).

אסטרטגיות מעשיות לשינוי גודל נכון

• עבור למערכת תמיכה קטנה יותר עבור רוב הבקשות.
  לאחר מכן, נתב "שאילתות קשות" למודל גדול יותר.

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

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

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

---

7) אופטימיזציות של מהדר + גרף: מאיפה מגיעה המהירות 🏎️

זוהי השכבה של "לגרום למחשב לעשות דברים חכמים יותר".

טכניקות נפוצות:

• היתוך אופרטורים (שילוב ליבות) ( "היתוך שכבות" של NVIDIA TensorRT )

• קיפול קבוע (ערכים קבועים בחישוב מראש) ( אופטימיזציות גרף בזמן ריצה של ONNX )

• בחירת ליבה מותאמת לחומרה

• לכידת גרפים כדי להפחית את תקורת הפייתון ( סקירת torch.compile )

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

הערות מעשיות (aka צלקות)

• אופטימיזציות אלו יכולות להיות רגישות לשינויים בצורת המודל.

• חלק מהדגמים מאיצים הרבה, חלקם בקושי זזים.

• לפעמים אתה מקבל עלייה באיטיות ובאג תמוה - כמו גרמלין שנכנס פנימה 🧌

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

---

8) קוונטיזציה, גיזום, זיקוק: קטן יותר בלי לבכות (יותר מדי) 🪓📉

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

קוונטיזציה (משקלים/הפעלות בעלי דיוק נמוך יותר)

• מעולה למהירות הסקה וזיכרון

• סיכון: ירידות איכות, במיוחד במארזי קצה

• שיטה מומלצת: להעריך על סט ניסויים אמיתי, לא על ויברציות

טעמים נפוצים שתשמעו עליהם:

• INT8 (לעתים קרובות מוצק) ( סוגים כמותיים של TensorRT )

• INT4 / low-bit (חיסכון עצום, סיכון האיכות עולה) ( קוונטיזציה של bitsandbytes ו-k-bit )

• כמותי מעורב (לא כל דבר דורש את אותו דיוק)

גיזום (הסרת פרמטרים)

• מסיר משקלים או מבנים "לא חשובים" ( מדריך גיזום PyTorch )

• בדרך כלל נדרשת הכשרה מחדש כדי לשחזר את האיכות

• עובד טוב יותר ממה שאנשים חושבים... כשהוא נעשה בזהירות

זיקוק (התלמיד לומד מהמורה)

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

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

---

9) הגשה והסקה: אזור הקרב האמיתי 🧯

אפשר "לייעל" מודל ועדיין להציג אותו בצורה גרועה. הצגתו היא המקום שבו השהייה והעלות הופכים למציאותיים.

הגשה מנצחת שחשובה

• מינון אצווה
  משפר את התפוקה. אבל מגביר את ההשהיה אם מגזימים. לאזן את זה. ( מינון אצווה דינמי של טריטון )

• במטמון (Caching
  ) אחסון במטמון (Caching) ושימוש חוזר במטמון KV יכולים להיות עצומים עבור הקשרים חוזרים. ( הסבר על מטמון KV )

• פלט בסטרימינג -
  משתמשים מרגישים שזה מהיר יותר גם אם הזמן הכולל דומה. התפיסה חשובה 🙂.

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

שימו לב להשהיית זנב

הממוצע שלך אולי נראה נהדר בעוד שה-p99 שלך הוא אסון. למרבה הצער, המשתמשים חיים בזנב. ( "השהיית זנב" ומדוע ממוצעים משקרים )

---

10) אופטימיזציה מודעת לחומרה: התאמת המודל למכונה 🧰🖥️

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

שיקולי GPU

• רוחב פס של זיכרון הוא לעתים קרובות הגורם המגביל, לא החישוב הגולמי

• גדלי אצווה גדולים יותר יכולים לעזור, עד שהם לא

• איחוי ליבה ואופטימיזציות של תשומת לב הן עצומות עבור טרנספורמרים ( FlashAttention: תשומת לב מדויקת מודעת IO )

שיקולי המעבד

• שרשור (Threading), וקטוריזציה (vectorization) ולוקליזציה של זיכרון (זיכרון מקומי) חשובים מאוד

• תקורה של טוקניזציה יכולה לשלוט ( 🤗 טוקניזטורים "מהירים" )

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

שיקולי קצה / נייד

• טביעת רגל של זיכרון הופכת לעדיפות מספר אחת

• שונות השהייה חשובה מכיוון שמכשירים הם... מצוברחים

• דגמים קטנים יותר ומתמחים לרוב מנצחים דגמים כלליים גדולים

---

11) מעקות בטיחות איכותיים: אל "תמטבו" את עצמכם לבאג 🧪

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

מעקות בטיחות פרגמטיים:

• הנחיות זהב (קבוצה קבועה של הנחיות שאתה תמיד בודק)

• מדדי משימה (דיוק, F1, BLEU, מה שמתאים)

• בדיקות נקודתיות אנושיות (כן, ברצינות)

• ספי רגרסיה ("ירידה של יותר מ-X% מותרת")

כמו כן, עקוב אחר מצבי כשל:

• סחף עיצוב

• שינויים בהתנהגות הסירוב

• תדירות הזיות

• אינפלציה של אורך התגובה

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

---

12) רשימת בדיקה: כיצד לבצע אופטימיזציה של מודלים של בינה מלאכותית שלב אחר שלב ✅🤖

אם אתם רוצים סדר פעולות ברור עבור כיצד לייעל מודלים של בינה מלאכותית , הנה תהליך העבודה שנוטה לשמור על שפיות אנשים:

1. הגדירו הצלחה.
   בחרו 1-2 מדדים עיקריים (זמן השהייה, עלות, תפוקה, איכות).

2. מדידת
   עומסי עבודה אמיתיים של פרופיל בסיסי, רישום p50/p95, זיכרון, עלות. ( פרופילר PyTorch )

3. תיקון צווארי בקבוק בצנרת
   טעינת נתונים, טוקניזציה, עיבוד מקדים, עיבוד אצווה.

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

5. נסה אופטימיזציות של מהדר/זמן ריצה
   , לכידת גרפים, זמני ריצה של הסקה, היתוך אופרטורים. ( מדריך torch.compile , מסמכי זמן ריצה של ONNX )

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

7. תיקוני אחסון
   במטמון של הגשה, מקביליות, בדיקות עומס, ותיקוני השהיית זנב.

8. אימות איכות.
   הפעל בדיקות רגרסיה והשווה פלטים זה לצד זה.

9. חזרות על
   שינויים קטנים, הערות ברורות, חזרה. לא ראוותני - יעיל.

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

---

13) טעויות נפוצות (כדי שלא תחזרו עליהן כמו כולנו) 🙃

• אופטימיזציה לפני מדידה -
  תבזבזו זמן. ואז תבצעו אופטימיזציה של הדבר הלא נכון בביטחון...

• מרדף אחר מדד ביצועים יחיד -
  מדדי ביצועים משקרים בהשמטה. עומס העבודה שלך הוא האמת.

• התעלמות מזיכרון
  בעיות זיכרון גורמות להאטה, קריסות וריצוד. ( הבנת השימוש בזיכרון CUDA ב-PyTorch )

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

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

---

הערות סיכום: הדרך האנושית לאופטימיזציה 😌⚡

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

אם אתם רוצים את הטייק אווי הקצר ביותר:

• מדדו קודם 🔍

• אופטימיזציה של הצינור הבא 🧵

• לאחר מכן בצע אופטימיזציה של המודל 🧠

• לאחר מכן, בצע אופטימיזציה של ההגשה 🏗️

• שמור על בדיקות איכות תמידיות ✅

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

שאלות נפוצות

מה המשמעות של אופטימיזציה של מודל בינה מלאכותית בפועל

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

כיצד לייעל מודלים של בינה מלאכותית מבלי לפגוע באיכות בשקט

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

מה למדוד לפני שמתחילים לבצע אופטימיזציה

התחילו עם אחוזוני השהייה (p50, p95, p99), תפוקה (טוקנים/שנייה או בקשות/שנייה), ניצול GPU ושיא VRAM/RAM. עקבו אחר העלות להסקה או לכל 1,000 טוקנים אם העלות היא אילוץ. צרו פרופיל של תרחיש אמיתי שאתם מגישים, לא הנחיה צעצוע. ניהול "יומן ביצועים" קטן עוזר לכם להימנע מניחוש וחזרה על טעויות.

ניצחונות מהירים ובעלי סיכון נמוך לשיפור ביצועי האימון

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

מתי להשתמש ב-torch.compile, ב- ONNX Runtime או ב- TensorRT

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

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

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

ההבדל בין גיזום לזיקוק לצורך הקטנת גודל המודל

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

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

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

מדוע השהיית זנב כל כך חשובה בעת אופטימיזציה של מודלים של בינה מלאכותית

ממוצעים יכולים להיראות נהדר בעוד ש-p99 הוא אסון, ומשתמשים נוטים לחיות ב"זנב" (tail latency). השהיית זנב נובעת לעתים קרובות מרעידות (jitter): פיצול זיכרון, קפיצות בעיבוד מקדים של המעבד, האטות באסימונים או התנהגות קבוצתית לקויה. זו הסיבה שהמדריך מדגיש אחוזונים ועומסי עבודה אמיתיים. אם מבצעים אופטימיזציה רק ​​של p50, עדיין ניתן ליצור חוויה ש"מרגישה איטית באופן אקראי"

הפניות

1. שירותי אינטרנט של אמזון (AWS) - אחוזוני AWS CloudWatch (הגדרות סטטיסטיות) - docs.aws.amazon.com

2. גוגל - זנב בקנה מידה (שיטות עבודה מומלצות להשהיית זנב) - sre.google

3. גוגל - יעדי רמת שירות (ספר SRE) - אחוזוני השהייה - sre.google

4. PyTorch - torch.compile - docs.pytorch.org

5. PyTorch - FullyShardedDataParallel (FSDP) - docs.pytorch.org

6. PyTorch - PyTorch Profiler - docs.pytorch.org

7. PyTorch - סמנטיקה של CUDA: ניהול זיכרון (הערות על מקצה זיכרון CUDA) - docs.pytorch.org

8. PyTorch - דיוק מעורב אוטומטי (torch.amp / AMP) - docs.pytorch.org

9. PyTorch - torch.utils.checkpoint - docs.pytorch.org

10. PyTorch - מדריך לכוונון ביצועים - docs.pytorch.org

11. PyTorch - מדריך גיזום - docs.pytorch.org

12. PyTorch - הבנת השימוש בזיכרון CUDA ב-PyTorch - docs.pytorch.org

13. PyTorch - מדריך / סקירה כללית של torch.compile - docs.pytorch.org

14. זמן ריצה של ONNX - תיעוד זמן ריצה של ONNX - onnxruntime.ai

15. NVIDIA - תיעוד TensorRT - docs.nvidia.com

16. NVIDIA - סוגי TensorRT מכומתים - docs.nvidia.com

17. NVIDIA - Nsight Systems - developer.nvidia.com

18. NVIDIA - שרת הסקת מסקנות Triton - אצווה דינמית - docs.nvidia.com

19. DeepSpeed ​​- ZeRO Stage 3 - deepspeed.readthedocs.io

20. bitsandbytes (bitsandbytes-foundation) - bitsandbytes - github.com

21. פנים מחבקות - האצה: מדריך לצבירת גרדיאנטים - huggingface.co

22. פנים מחבקות - תיעוד של טוקנייזרים - huggingface.co

23. פנים מחבקות - רובוטריקים: מדריך PEFT - huggingface.co

24. פרצוף מחבק - הסבר על מטמון טרנספורמרים: KV - huggingface.co

25. פרצוף מחבק - רובוטריקים: טוקנייזרים "מהירים" (מחלקות טוקנייזר) - huggingface.co

26. arXiv - זיקוק הידע ברשת נוירונים (Hinton et al., 2015) - arxiv.org

27. arXiv - LoRA: עיבוד בדרגה נמוכה של מודלים גדולים של שפה - arxiv.org

28. arXiv - FlashAttention: קשב מדויק, מהיר ויעיל מבחינת זיכרון עם IO-Awareness - arxiv.org