עיצוב הספרייה
Tokamax נועד לתקנן ולפשט תהליכים אופייניים של מפתחים שקשורים ליצירה, לאופטימיזציה, לתחזוקה ולשימוש בקרנל בסביבת ייצור. הוא עושה זאת באמצעות מחלקות בסיסיות ותשתית משותפת שכל האופרטורים בספרייה יורשים מהן ומטמיעים אותן במסגרת מובנית היטב.
שכבות של מפעילים
מחלקה בסיסית של Tokamax
tokamax.Op היא המחלקה הבסיסית של Tokamax, שמשמשת כבסיס לכל אופרטור בספרייה. כשמפעילים אופרטור נגזר, השכבה הזו מטפלת באופן אוטומטי בפונקציונליות הבאה:
- קישור ארגומנטים: לפני שמתבצע חישוב כלשהו, מחלקת הבסיס מנרמלת ומאמתת את הארגומנטים של מבצע הקריאה לייצוג קנוני יחיד, כדי שהשמירה במטמון, ההיוריסטיקה והביצוע של הליבה יוכלו להסיק על עומס העבודה באופן אחיד (באמצעות אובייקט
BoundArguments), בלי קשר לאופן שבו הקלט הועבר (ראוop.bind()). - אימות מכשיר: כדי לזהות חוסר התאמה בחומרה בשלב מוקדם, האופרטור מאמת את התמיכה במכשיר מול מאיץ היעד לפני ההפעלה, ועדיין מאפשר לעקוף את הבדיקה הזו כשמבצעים עיבוד בין מערכות ממארח מעבד (ראו
op.supported_on(),bypass_device_check=Trueו-config.cross_compile(True)). - תיעוד של אצווה: מכיוון שההגדרה הטובה ביותר של הליבה (
Config) תלויה לעיתים קרובות בגודל הבעיה המלאה של האצווה ולא בפרוסה אחת, מחלקת הבסיס מתעדת את הממדים של האצווה שמסביב כאשר אופרטור עובר וקטוריזציה (jax.vmap) כדי שהיוריסטיקה ומטמונים של כוונון אוטומטי יוכלו לבצע אופטימיזציה לצורה האמיתית של עומס העבודה (ראוop._capture_batched_args()). - רזולוציית הגדרות אישיות: כדי לספק ביצועים חזקים בלי צורך בכוונון ידני, המחלקה הבסיסית פותרת את היפר-הפרמטרים של הליבה באופן אוטומטי בכל פעם שהמתקשר לא מספק אותם – שימוש חוזר בהגדרות שכוונו באופן אוטומטי בעבר במטמון של כוונון אוטומטי שמבוסס על דיסק, אם הן זמינות, או חזרה להיוריסטיקה מובנית (ראו
BoundArguments.default_config). - סדרתיות של מטא-נתונים ב-StableHLO: כדי לאפשר בדיקה של תוכנות מקומפלות לצורך יצירת פרופילים אופליין וכוונון אוטומטי, מחלקת הבסיס מטמיעה מטא-נתונים של אופרטורים בתרשים המופחת, כך שכלים במורד הזרם יכולים לשחזר אילו אופרטורים הופעלו ועם אילו קלטים (צורות, סוגים וכו') ישירות ממודול מקומפל או מפרופיל ביצועים (ראו
_tokamax_metadata()). - הרצה קדימה ו-VJP בהתאמה אישית: מכיוון שלעיתים קרובות לא ניתן להבדיל ביעילות בין ליבות חומרה ייעודיות באמצעות הבחנה אוטומטית רגילה, המחלקה הבסיסית מתאמת את ההרצה קדימה ואחורה כזוג, ומאפשרת למעבר קדימה להעביר ערכי ביניים ישירות לליבה אחורה בהתאמה אישית במהלך חישוב השיפוע (ראו
op._fwd()) וקריאות ל-jax.custom_vjp.
מחלקה בסיסית ספציפית לפעולה
כל משפחת אופרטורים מגדירה מחלקה בסיסית משלה, שיורשת ממחלקת האופרטורים הבסיסית ויוצרת את החוזה שמשותף לכל הקצוות העורפיים (לדוגמה, ראו RaggedDot):
- הטמעת קובץ עזר: כל מחלקה בסיסית של אופרטור מספקת הטמעת קובץ עזר נייד וטהור של JAX של המפרט המתמטי המלא, כולל גרדיאנטים, אם רלוונטי. הוא משמש כאמת קרקע (ground truth) לבדיקות של נכוֹנוּת מספרית, ומבטיח חלופה תקינה בכל חומרה (ראו
RaggedDot._fwd()). - כריכה קנונית מכיוון שמשתמשים יכולים לבטא את אותה פעולה מתמטית במספר דרכים - כגון העברת צורות שונות של מסכות, הגדרות דיוק או מפרטי ממד - מחלקת הבסיס של האופרטור מנרמלת קלטים ובודקת תאימות צורה וסוג מראש, כך שחלקי חומרה בודדים צריכים לטפל רק בפורמט קלט יחיד וצפוי (ראה
RaggedDot.bind()).
מחלקות להטמעת אופרטורים
המחלקות האלה מספקות את ההטמעות של הליבה הספציפיות לחומרה, והמשתמשים יכולים ליצור להן מופעים ולהפעיל אותן ישירות. כל הטמעה יורשת מהמחלקה הבסיסית הספציפית לאופרטור ומספקת את ההתנהגות הספציפית לקצה העורפי (לדוגמה, ראו PallasMosaicTpuRaggedDot):
- פונקציונליות עיקרית: כאן מוגדרת ההפעלה בפועל של ליבת החומרה, בדרך כלל באמצעות שפת ליבה כמו Pallas. כשפעולה דורשת מעבר לאחור מיוחד, ליבת הגרדיאנט בדרך כלל מעוצבת כהטמעה של אופרטור משלה, כך שאפשר להגדיר, לכוונן ולבדוק אותה בנפרד. למרות שקוד הליבה ברמה הנמוכה ביותר מופרד לעיתים קרובות לקובץ עזר נפרד לצורך מודולריות, המחלקה הזו משמשת כממשק הראשי להפעלת הליבה הזו (ראו
PallasMosaicTpuRaggedDot._fwd()). - הגדרה: מכיוון שקרנלים של חומרה חושפים לעיתים קרובות כפתורי ביצועים – כמו גודלי משבצות, שלבי צינור עיבוד נתונים או אסטרטגיות של מאגר נתונים זמני (buffer) בזיכרון, כל קצה עורפי מגדיר מבנה הגדרה ייעודי שמאפשר למשתמשים או לכלים אוטומטיים לקבוע איך הקרנל מחולק, עובר הידור ומופעל (ראו
Config). - היוריסטיקה: לא כל עומס עבודה עבר כוונון אוטומטי מראש, ולכן כל קצה עורפי מספק היוריסטיקה מובנית שבוחרת פרמטרים סבירים של כוונון כברירת מחדל, על סמך מאפייני הבעיה, סוגי הנתונים והמפרטים של המאיץ (ראו
_get_heuristics_config()). - מרחב חיפוש לכוונון אוטומטי: בעומסי עבודה שבהם ביצועי השיא חשובים, כל קצה עורפי מגדיר מרחב חיפוש לכוונון אוטומטי של שילובי פרמטרים תקינים לצורה נתונה של בעיה, וכך מאפשר לכוונון האוטומטי להשוות בין מועמדים ולגלות את ההגדרה המהירה ביותר (ראו
_get_autotuning_configs()). - אימות ספציפי להטמעה: לקרנלים של חומרה יש לעיתים קרובות דרישות מחמירות יותר מאשר לפעולה המתמטית הכללית, כמו כללי יישור של ממדים או תמיכה מוגבלת בסוגי נתונים. כל הטמעה מאמתת את המגבלות האלה ומאותתת כשאי אפשר לטפל בעומס עבודה, וכך מאפשרת למערכות ניהול ברמה גבוהה יותר לחזור בצורה חלקה לקצה עורפי אחר (ראו
PallasMosaicTpuRaggedDot._fwd()).
High-Level API
לרוב האופרטורים יש כמה קצוות עורפיים – כמו הטמעת קובץ עזר נייד לצד ליבה אחת או יותר ספציפית לחומרה – והם חושפים נקודת כניסה אחת מוכרת ברמה גבוהה (למשל, פונקציית jax.lax רגילה). השכבה הזו נועדה לתת למשתמשים ממשק פשוט וקל להטמעה שבוחר באופן אוטומטי את הקצה העורפי הנתמך הטוב ביותר לחומרה ולצורות הקלט שלהם, ועדיין מאפשר להם לבקש הטמעה ספציפית כשהם רוצים (ראו tokamax.ragged_dot()).
ArgSpecs
כדי לבדוק ולשפר את הליבות באופן עקבי בכל הקצוות העורפיים, חשוב לשמור קטלוג משותף של צורות חשובות של עומסי עבודה. Tokamax מתעד את צורות הייצור וההשוואה המייצגות האלה כמפרטי עומס עבודה שמשותפים לכל ההטמעות של אופרטור. כך אפשר להגדיר מקור אמת יחיד לבדיקות של שילוב רציף, למדדי השוואה של רגרסיה ולצינורות עיבוד נתונים של כוונון אוטומטי, ולסנן אותו לפי תגים לתהליכי עבודה שונים (ראו את ArgSpecs של ragged_dot).
מבנה המאגר
קוד ההטמעה הפנימי נמצא בעץ המקור הפרטי (ראו tokamax/_src), וסמלים ציבוריים של אופרטורים, כוונון אוטומטי, השוואה לשוק והגדרות מיוצאים מחדש דרך מודולים ברמה העליונה (ראו tokamax/__init__.py).
בכל ספריית מפעיל (ראו tokamax/_src/ops), הקבצים נקראים לפי מוסכמה עקבית, שמוצגת כאן באמצעות נקודות:
- High-Level API: מגדיר את נקודת הכניסה הפונקציונלית הציבורית ואת לוגיקת השליחה לקצה העורפי (ראו
api.py). - מחלקה בסיסית ספציפית לפעולה: מגדירה את הטמעת ההפניה הניידת (ראו
base.py). - הטמעות בקצה העורפי: מגדירות מחלקות של אופרטורים, הגדרות אישיות, היוריסטיקה ומרחבי כוונון אוטומטי ספציפיים לחומרה (ראו
pallas_mosaic_tpu.py). - קרנלים ברמה נמוכה: הפרדה בין הטמעות קרנל עצמאיות לבין רכיבי עזר משותפים ברמה נמוכה למודולים נלווים (ראו
pallas_mosaic_tpu_kernel.py). - מפרטי עומסי עבודה: קטלוגים של צורות קלט קנוניות לבדיקה, להשוואה ולכוונון אוטומטי (ראו
arg_specs.py). - חבילות מקרים לבדיקה: מגדירות בדיקות תקינות משותפות עם פרמטרים, לצד חבילות מקרים לבדיקה לכל קצה עורפי (ראו
test_base.py).
הפעולות בספרייה experimental פועלות במבנה דומה, אבל יכול להיות שהן לא יהיו חשופות ב-API הציבורי. הפעולות האלה מיועדות לאיטרציה ולבדיקה מהירות, והן עשויות להשתנות לעיתים קרובות ובאופן משמעותי. בדרך כלל, הציפיות לגבי תחזוקה ותמיכה שוטפות נמוכות יותר.
איזו שכבה המשתמשים צריכים להפעיל
הבחירה בנקודת כניסה היא למעשה פשרה בין נוחות לשליטה. רוב המשתמשים צריכים להתחיל בקריאה לאופרטורים דרך ה-API הפונקציונלי ברמה גבוהה, שמספק ממשק בסגנון מוכר ובוחר באופן אוטומטי הטמעה מתאימה של בק-אנד. כשצריך לבחור קצה עורפי דטרמיניסטי, המשתמשים יכולים להעביר בחירת הטמעה מפורשת לפונקציה ברמה גבוהה, תוך שמירה על אותה חתימת קריאה. כדי לקבל שליטה מקסימלית, המשתמשים יכולים ליצור מופע של מחלקת הטמעה של אופרטור ספציפי ישירות כדי להתאים אישית היפר-פרמטרים של ליבה – כמו גודלי משבצות – ולהעביר ארגומנטים ספציפיים לקצה העורפי.
לא מומלץ להפעיל פונקציות ליבה ברמה נמוכה ישירות בלי לעבור דרך מחלקת הטמעה של אופרטור. פעולה כזו עוקפת תשתית חיונית – כולל כוונון אוטומטי, אימות קלט וקנוניזציה, וסריאליזציה של מטא-נתונים – בלי להציע חיסכון משמעותי בתקורה, כי מעטפות האופרטורים הן קלות משקל בכוונה. לדוגמה, אם אין היפר-פרמטרים מתאימים לכוונון אוטומטי, סביר להניח שהמשתמשים יראו ביצועים נמוכים משמעותית.
נושאים מתקדמים
מיזוג אופרטורים
אופרטורים של Fusible Pallas TPU תומכים במיזוג של פרולוגים ואפילוגים של JAX ישירות לתוך הליבה באמצעות @tokamax.ops.op_fusion.fuse. במדריך Operator Fusion מוסבר איך להשתמש ב-Operator Fusion ואיך ליצור ליבות וסוגי משנה של Op שתואמים ל-Fusion.
סידור הפרקים
אפשר להמיר קרנלים ל-StableHLO. קריאות לקרנל הן קריאות בהתאמה אישית של JAX, שבברירת המחדל אסורות ב-jax.export, ולכן צריך להשתמש ב-tokamax.DISABLE_JAX_EXPORT_CHECKS כדי לאפשר ייצוא של כל הקרנלים של Tokamax:
from jax import export
f_grad_exported = export.export(f_grad, disabled_checks=tokamax.DISABLE_JAX_EXPORT_CHECKS)(
jax.ShapeDtypeStruct(x.shape, x.dtype),
jax.ShapeDtypeStruct(scale.shape, scale.dtype),
)
חשוב לשים לב שפונקציות שעברו סריאליזציה עם ליבות Tokamax מאבדות את חוסר התלות במכשיר של StableHLO רגיל. Tokamax מספק שתי התחייבויות לסדרתיות:
- פונקציה שעברה דה-סריאליזציה וסריאליזציה במכשיר ספציפי מובטח שתפעל במכשיר המדויק שעבורו היא עברה סריאליזציה.
- Tokamax מספק את אותן התחייבויות לתאימות כמו JAX: תאימות לדורות קודמים למשך 6 חודשים.
עיבוד בין מערכות וייצוא מעבד (CPU)
אפשר לייצא או לעבד בין מערכות את הליבות של Tokamax במארח של מעבד (CPU):
- בחירה מפורשת של הטמעה (למשל
implementation="mosaic_tpu_v2") עוקפת באופן אוטומטי את האימות של המכשיר המארח. - לחלופין, אפשר להפעיל עיבוד בין מערכות באופן גלובלי באמצעות
tokamax.config.cross_compile(True):
with tokamax.config.cross_compile(True):
f_exported = export.export(
f, disabled_checks=tokamax.DISABLE_JAX_EXPORT_CHECKS
)(
jax.ShapeDtypeStruct(x.shape, x.dtype),
...,
)