‫PyTorch ב-Cloud TPU

‫PyTorch ב-Cloud TPU מאפשר לאמן, לכוונן ולהציג מודלים בקוד פתוח בחומרה של Cloud TPU באמצעות סמנטיקה סטנדרטית של PyTorch, ממשקי API מבוזרים והכלים בסביבה העסקית שכבר נמצאים בשימוש, כולל Hugging Face,‏ vLLM,‏ SGLang,‏ llm-d,‏ TorchTitan,‏ TorchRec ו-Ray.

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

‫TorchTPU מחובר ל-Hugging Face, ל-TorchTitan, ל-vLLM, ל-SGLang, ל-Ray ול-llm-d, עם torch.profiler,‏ DTensor,‏ TorchRec ו-Pallas.

קדימה, מתחילים

  • הרצת מודלים של PyTorch ב-TPU: מתחילים עם TorchTPU והמסמכים של TorchTPU.
  • הצגת מודלים גדולים של שפה (LLM) ומודלים מולטי-מודאליים: משתמשים ב-vLLM-TorchTPU או ב-SGLang-TorchTPU.
  • ניתוב בקשות ב-Kubernetes fleet: משתמשים ב-llm-d.
  • אימון מראש או כוונון של מודלים בסיסיים: משתמשים ב-TorchTitan ב-TPU (או ב-TorchRec למודלים של המלצות).
  • להרחיב את עיבוד הנתונים, האימון, ה-RL וצינורות עיבוד הנתונים להצגת מודעות: באמצעות Ray.
  • הכשרה, יצירת פרופילים וכוונון של מודלים בעזרת עזרה בתכנות: משתמשים ב-TPU agent suite (גרסת טרום-השקה).

‫TorchTPU: קצה עורפי מקורי של PyTorch ל-Cloud TPU

‫TorchTPU מספק את הקצה העורפי של המכשיר, שילוב של מהדר גרפים וממשקי API של ליבה בהתאמה אישית ל-PyTorch ב-Cloud TPU. ‫TorchTPU פותח בשיתוף עם צוות PyTorch, והוא מאפשר לנפות באגים במודלים באופן אינטראקטיבי במצב eager, לקמפל קוד של מודלים באמצעות torch.compile ולהרחיב את הפרוסות באמצעות torch.distributed (tpu_dist).

כדי להתקין את TorchTPU ולהריץ פעולת טנזור ב-Cloud TPU:

pip install torch_tpu

import torch

device = torch.device("tpu")

x = torch.randn((4, 4), device=device)
y = torch.ones((4, 4), device=device)
result = torch.matmul(x, y).cpu()

print(f"Executed on device: {x.device}")
print(f"Result shape on CPU: {result.shape}, sum: {result.sum():.4f}")

למה בחרנו לעשות זאת?

בעבר, יחידות ה-Cloud TPU היו משולבות עם JAX ו-TensorFlow, והפעלת PyTorch ב-TPU דרשה הקלטת תרשים של lazy-tensor‏ (PyTorch/XLA). בדרך כלל זה אומר שצריך להוסיף קוד כדי לסמן אזורים שניתנים להידור. כברירת מחדל, TorchTPU מריץ פעולות באופן מיידי באמצעות מודל ההרצה הרגיל של PyTorch, שבו כל מכשיר מריץ תהליך אחד. לכן, עומסי עבודה וספריות קיימים פועלים בלי שצריך לשכתב את המבנה שלהם.

עיצוב

‫TorchTPU מספק תמיכה מובנית ב-TPU ל-PyTorch, עם שלוש מטרות עיצוב:

  • סמנטיקה רגילה של PyTorch: מריצה תהליך אחד לכל מכשיר ושומרת על תצוגות טנזור של PyTorch ומוטציות במקום, בלי תלות בזמן ריצה של JAX.
  • הרצה מיידית כברירת מחדל: מודלים רגילים של PyTorch פועלים באופן מיידי במצב הרצה מיידית, כדי לאפשר ניפוי באגים אינטראקטיבי ובדיקה הדרגתית.
  • אופטימיזציות של קומפיילר וליבה: בנוסף להפעלה מיידית של כל אופרטור בנפרד, TorchTPU מספק מיזוג אופרטורים במצב מיידי, שילוב של torch.compile עם גבולות צורה דינמיים כדי לצמצם את הצורך בקימפול מחדש, וממשקי API של ליבה בהתאמה אישית.

כדי לקמפל את התרשים, torch.compile מתעד את תרשים החישוב של PyTorch באמצעות TorchDynamo ומקמפל אותו לשפת מכונה של TPU באמצעות OpenXLA ו-StableHLO. פעולות קולקטיביות פועלות ברמת קבוצת התהליכים של torch.distributed (tpu_dist).

נקודות החוזק העיקריות

  • תמיכה באופרטורים, במודלים וב-Hugging Face: TorchTPU תומך באופרטורים סטנדרטיים של PyTorch (ATen)‎ במעברים קדימה ואחורה, ונבדק באופן קבוע מול מודלים פופולריים של Hugging Face. אתם יכולים לפרוס מודלים ב-Transformers v5 על ידי העברת device_map="tpu", להריץ צינורות עיבוד נתונים של Diffusers במצב eager, ‏ torch.compile, ו-tensor parallelism, ולנתח עומסי עבודה באמצעות torch.profiler ב-TensorBoard וב-XProf.
  • שינוי קנה מידה מצ'יפ יחיד לריבוי-פרוסות (Multislice): הקצה העורפי של tpu_dist תומך ב-DistributedDataParallel ‏(DDP), ב-FullyShardedDataParallel ‏(FSDP2) וב-DTensor. בנוסף, torch.tpu.distributed.topology_aware_mesh ממפה את ממדי ההקבלה לחיבורים הפיזיים של ה-TPU.
  • מצבי ביצוע מיידיים שניתנים להגדרה: מספק שלושה מצבי ביצוע מיידיים:
    • Strict (ברירת מחדל): שולח אופרטורים בנפרד ובאופן אסינכרוני, עם סמנטיקה אימפרטיבית סטנדרטית של PyTorch.
    • ‫Debug: פועל באופן סינכרוני עם בדיקת גבולות של טנזור.
    • ‫DeferAndFuse: ממזג רצפים של אופרטורים להערכה מיידית כדי להפחית את התנועה בזיכרון ברוחב פס גבוה (HBM).
  • קומפילציה ושמירה במטמון של גרפים מלאים: torch.compile(backend="tpu") מקמפל גרפים לקובצי הפעלה של TPU ושומר אותם במטמון בתהליכים, במארחים ובהפעלות מחדש של משימות.
  • קרנלים מותאמים אישית של TPU: אתם יכולים להפעיל קרנלים מותאמים אישית של Pallas, כולל קרנלים שמתקשרים ישירות בין שבבים, כפונקציות PyTorch רגילות, להשתמש בקרנלים מוכנים מראש מהספרייה Tokamax או ליצור קרנלים ניידים מבוססי-משבצות באמצעות Helion.

למידע נוסף, אפשר לעיין במסמכי התיעוד של TorchTPU, לשאול שאלות בפורום הדיון של PyTorch ב-TPU או לדווח על בעיות ב-GitHub.

הסקה והצגה בסביבת ייצור

לפריסה בסביבת ייצור, PyTorch ב-Cloud TPU משתלב עם מנועי הסקה בקוד פתוח ועם תשתית להצגת מודלים מבוזרים ב-Kubernetes.

‫vLLM-TorchTPU ו-SGLang-TorchTPU: מנועי הסקה

‫vLLM-TorchTPU ו-SGLang-TorchTPU הם קצוות עורפיים של TorchTPU למנועי ההסקה vLLM ו-SGLang. שני ה-backends מריצים מודלים פתוחים כמו Qwen,‏ DeepSeek,‏ GLM,‏ Kimi,‏ GPT-OSS ו-Gemma 4. למידע נוסף, קראו את הפוסט בבלוג הכרזה על מנועי הסקה חדשים של vLLM ו-SGLang ב-TPU.

למה בחרנו לעשות זאת?

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

עיצוב

שני ה-backends שומרים על מתזמנים רגילים של vLLM ו-SGLang, מנהלי מטמון של KV ושרתי API, תוך שימוש בהפעלה של TorchTPU ובאופרטורים מותאמים אישית של Pallas. רוב המודלים מריצים את הגדרות המודל הרגילות של PyTorch, ובלוקים שדורשים הרבה משאבי מחשוב מפעילים קרנלים של Pallas בתוך התרשים המקומפל, כדי שאפשר יהיה לעדכן קרנלים ספציפיים לחומרה באופן עצמאי.

נקודות החוזק העיקריות

  • מקביליות, קוונטיזציה ופענוח ספקולטיבי: תמיכה במקביליות של טנזורים, נתונים, מומחים, צינורות עיבוד נתונים והקשרים בין מארחים, וגם בקלט מולטי-מודאלי (תמונות וסרטונים) והטמעות. שיטות הפענוח הספקולטיבי הנתמכות כוללות חיזוי של כמה אסימונים (MTP),‏ EAGLE-3,‏ DFlash,‏ DSpark והתאמת n-gram. פורמטים נתמכים של קוונטיזציה כוללים מטמונים של KV של 8 ביט (FP8) ונקודות ביקורת של מודלים של נקודה צפה (floating-point) של 8 ביט (FP8) ו-4 ביט (MXFP4 ו-NVFP4).
  • שמירה במטמון של תחיליות בשתי רמות, קריאה לפונקציות ופלט מובנה: שמירה אוטומטית במטמון של תחיליות (כולל למודלים של קשב היברידי ומודלים חוזרים) שומרת תחיליות פעילות ב-HBM ומעבירה תחיליות ישנות יותר לזיכרון המארח כדי למנוע חישוב מחדש בבקשות עם כמה סבבים. הקריאה לפונקציות והפלט המובנה כבר מובנים.
  • העברות חופפות של מטמון KV באמצעות TPU Sync: תמיכה בהצגה מפורקת של מילוי מראש ופענוח (הפרדה בין עיבוד ההנחיות לבין יצירת הטוקנים למאגרי עובדים נפרדים) בין מארחים, ופריקה של KV מהמארח באמצעות TPU Sync. ‫TPU Sync היא ספריית C++‎ בקוד פתוח שקוראת מאגרי נתונים זמניים של מכשירי PyTorch ישירות בשרשורים ברקע, בלי להעתיק נתונים דרך זיכרון המארח של המעבד (CPU).

מידע נוסף על vLLM-TorchTPU זמין במאגר vLLM-TorchTPU. אתם יכולים גם לשאול שאלות בערוץ Slack של vLLM או לדווח על בעיות ב-vLLM-TorchTPU ב-GitHub.

מידע נוסף על SGLang-TorchTPU זמין במאגר SGLang-TorchTPU. אפשר גם לדווח על בעיות ב-SGLang-TorchTPU ב-GitHub.

‫llm-d: הסקת מסקנות מבוזרת ב-Kubernetes

‫llm-d הוא מסגרת ארגז חול (sandbox) בקוד פתוח של Cloud Native Computing Foundation ‏(CNCF) להסקת מסקנות מבוזרת של LLM ב-Kubernetes, שפותחה בשיתוף עם Red Hat, ‏IBM, ‏ Google Cloudוקהילה של יותר מ-500 תורמים ו-35 ארגונים.

למה בחרנו לעשות זאת?

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

עיצוב

‫llm-d פועל לפני שרתי מודלים כמו vLLM ו-SGLang ב-Kubernetes, ומספק את הדברים הבאים:

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

נקודות החוזק העיקריות

  • ניתוב סשנים בכמה שלבים: ניתוב שיחות בכמה שלבים לרפליקות שמכילות את ההקשר שלהן במטמון. תזמון לפי סדר עדיפויות של תורות ותמיכה ב-Stateful Responses API מאפשרים לסוכנים להשתמש בהקשר בתורות שונות כדי לצמצם את החישוב מחדש.
  • איכות השירות של ריבוי דיירים: בקרת זרימה של עדיפות והוגנות מאפשרת לבקשות שרגישות לזמן אחזור ולעומסי עבודה של סוכנים מתפרצים לחלוק צי בלי מחסור במשאבים.
  • פעולות בצי ועדכונים בהדרגה (rolling): מספק ממשק API להגדרות בגרסה 1, זמינות גבוהה של הנתב ועדכונים מתואמים בהדרגה (rolling) שמנהלים את הרפליקות של המילוי מראש והפענוח כיחידה לוגית אחת.
  • הצגה מקורית של TorchTPU ב-GKE: אתם יכולים להציג יחידות Cloud TPU לצד מאיצים אחרים מאחורי נקודת קצה אחת של llm-d, ולנהל רפליקות של vLLM-TorchTPU ו-SGLang-TorchTPU באמצעות כלים רגילים של Kubernetes.

למידע נוסף, אפשר לשאול שאלות בערוץ Slack של llm-d, או לדווח על בעיות ב-GitHub.

ספריות לאימון, לכוונון עדין ולדומיינים

כדי לאמן מראש, לכוונן ולהתאים מודלים גדולים, TorchTPU מספק מתכוני אימון לדוגמה וספריות ספציפיות לדומיין שמותאמות לחומרת TPU.

‫TorchTitan ב-TPU: חומר עזר לאימון בקנה מידה גדול

‫TorchTitan ב-TPU מרחיב את TorchTitan, פלטפורמת העזר המודולרית של PyTorch לאימון AI גנרטיבי, עם מעברי פיצול נתונים (sharding) ב-TPU, ליבות בהתאמה אישית ומתכוני אימון. מידע נוסף זמין בפוסט בבלוג Integrating TorchTPU into TorchTitan and Optimizing Models for TPU.

למה בחרנו לעשות זאת?

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

עיצוב

המודלים כתובים ב-PyTorch למכשיר יחיד, בלי קוד ספציפי למאיץ. ‫TorchTitan מגדיר שכבות של מודלים מקובצי תצורה, ומאפשר להחליף שכבות ספציפיות בקרנלים מותאמים אישית של Pallas (כמו Splash Attention) בלי לערוך את הגדרת המודל או את לולאת האימון.

בהטמעה של TorchTitan ב-SimpleFSDP, פעולות חלוקת הפרמטרים לחלקים מתבצעות ישירות בתוך התרשים המקומפל, כך שהקומפיילר של XLA יכול לחפוף בין התקשורת של המכשיר לבין החישוב, וקומפילציית התרשים של השלב כולו מתעדת את כל שלב האימון כתוכנית XLA אחת. בהרצות של ריבוי-פרוסות, חלוקה היברידית לפלחים (HSDP) מחלקת לפלחים בתוך כל פרוסה דרך החיבור בין השבבים (ICI) ומשכפלת בין הפרוסות דרך הרשת של מרכז הנתונים (DCN). הפריסה הזו מגבילה את התנועה בין הפרוסות להפחתת גרדיאנט אחת לכל שלב.

נקודות החוזק העיקריות

  • מתכונים לאימון מוקדם ולאימון RL לאחר מכן: כולל מתכונים לדוגמה למודלים צפופים של LLM ‏ (Llama 3,‏ Qwen 3 ו-MuseGlimmer 30B), למודלים של שילוב מומחים (MoE) ‏ (Qwen 3 235B, אומת על עד 8,192 שבבי TPU7x) ולטרנספורמרים של דיפוזיה (FLUX.1). באימון RL לאחר אימון (כמו Group Relative Policy Optimization, או GRPO), ‏VeRL (גרסת טרום-השקה (Preview)) מעביר את עדכוני הפרמטרים ל-TorchTitan ודוחף את המשקלים המעודכנים למנועי הצגת המודעות כדי ליצור מסלולי אימון (השקות).
  • הגדרות קומפיילר ומקביליות מוגדרות מראש: הגדרות המתכונים כוללות הגדרות קומפיילר ומקביליות מוגדרות מראש, כדי שתוכלו לשנות את ניצול ה-FLOPs של המודל (MFU) באמצעות קובצי תצורה במקום שינויים בקוד.
  • הכשרת עובדים חדשים לארכיטקטורות חדשות: הקצה העורפי של המודלים של Hugging Face Transformers מריץ נקודות ביקורת של מודלים של Hugging Face Hub (כולל מודלים של MoE ללא מומחיות מקבילה) דרך מאמן TorchTitan. לפורטים מלאים של מודלים, TorchTitan כולל מיומנות הדרכה שלב אחר שלב למהנדסים ולסוכני תכנות.
  • שימוש חוזר ברכיבים עצמאיים: אתם יכולים להשתמש ב-TorchTitan מקצה לקצה או לייבא מודולים נפרדים, אופרטורים בהתאמה אישית ודגלי קומפיילר לבסיס קוד קיים של אימון.

מידע נוסף זמין במדריך לתחילת העבודה עם TorchTitan ב-TPU. אתם יכולים גם לשאול שאלות בפורום הדיונים של PyTorch או לדווח על בעיות ב-GitHub.

‫TorchRec: מערכות המלצות

‫TorchRec היא ספריית דומיינים של PyTorch שמספקת טבלאות הטמעה מבוזרות ופרימיטיבים של פיצול למודלים של המלצות. ב-Cloud TPU,‏ TorchRec מעביר את החיפושים בטבלאות הטמעות דלילות למעבדי TPU SparseCore ייעודיים, בזמן שהוא מריץ פעולות של מטריצות צפופות ב-TPU TensorCores.

מידע נוסף על TorchRec זמין במסמכי התיעוד של TorchRec. אתם יכולים גם לשאול שאלות בפורום הדיון של PyTorch ב-TPU או לדווח על בעיות ב-GitHub.

כלים למפתחים ולתזמור אשכולות

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

‫Ray: אימון מבוזר, הצגה ו-RL

Ray משמש להרחבת עומסי העבודה של Python ו-AI באשכולות באמצעות Ray Train,‏ Ray Serve,‏ Ray Data,‏ Ray Core ומסגרות RL כמו verl.

למה בחרנו לעשות זאת?

אימון של ריבוי-פרוסות ופייפליינים עם כמה שלבים (כמו תהליכי עבודה של RL שמשלבים עיבוד מראש של נתונים, אימון ויצירת פריסה) דורשים הקצאה אוטומטית של פרוסות, גילוי טופולוגיה ותיאום בין workers עמיד בכשלים. כלי הפעלה עצמאיים כמו torchrun לא מקצים פרוסות TPU או מתאמים צינורות עיבוד נתונים של שחקנים בכמה שלבים, ולכן Ray מנהל את התזמון והמיקום של עומסי העבודה של TorchTPU בכל האשכול.

עיצוב

כששולחים משימה ומציינים את דור ה-TPU, הטופולוגיה ומספר ה-workers, ‏Ray שומר פרוסות TPU שלמות כדי שכל ה-workers בפרוסה יתוזמנו ביחד, מגלה את כתובות החיבורים של השבבים ומפעיל worker אחד של PyTorch לכל מכשיר TPU. ה-backend של PyTorch ב-Ray Train מאתחל את מכשיר tpu ואת קבוצת התהליכים tpu_dist באופן אוטומטי לפני התחלת המשימה.

נקודות החוזק העיקריות

  • מיקום תואם לטופולוגיה: התאמה של מיקום ה-worker במארחים לפריסת הפרוסות ולדור ה-TPU הפיזי.
  • שחזור אוטומטי אחרי כשל: הרצת משימות אימון מבוזרות בכמה פרוסות TPU ב-GKE, עם שחזור אוטומטי במקרה של כשל ב-worker או בפרוסה.
  • אחזור מראש של נתונים ישירות ל-TPU: השיטה iter_torch_batches של Ray Data מאחזרת מראש אצוות כטנזורים של PyTorch ישירות לזיכרון של מכשיר ה-TPU.
  • תזמור של הסקת מסקנות בכמה מארחים: ניהול של פריסות להצגה בכמה מארחים ל-vLLM-TorchTPU ול-SGLang-TorchTPU.

‫TPU agent suite: (גרסת טרום-השקה) סוכני תכנות ל-TPU

חבילת הסוכנים של TPU היא תוסף בקוד פתוח לעוזרי תכנות – כולל Claude Code ו-Google Antigravity, וסוכני תכנות נוספים בהמשך – שמתמקד בהסקת טרנספורמר (מודלים של LLM דחוסים ו-MoE) ב-TPU v6e וב-TPU7x.

למה בחרנו לעשות זאת?

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

עיצוב

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

נקודות החוזק העיקריות

  • הכשרת מודלים ואימות הדיוק: הסוכן TPU Model Onboarding פותר בעיות של אופרטורים לא נתמכים, בוחר נתיב להצגת מודעות (vLLM-TorchTPU או PyTorch רגיל) ומשווה בין פלטים של שכבה אחר שכבה לבין מודל העזר של המעבד (CPU) כדי לאמת את הדיוק המספרי.
  • אבחון של קריסות וצווארי בקבוק: סוכן האבחון של ה-TPU מנתח את יומני הקריסה, בודק את הפרופילים של XProf ואת המעקבים של מהדר ה-XLA, ומבודד את צווארי הבקבוק בזמן הריצה.
  • אופטימיזציה של ליבה, קומפיילר ופיצול (sharding): סוכן פיתוח הליבה של ה-TPU עוזר עם ליבות Pallas בהתאמה אישית, סוכן אופטימיזציית הביצועים של ה-TPU משווה בין שילובים של דגלי קומפיילר XLA, וסוכן הפיצול של ה-TPU מתכנן פריסות מקבילות של ריבוי-פרוסות (multislice).
  • חיפוש במסמכי תיעוד עם ציטוטים: הסוכן של מאגר הידע של TPU עונה על שאלות טכניות עם ציטוטים מפורשים ממסמכי תיעוד ומדריכים רשמיים של TPU, ומציין אם נושא מסוים לא נכלל.

מידע נוסף זמין במסמכי התיעוד של TPU agent suite. אתם יכולים גם לשתף משוב ולשאול שאלות בדיונים ב-GitHub, או לדווח על בעיות ב-GitHub.

המאמרים הבאים