Latest / M365.FM – פודקאסט Microsoft 365, Copilot ובינה מלאכותית בעברית / הסקה איטית ב-GPU: נפילה ל-CPU, התנגשויות גרסאות CUDA/TensorRT ותקלות קונטיינרים (דיבוב AI)

Transcript

הסקה איטית ב-GPU: נפילה ל-CPU, התנגשויות גרסאות CUDA/TensorRT ותקלות קונטיינרים (דיבוב AI) · M365.FM – פודקאסט Microsoft 365, Copilot ובינה מלאכותית בעברית

• 0:00
  זה התחיל בהזהרה, ואז שקט.
• 0:02
  חשבון ה-GPU עלה כאילו המעיץ לא ישן מעולם.
• 0:05
  ובכל זאת התפוקות זחלו כאילו האורות קבו.
• 0:07
  לוחות המכוונים היו ירוקים, הלקוחות לא.
• 0:10
  החריגה לא התאים על התמונה.
• 0:11
  ניצול GPU קרוב לאפס בזמן שהשהיה זינקה.
• 0:15
  לא הופעלו התראות, לא היו קווים אדומים, רק זמן שהתעדה.
• 0:18
  הראיות מצביעות על פתולוגיה אחת שמתחזה למצב תקין.
• 0:22
  הנה ההבטחה.
• 0:23
  נעקוב אחר הממצאים, נזהה את האשם, ונתקן את הפתולוגיה.
• 0:27
  נבחן שלושה מצבי קשר, גיבוי למעבד, CPU,
• 0:30
  חוסר התאמת גרסאות בין קודה לאונט סטנסר RT,
• 0:33
  ותצורת קונטיינר שגויה, ונוכיח זאת באמצעות השיה,
• 0:36
  תפוקה וניצול GPU לפני ואחרי.
• 0:38
  הגדרת המקרה, הסביבה ופרופיל הקורבן.
• 0:41
  כל קונפיגורציה מספרת סיפור, והסיפור הזה מתחיל בדייר רגיל תחת לחץ.
• 0:46
  אומס העבודה הוא דיפוזיה מטקסט לתמונה,
• 0:47
  גרסאות סטייבל דיפוז'ון שרצות בית מינוס 512 על 512 ומתרחבות למד מינוס 1024 על 1024.
• 0:54
  התעבורה התנודתית.
• 0:55
  הקונקורנסי נע בין 8 למד מינוס 32 בקשות.
• 0:58
  גדלי העצבות משתנים בין 1 למד מינוס 8.
• 1:00
  רמות השירות מחמירות לגבי השיית זנב.
• 1:02
  חריגות בפי 95 מתורגמות ישירות לזיקויים וכנסות.
• 1:05
  המודלים אינם אקזוטיים, אבל הבחירות שלהם קריטיות.
• 1:08
  צינורות עיבוד של סטייבל דיפוז'ון מיוצאים לאונקס,
• 1:11
  אופטימיזציות של תשומת לב צולבת כמו X4 Mars או Scale.Product Attention,
• 1:15
  ובחירות מתזמן שסוחרות בצעדים עבור איכות.
• 1:17
  המערכת האקולוגית אמורה להעיץ כאשר התשתית תקינה.
• 1:20
  החומרה נראית מכובדת על הנייר.
• 1:22
  כרטיסי אנווידיה מסדרת RTX ואה בענן עם 16 עד 32 גיגה בייט וירם.
• 1:27
  ה-PCIE יושב בין המערך להתקן כמו עמדת תשלום.
• 1:30
  מהיר מספיק כשהוא מוגדר, מעניש כשפעולות כלת פלט חוזרות להעברות הניתנות לדפדוף.
• 1:34
  בסביבה הזו, שום דבר אינו מקרי.
• 1:36
  שרשרת הכלים מוערמת בשכבות מוכרות.
• 1:38
  PyTorch משמש לייצוא, ואז אונאקס רנדהים או TensorRT משתלטים לצורך עסקה.
• 1:42
  מנהלי הטקן קודה יושבים מתחת להקל.
• 1:45
  גרעיני תשומת לב מבטיחים מהירות עם הגרסאות תואמות.
• 1:48
  הפריסה היא בקונטיינרים בלבד, תמונות בלתי ניתנות לשינוי,
• 1:51
  פריסות בניהול C ומדיניות כחול ירו.
• 1:53
  המגבלה הזו אמורה ליצור בטיחות.
• 1:55
  היא יכולה גם להקפיא פגמים בתוך אינבר.
• 1:57
  הסיכונים העסקיים אינם מופשטים.
• 1:59
  עלות לכל בקשה מגדירה את הרווח.
• 2:01
  הזמנות GPU מתומחרות לפי שעה, בין אם הגרעינים רצים ובין אם לא.
• 2:05
  כשההשייה נמתחת משניות לחצי דקה, התפוקה קורסת.
• 2:08
  קונפיגורציה שגויה אחת הופכת מעיץ לתנור חימום, יקר, שקט,
• 2:12
  ועסוק בלא לעשות כלום שתורם לתור.
• 2:14
  בבחינה מדוקדקת יותר, פרופיל הקורבן מצטמצם.
• 2:17
  קונקורנסי בית מינוס 16, עצבות ב-2 כדי להישאר מתחת לתקרות הוורם בית מינוס 512 עם עלייה למד מינוס 1024 לאיכות.
• 2:24
  הדייר מצפה לפי 95 עקבי.
• 2:27
  במקום זאת, העקבות מראים השהיות לא יציבות, דלתאות רחבות בין פי 50 לפי 95 ומחזורי עבודה של הג'י פי יו שמתנודדים מממינוס 5% עד 40% ללא סיבה ברורה.
• 2:36
  גרפי ה-CPU מספרים אמת אחרת.
• 2:39
  הליבות עמוסות ללא הצדקה בעיבוד מקדים.
• 2:41
  הראיות מצביעות על שלושה כיוונים.
• 2:43
  ראשית, חלופה ל-CPU. כאשר ספק הביצוע של CUDA או TensorRT נכשל בטעינה, המנוע בוחר בשקט בגרף ה-CPU.
• 2:50
  המודל עובד, אך עם שיהוי הגבוה פי 10 עד 30.
• 2:53
  שנית, היא התאמת גרסאות.
• 2:54
  אונקס רנטיים קומפל מול גרסת CUDA אחת, צמתים מריצים אחרת, ומנועי TensorRT מבוטלים ונבנים מחדש עם ליבות גנריות.
• 3:02
  ניצול המשאבים קיים, אך הנתיבים המהירים עבדו.
• 3:05
  שלישית, הגדרות קונטיינר, שגויות, תמונות נפוחות, חוסר בחיבור התקני GPU, הגדרות שגויות של אנווידיה טורקית, וזיכרון שתפוס בהקצאות שמגביר שיהוי זנב תחת אומס.
• 3:15
  בסופו של דבר, זו לא תעלומה שקשורה למודלים.
• 3:18
  זהו מקרה שנוגע לאמינות התשתית.
• 3:20
  אנו נדחקה אחר הממצאים, סדר הספקים, יומני היכולות, חיבורי ההתקנים, ונשווה אותם לשלושה מדדים קריטיים, שיהוי, תפוקה וניצול GPU.
• 3:31
  תיק ראיות א', חלופה ל-CPU, החבלן השקט.
• 3:35
  זה התחיל בבקשה שהייתה אמורה לקחת שניות ולא לקחה.
• 3:38
  מד ה-GPU היה שקט, שקט מדי.
• 3:41
  גרף ה-CPU בינתיים עלה כמו הזעקת אש.
• 3:43
  בבדיקה מעמיקה יותר, המנוע ביצע בחירה.
• 3:46
  הוא הריץ משימה המיועדת ל-GPU על ה-CPU.
• 3:48
  אף התראה לא הופעלה.
• 3:49
  הפלט חזר בסופו של דבר.
• 3:51
  זהו החבלן השקט, החלופה ל-CPU.
• 3:54
  מדוע זה משנה? זה פשוט.
• 3:55
  סטייבל דיפיוז'ון על CPU הוא בזבוז זמן.
• 3:58
  המודל עובד, אך השיהוי מתרבה, פי 10 עד 30 איטי יותר, והתפוקה קורסת.
• 4:03
  בסביבה שמוכרת מילי שניות, הפער הזה קטלני.
• 4:05
  החשבון ממשיך לחייב על זמן GPU, אך ההתקן לא מבצע את העבודה.
• 4:09
  ציר הזמן חשף את התבנית.
• 4:11
  קונטיינרים שהורצו מקומית עם קודה טאסו.
• 4:13
  כשעברו לצומת אשכול עם מחסנית דרייברים שונה מעט, אותם קונטיינרים עלו, הגיבו לבדיקות תקינות, ואז הידרדרו.
• 4:19
  נקודת הקצה של התקינות רק בדקה, האם השרת למעלה.
• 4:22
  אז, היא מעולם לא בדקה, האם ה-GPU באמת מבצע את העבודה.
• 4:25
  בסביבה הזו, שום דבר אינו מקרי.
• 4:28
  שתיקה היא ממצא.
• 4:29
  הממצא העיקרי הוא סדר ספקי הביצוע באונקס רנטיים.
• 4:32
  המנוע מקבל רשימה, נסה טנסור RT, לאחר מכן קודה, ואז CPU.
• 4:37
  אם קודה נכשל בהתחול, בגלל דרייבר שגוי, ספריות חסרות או התקן לא מחובר, אורט יחבר בשקט את ספק הביצוע של ה-CPU.
• 4:44
  ללא חריגה, ללא קריסה, רק שורה ביומנים, שלעיתים קרובות נסתרת מהעין.
• 4:48
  ספק הביצוע של קודה אינו זמין, חוזר ל-CPU.
• 4:51
  השורה הזו היא הוידוי שרוב הצוותים לעולם לא קוראים.
• 4:54
  הנה החלק המוזר.
• 4:55
  תרשימי הניצול נראים תקינים מתאה במבט ראשון.
• 4:58
  בקשות עדיין מסתיימות.
• 4:59
  מפת השירות נראית ירוקה, אבל מחזור העבודה של ה-CPU נשאר על 5% בעוד זמן המאבד של המשתמש מזנק ונשאר גבוה.
• 5:06
  השיית ה-P50 גדלה P4 וביצועי ה-P95 מתפרקים.
• 5:09
  תעבורה מתפרצת מחמירה את המצב.
• 5:11
  תורים נוצרים והסקלר האוטומטי מוסיף עוד רפליקות שיורשות את אותו הפגם.
• 5:15
  תחשבו על זה כמו נבחרת שליחים שבה העצן לא הופיע, אז הספרן רץ את המקצה.
• 5:19
  המקל עובר, אבל לא במהירות של מרוץ.
• 5:21
  במילים אחרות, המערכת שלכם מספקת תוצאה נכונה על חשבון כל תקציב הסלו.
• 5:25
  סימנים מצטברים במהירות כשעוקבים אחר רצף ההתחול.
• 5:28
  יומני טעינת הספק מראים ניסיונות התחול של CUDA עם בדיקות גרסת דרייבר.
• 5:33
  אם הקונטיינר נבנה עבור CUDA 12.2, אבל בצומת יש רק 12, ההתחול נכשל.
• 5:39
  אם ערכת הכלים של אנווידיה לקונטיינרים לא מוגדרת, חיבור ההתקן לעולם לא יופיע בתוך הקונטיינר.
• 5:44
  בלי דב, אנווידיה אין לייב קודה.
• 5:46
  לכן, אם הגדרת הפוד לא מבקשת GPU במפורש, המתזמן לעולם לא יקצה את ההתקן.
• 5:52
  כל אחד מאלה מפעיל את השינמוך השקט הזה.
• 5:55
  השחזור הוא פשוט וישיר.
• 5:58
  בצומת שהוגדר לא נכון, הסקה פשוטה תציג ספק ביצוע מעבד, בעוד שציפית לספק טנסור RT או ספק CUDA.
• 6:07
  שלחו הודעה אחת, הגי-פי-יו נשאר במצב סרק.
• 6:10
  תהליכי המעבד מזנקים, והתמונה חוזרת תוך 20 עד 40 שניות במקום 2 עד 6.
• 6:15
  חזרו על כך בצומת עם דרייברים וחיבורים תקינים, וההודעה מסתיימת בשבריר מהזמן ומחזור הגי-פי-יו קופץ לטווח עבודה יציב.
• 6:22
  הראיות מצביעות על כך שמנגנוני ההגנה הנוכחיים הם תיאטרליים בלבד.
• 6:26
  בדיקות בריאות מחזירות 200 כי השרת מגיב.
• 6:28
  אין עימות התחול לכך שנתיב הג'י-פי-יו פעיל.
• 6:31
  בדיקות ביצועים לא קיימות, לכן התזמור מאמין שהרפליקות תקינות.
• 6:34
  המערכת לא מסוגלת להבדיל בין העצה לבין אמולציה.
• 6:38
  אמצעי הנגד הוא בוטה מעצם תכנונו.
• 6:40
  כישלון חרוץ עם ספק ביצוע הג'י-פי-יו חסר או פגום.
• 6:44
  סרבו להתחיל עם מאבד בסביבת ייצור.
• 6:46
  בהפעלת התהליך מנו את הספקים, ודו שטנסור RT או קודה נתנו, ושמספר ההתקנים תואם לציפיות.
• 6:54
  תעדו את היכולות QDNN, ליבות תנזור זמינות, מגבלות זיכרון, ווצאו עם קוד שגיאה עם משהו חסר.
• 7:01
  הקריבו זמינות עבור תקינות, ואפשרו לי מתזמירים להריץ מחדש על צומת תקין.
• 7:05
  כדי שזה יעבוד, אכפו עימות של חיבורי כלת, פלט.
• 7:08
  חברו קלטים ופלטים לזיכרון ההתקן ועמתו השקת ריאלית בעת ההתחול.
• 7:13
  הרצאה אחת לחימום שמפעילה את ליבת ה-Food Attention.
• 7:15
  אם התזמון חוצה את סף ההשאיה, הניחו שהנתיב פגום והפילו את הפוד.
• 7:20
  הוסיפו סט הודעות בדיקה, קנרי, עם זרעים דטרמיניסטיים.
• 7:23
  השבו את ההשאיה מול חלון הבסיס.
• 7:25
  אם הסטייה חורגת מהסובלנות שלכם, שילחו התראה לצוות ויצרו את הפריסה.
• 7:29
  זה אולי נראה קשוח, אבל האלטרנטיבה גרועה יותר.
• 7:32
  אשקול שעובד תוך עיבוד זמן ותקציב.
• 7:35
  קבע את סדר הספקים, דחה חלופת מעבד, וגרם למערכת להוכיח שהיא מהירה לפני שהיא נחשבת לפעילה.
• 7:41
  רק אז ירוק פירושו מועץ.
• 7:43
  ראייה ב' היא התאמת גרסאות.
• 7:46
  חוסר תאימות בין קודה לאונקס לטנסור.
• 7:49
  אם הג'י פי יו לא היה בשימוש, השאלה הבאה היא אם הוא יכול היה לפעול במלוא המהירות גם כשהוא נוכח.
• 7:54
  הראיות מצביעות על קשל עדין יותר.
• 7:56
  הגרסאות מסתנקרנות מספיק כדי לרוץ, אך לא מספיק כדי לפתוח את הנתיב המהיר.
• 8:00
  המערכת נראית מועצת עד שמסתכלים על השעונים.
• 8:03
  למה זה משנה? זה פשוט.
• 8:04
  צינורות דיפוזיה חיים עומתים על ביצועי האטנציה.
• 8:07
  כשאונקס רנטאים וטנסורט לא יכולים לטעון גרעינים, קרנלס,
• 8:11
  מאוחדים כי גרסאות קודה, CU-DNN או טנסור-RT לא תואמות, הם עוברים בשקט למימושים גנריים.
• 8:17
  המודל עובד.
• 8:19
  ניצול המשאבים נע סביב 30-50% והשיהוי חורג מהתקציב.
• 8:24
  הגרסה נראית אותו דבר, העבודה איטית יותר.
• 8:26
  בבדיקה מדוקדקת יותר, הממצאים מדויקים.
• 8:29
  יומני טעינת הספקים מצהירים על הצלחה עם סימן מסוים.
• 8:32
  נסיגה לגרעיני ברירת מחדל או השבטת X4 Mars.
• 8:36
  תראה שפיינוח הטנסורט נכשל עם בנייה מחדש של מנוע לא תואם,
• 8:40
  מה שמפעיל קומפילציה מקומי.
• 8:42
  מנועים שנבנו על גרסת משנה אחת של טנסור-RT לא יפענחו על אחרת.
• 8:46
  הבנייה מחדש מסתיימת, אך התוכנית המתקבלת עשויה להשמית אופטימיזיות של FP16 או ATTENSION מאוחד.
• 8:51
  המרוץ מסתיים.
• 8:52
  ללא זינוקים, מחזורי העבודה של ליבות הטנסור נשארים מושתקים.
• 8:56
  הנה החלק המנוגד לאינטואיציה.
• 8:58
  צוותים מפרשים את זה כריצה אופטימלית.
• 9:00
  בסביבה הזו, שום דבר אינו מקרי.
• 9:02
  אם Scaled Product Attention לא פעיל, אם X-Formers קבוי,
• 9:06
  אם CU-DNN מדווח על מרחב עבודה מוגבל, הביצועים קורסים בנימוס.
• 9:10
  הגרסה הפשוטה היא שקבצים בינאריים לא תואמים קופים גרעינים שמשתמשים ביותר תנועת זיכרון ופחות ספיפות חישובית.
• 9:16
  הפסי הופך לנראה לעין במעקבים.
• 9:18
  זמני השיהוי הקצה גדלים ככל שהמקביליות עולה.
• 9:20
  חשוב על המחסנית כעל סט מנעולים.
• 9:22
  דרייבר, ערכת כלים CUDA, CU-DNN, דגלי בנייה של ONUX Runtime וטנסור.
• 9:28
  שן אחת לא במקום, והמפתח מסתובב רק חצי דרך.
• 9:31
  אורט מפרסם גרף יכולות לכל ספק הרצה.
• 9:34
  אם האורט המקומפל מצפה לקדה 12.2, אך דרייבר הצומת חושף 12.1.
• 9:39
  CUDA נטען עם תכונות מוגבלות או לא נטען כלל.
• 9:42
  אם טנסור RT הוא 8.6 בצומת, אך התוכניות נוצרו עם 8.4, הפיינוח נכשל והמערכת מייצרת מחדש עם טקטיקות שמרניות.
• 9:50
  המערכת מעדיפה תקינות על פני מהירות בשקט.
• 9:53
  מדדים מוכיחים את ההפסד במונחים מעשיים.
• 9:55
  אם X-Formers או SDP פעילים, האטנציה של הדיפוזיה מפחית את זמן השעון באופן מדיד.
• 10:00
  מחקרים מראים בעקביות העצות של P2 עד P5 בנתיב האטנציה, תלוי ברזולוציה ובגודל העצבה.
• 10:05
  השוות אותם דרך אי-התאמת גרסאות ותאבד את המכפילים האלו.
• 10:09
  מזוג הסימונים, טום, מצטבר עם הרווחים האלו.
• 10:12
  ללא הגרעינים המאוחדים, התועלת נחנקת על ידי רוחב פס של זיכרון ופריסות לא אופטימליות.
• 10:17
  הפער מחמיר תחת 1024 על 1024 ורמת מקביליות גבוהה יותר.
• 10:21
  כדי לעקוב אחר הממצאים, התחל במיפוי היכולות.
• 10:24
  בעת ההפעלה, הדפס את רשימת הספקים המדויקת ואת התכונות המדווחות שלהם.
• 10:28
  גרסת טנסור RT, זמינות FP16 ו-INT8, סביבת עבודה מקסימלית, היוריסטיקת קונבולוציה של CUDNN ונוכחות NCCL לריבוי מאבדים גרפיים.
• 10:38
  עבור אונאקס רנטיים, הצג את סדרי העדיפויות של ה-EP.
• 10:41
  טנסור RT, קודה ואז CPU.
• 10:44
  אמת מה באמת נקשר לצמתי הגרף שלך?
• 10:46
  תעד אם צמתי עטנשון מוקצים לטנסורט עם ליבות מאוחדות או לליבות קודה כלליות.
• 10:52
  לאחר מכן, חקור את הסביבה.
• 10:53
  תשאל את מנהל ההתקן, דרייבר.
• 10:55
  אנווידי ה-SMI מציג את מודול הקרנל ואת התאימות לקדה.
• 10:58
  קרא את גרסאות הספריות קונטיינר.
• 11:00
  ליב קודה, ליב קבלס, ליב קן, ליב וינפר.
• 11:03
  אם ה-IMEG מכיל ספריות קודה 12.3, אך מנהל ההתקן המערך תומך רק עד 12.2, מצב תאימות זמן הריצה עשוי להתאנ עם מגבלות.
• 11:11
  אם ה-IMEG מצפה לכותרות טנסור RT 8.6, אך תוסף הצומת מספק 8.4, קריאות API ידרדרו או יבטלו אופטימיזציות מסוימות.
• 11:18
  התיקון הוא מטריצת בנייה, לא משאלה.
• 11:21
  קבע גרסאות מדויקות במקור אמת יחיד.
• 11:23
  IMEG, בסיס עם תאימות מנהל התקן, גרסת קודה משנית, CUDNN, גיבוב בניית ORT וגרסת טנסור RT.
• 11:30
  עפה אימג'ים להסקה, אינפרנס, מול המטריצה הזו ודחה צמתים שלא תואמים דרך תוויות צמתים ובדיקות קבלה.
• 11:36
  בני מראש הוא שמור במטמון מנועי טנסור RT לכל גרסת מודל ורזולוציה בגרסת טנסור RT המדויקת שאתה פורס.
• 11:41
  התייחס לגבצי תוכנית כאל ממצאים הקשורים למטריצה.
• 11:44
  לעולם אל תסתמך על בניית מנוע על הצומת בסביבת ייצור.
• 11:47
  זה מסתיר סחיפת גרסאות ומנפח זמני הזנקה, Cold Starts.
• 11:50
  כדי להבטיח שזה יעבוד, הוסף בדיקות אשן ב-C שמעמתות יכולות ליבה.
• 11:54
  הרץ את הקונטיינר בסביבה מבודדת עם מנהל ההתקן היד ואמת שטנסורט טוען ליבות FP16,
• 12:00
  צמתי אטנשון מאוחדים, קישור IO פעיל, Vex for Mars או SDP מוכרים.
• 12:05
  הרץ סט פרומפטים דטרמיניסטי ותכשל את הבנייה אם ההחזור חורג מחלון הבסיס או אם הלוגים מכילים שפת חזרה למצב בטוח.
• 12:12
  שמור את תמונת המצב של היכולות לצד הדיג'סט של האימג כדי ששחזור גרסה יחזיר גם את הקוד וגם את מאפייני הביצועים.
• 12:19
  בסופו של דבר, העובדות מראות שסחיפת גרסאות היא לא בג, אתה מבין.
• 12:22
  זה מחיר המהירות שאתה משלם.
• 12:24
  המערכת תעבוד.
• 12:25
  השעונים יעידו על כך.
• 12:27
  קובץ ראיות C, קונטיינר.
• 12:29
  שחיקת יעילות עקב הגדרות שגויות בתכנון.
• 12:33
  גם כשהגרסאות תואמות, הקונטיינר יכול לחבל ביעילות מבפנים.
• 12:37
  הראיות מצביעות על דימום איתי, אימג, נפוח, אינסטלציה חסרה של GPU והתנהגות מקצה זיכרון שמעובטת את ההחזור תחת אומס.
• 12:44
  שום דבר לא קורס.
• 12:45
  הכל מתדרדר.
• 12:47
  מדוע זה חשוב זה פשוט?
• 12:49
  קונטיינרים מעצבים את המציאות בזמן הריצה.
• 12:51
  עם האימג, שמן והזנקה איטית, רפליקות מגיעות מאוחר לאירוע.
• 12:55
  אם התקני GPU אינם מחוברים או של זמן הריצה חסרים הדגלים הנכונים, ספקי הביצוע מתנהגים לא קשורה.
• 13:02
  עם זירות זיכרון עוגרות הקצאות, רעש ברם מפעיל דפדוף וזינוקים בזנב התעבורה.
• 13:06
  המודל נראה בסדר.
• 13:08
  הקונטיינר ממשה בשקט כל בקשה.
• 13:10
  בבחינה מקרוב, ארטיפקטים מצטברים בזמן ה-ביילד.
• 13:13
  אימגים עולים על 2 ג'יגבייט, עמוסים במהדרים, קבצי כותרת ונכסי בדיקות כי אין בנייה רב של הביט.
• 13:19
  היעדר דוקר אגנור מזמין מחברות, מתמונים ומשקולות ניסיוניות לשכבות הייצור.
• 13:24
  כל פריסה מושכת גיגה ביתים דרך הרשת.
• 13:27
  כשתרחיב את זה לנוד פולס, הפעלה קרה הופכת למדיניות, לא לחריגה.
• 13:31
  הראיות אינן מסתוריות.
• 13:33
  ההיסטוריה של דוקר מספרת את הסיפור בשכבות.
• 13:35
  זמן הריצה חושף את השכבה השנייה של השחיקה.
• 13:38
  ללא דגלי GPU מפורשים, אין GPUs בדוקר או חוסר בהגדרת תוסף התקן בקאברנץ, התהליך לא רואה התכני אנווידיה.
• 13:47
  קונפיגורציות שגויות בין ויידיה קונטיינאר טולקיט מסתירות את לייב קודה.
• 13:51
  אז ככה, ספק הביצוע נטען עם מגבלות או לא נטען בכלל.
• 13:55
  מיג לא נאכף, לכן עומסי עבודה נלחמים על פרוסות זיכרון ומבזבזים משאבים שהמתזמנים לא מבינים.
• 14:00
  היומנים נשארים מנומסים, הביצועים מדממים החוצה.
• 14:02
  התנהגות הזיכרון היא השכבה השלישית.
• 14:04
  כברירת מחדל, זירת הזיכרון קודה של אונאקס רנדיים שומרת הקצאות בצורה אגרסיבית.
• 14:08
  תחת עומס במקביל זה נראה יציב, עד שהזירה תופסת יותר מדי ומאועבת לבקשות חדשות.
• 14:13
  זיכרון מוצמד לא מוגדר, כך שהעברות מערח התקן קורות דרך מאגרים ניתנים לדפדוף והופכות את ה-PCIE לצוואר בקבוק.
• 14:20
  קלט, פלט לא קשור להתקן, לכן טנזורים מקפצים בין ה-CPU ל-GPU ויוצרים ניסי השאיה בלתי נראים.
• 14:25
  התנהגות הזנב מחמירה ראשונה, ואז החציון עוקב אחריה.
• 14:29
  ככה נראה סט הסימפטומים בשטח.
• 14:30
  התפוקה האפקטיבית מפגרת למרות ניצול GPU מתון.
• 14:34
  השאיה תחת עומס קל היא מקובלת, אבל ה-P95 מתנדנד תחת מקביליות ואז מזנק ללא צפי.
• 14:40
  הריגות אום מזדמנות מאפסות רפליקות בשיא התעבורה ויוצרות התנהגות עדר.
• 14:50
  חשוב על היגיינת קונטיינרים כעל טיפול בראיות.
• 14:54
  בנייה רב שלבית מסירת טביעות אצבע.
• 14:56
  מהדרים ווכלי פיתוח לעולם לא נכנסים לזמן הריצה.
• 14:59
  אם בסיס מסוג DestroyS או Slim מצמצם את שטח הפנים ומקטין את זמן המשיכה.
• 15:03
  ביקורות של Docker Slim או Dive מאשרות מה שרד את הבנייה.
• 15:06
  קובץ Docker Ignore מונע נפח מקרי.
• 15:09
  התוצאה היא ניקיון פורנזי.
• 15:10
  מה שרץ הוא רק מה שצריך לרוץ.
• 15:12
  צינרת ה-GPUs קוקה להצהרות מפורשות.
• 15:15
  בדוקר הצהר על GPUs כולם או על פורסת מיג מדויקת.
• 15:19
  בקאברנץ בקש משאבי NVIDIA COM GPU ווודא שהתקן התוסף תואם לענף הדרייבר שלך.
• 15:25
  בהפעלה ווודא נוכחות התקן ותאימות דרייבר.
• 15:28
  NVIDIA SME וLD CONFIG הם לא לקישות, הם בדיקות קבלה.
• 15:32
  אם מה שהוא חסר או לא תואם, תעת זאת כהפרה וצא.
• 15:35
  אז כוון את ONUX Runtime וטנסורט עם כוונה תחילה.
• 15:38
  נעל את סדר ספק הביצוע על אינטיבי GPU בלבד בסביבת ייצור.
• 15:41
  שקול לבטל או לכוונן מחדש את אזור הזיכרון של קודה כאשר הוא עוגר משאבים מעבר לאומס העבודה שלך.
• 15:47
  הגבל צמיחה או קבע הקצאה מראש לגבולות צפויים.
• 15:50
  הפעל FP16 כברירת מחדל כאשר מגבלות הדיוק מאפשרות זאת.
• 15:54
  התנה INT8 בבדיקת דיוק.
• 15:56
  קשור קלט פלט לזיכרון ההתקן כדי שהנתונים יגיעו למקום שבו מתבצע החישוב.
• 16:01
  הובחר זרמים בזהירות כדי למנוע חסימת ראש תור.
• 16:03
  ווודא שהדברים נשמרים באמצעות שני שערים, בריאות וביצועים.
• 16:07
  בריאות היא לא רק סטטוס 200, היא תמונת מצב מאומתת של היכולות.
• 16:10
  ספקים טעונים, ליבות מאוחדות נוכחות, ליבות תנזור מזוהות וכלת פלט מוגדר.
• 16:15
  ביצועים הם קבוצת הנחיות בסיסית שרצה, חם, בעלייה, עם חלון השיה ורף ניצול מינימלי.
• 16:21
  אם הקונטיינר לא עומד בשניהם, הוא לא מורשה להיכנס לשירות.
• 16:24
  עצמד תקציבי גודל משיכה, פול סייז, לשיא כך שתמונות החורגות מהסף יכשילו את הבנייה.
• 16:28
  שמור תיעוד שינויים של תוכן התמונה לפי תמצית, דייג'סט, כדי ששחזורים יחזירו קוד תקים.
• 16:33
  הראיות מראות שקונטיינרים לא רק מריצים תוכנה, הם מקודדים התנהגות תחת אומס.
• 16:38
  כשהם רועשים, כבדים או מאורפלים לגבי ה-GPU, הם הופכים את ההיעצה לטקס חסר תועלת.
• 16:42
  כשהם רזים, ברורים ואסרטיביים, הם שומרים על הנתיב המהיר ששילמת עבורו.
• 16:46
  בסביבה הזו, שום דבר אינו מקרי.
• 16:48
  הקונטיינר או שעוזר ל-GPU לבצע את עבודתו, או שהוא מפריע לו.
• 16:52
  מעבדת, פורנזיקה, מדדים שמרשיעים.
• 16:54
  השהיה, תפוקה, ניצול.
• 16:56
  ראיות מנצחות דעות, לכן אנו מקבים את קבוצת ההנחיות, נועלים את זרעי האקריות ומריצים את המערכת חם.
• 17:01
  אותם מתזמנים, אותם צעדים, 25 עבור 512 מורחב ל-50 עבור 1024 על 1024 כדי לחשוף עומס.
• 17:09
  הקונקורנציה מוחזקת על 16 עם סוויפ ל-32.
• 17:13
  גודל הבוטש מתחיל ב-1 ועולה בזהירות עד שגבולות הו-RAM משמיעים את כולם.
• 17:16
  ללא אקסטרפולציה, ללא תירוצים, רק שעונים ומונים.
• 17:20
  ההשאיה מעידה ראשונה.
• 17:21
  במצב המושפל, ה-CPU Fallback, או נתיב האטנציה הגנרי, P50 בית מינוס 512 על 512, נמתח לדו ספרתי.
• 17:28
  P95 מספר את הסיפור האמיתי.
• 17:30
  הוא נודד ל-20 עד 40 שניות באופן בלתי צפוי, כיתורים מחמירים חוסר יעילות קטן.
• 17:35
  בית מינוס 1024 על 1024 עם 50 צעדים, P95 הופך לחישלון מרגע ההגעה.
• 17:41
  לאחר התיקון, עם GPU EP נעול, Attention מאוחד פעיל וקלט, פלט קשור להתקן,
• 17:46
  P50 חוזר לספרה אחת ו-P95 מתכווץ לתוך התקציב.
• 17:50
  הטווח מצטמצם, המערכת הופכת לצפויה.
• 17:53
  התפוקה מאשרת זאת.
• 17:54
  בקונקורנציה 16, הנתיב המושפל מניב טפטוף בלבד.
• 17:58
  תמונות לדקה בקושי עולות עם רפליקות כי כל מופע תוקע את עצמו.
• 18:02
  הגדלה ל-32 מחפילה את התחרות על המשאבים, לא את התפוקה.
• 18:05
  לאחר התיקון, הקשר מתיישר.
• 18:07
  תמונות לדקה עולות כמעט לנערית עד שמחזור העבודה של ליבות הטנזור רבוי או שה-C מגביל את הבוטש.
• 18:13
  ההבדל בשיפוע הוא ההוכחה.
• 18:14
  העבודה אכן חוצה את קו הסיום מהר יותר, לא רק ברעש, רב יותר.
• 18:18
  הניצול סוגר את התיק.
• 18:19
  לפני כן, מחזור העבודה של ה-GPU נע בין אחוז למד מינוס 50 אחוזים עם עמקים שטוחים וארוכים.
• 18:25
  מוני הפסי מציגים רעש מהעברות זיכרון הניתנות לגישה פייג'י אבר.
• 18:29
  לאחר מכן, מחזור העבודה מתייצב לרצועה גבוהה ועקבית עם מעורבות גלויה של ליבות טנזור.
• 18:36
  ה-CPU חוזר לתזמור ועיבוד מקדים קל.
• 18:39
  קפיצות בפסי מתקבצות כי זיכרון מוצמד, פינד וקישור IO בתלות העבורה מיותרת.
• 18:44
  שום דבר אחר לא מסביר את השינוי הזה חוץ מהעצה ממשית.
• 18:46
  אנחנו מוסיפים בדיקת מאמץ צולבת.
• 18:48
  מתחת ל-512 על 512 בית מינוס 25 צעדים, הנתיב המיוצב שומר על מקביליות של 16 ללא קפיצות זנב.
• 18:53
  דחיפה ל-32 והמערכת מתדרדרת בצורה מבוקרת.
• 18:57
  מדד פי 95 מתרחב באופן צפוי, לא כאוטי.
• 19:00
  תחת 1024 על 1024 בית מינוס 50 צעדים, ההבדל מוגדל.
• 19:04
  הנתיב הלא מיוצב קורס לזמני קצובה, טיימאוטס.
• 19:07
  הנתיב המוקשה שומר על פי 50 שימושי ופי 95 קביל עם בצ של 1 עד 2 עד לגבולות הו-RAM.
• 19:12
  כאן זירות, ארינז, וזרמים, סטריםס, הם קריטיים.
• 19:15
  לאחר הכבנון, חסימות ראש התור פוחתות.
• 19:17
  זווית העלות היא חשבון פשוט, בקשות לשעת GPU מטפסות פי 2 עד 5 כאשר תשומת לב מאוחדת,
• 19:23
  פיוז דטנשון, באף פי 16 וקישור IO מאומתים.
• 19:25
  העלות האפקטיבית למד מינוס אלף תמונות יורדת בהתאם.
• 19:28
  כנסות הפעלה קרה מתכווצים כי הדימויים רזים והמנועים בנויים מראש.
• 19:32
  צמתים מפסיקים לשלם מס הידור במפגש הראשון.
• 19:35
  הספר הראשי מסכים עם הלוגים.
• 19:37
  עימות מונע הרצות בנות מזל.
• 19:39
  חזור על כך בברכת צמתים שנייה עם גרסת מנהל התקן משנית שונה.
• 19:42
  הדימוי המוקשה מסרב לעלות על צומת לא תואם לפי תכנון.
• 19:46
  לכן, התוצאות ניתנות להשוואה ולא מבלבלות.
• 19:49
  בדוק צילום מצב של יכולות.
• 19:51
  אותו סדר ספקים, אותו טנסור RT, אותן טענות קרנל.
• 19:54
  הרץ שוב את סט ההנחיות וקלות מחדש את ההתפלגויות.
• 19:58
  כשההיסטוגרמות חופפות, הביטחון עולה.
• 20:00
  כשהן לא, הפרש היכולות מסביר למה.
• 20:03
  בסוף, המספרים לא מתווכחים, הם מרשיעים.
• 20:05
  השיה מתכווצת, התפוקה גדלה, הניצול מתייצב.
• 20:09
  הפתולוגיה אינה היפותטית.
• 20:10
  היא ניתנת למדידה, ואחריה היא מותירה טביעות אצבע על כל גרף.
• 20:14
  פרוטוקול התיקון, רשימת טיוג חוזרת להקשכה.
• 20:18
  בקרת קבלה מגיעה ראשונה.
• 20:20
  סרב להפעלה אם ספקי ביצוע של טנסור RT או קודה אינם נוכחים.
• 20:24
  מנס ספקים, עמת ספירת התקנים,
• 20:26
  הדפס צילומי מצב של יכולות,
• 20:28
  CU-DNN, FP-16, סביבת עבודה IN-T8.
• 20:31
  אם מה שהוא חסר, צא עם קוד שגיאה.
• 20:33
  זמינות עוקבת אחרי תקינות.
• 20:35
  הצמדת גרסאות היא עמוד השדרה.
• 20:37
  שמור על ענף מנהל התקן מטריצה יחיד,
• 20:39
  קודה משני לכאן, גיבוי לבניית ONUX Runtime,
• 20:42
  טנסור RT, בני דימויי השקה כנגד אותה מטריצה.
• 20:45
  תייג צמתים להתאמה.
• 20:46
  חסום קבלה על בסיס שוויון.
• 20:48
  מנועי טנסור RT בנויים מראש לכל מודל ורזולוציה.
• 20:51
  תוכניות הן תוצרים, לא ניחושי זמן ריצה.
• 20:54
  היגיינת קונטיינרים משמרת את האמת.
• 20:56
  השתמש בבנייה רב של ביט.
• 20:57
  שמור את זמן הריצה ללא הפצה, דיסטרו-ס או רזה.
• 21:00
  כלול דוקר איגנור קפדני.
• 21:01
  אמת עם היסטוריית דוקר וביקורת הרזיה.
• 21:04
  הגדר תקציבי גודל בריכה ב-C.
• 21:06
  ייקשל בדימויים מנופחים,
• 21:07
  חתום על דימויים ובדוק תוכן לפי תמצית,
• 21:10
  דייג'סט.
• 21:10
  הגדר GPU תחילה,
• 21:12
  נעל את סדר ה-EP לטנסורט קודה,
• 21:14
  ובטל את ספק ה-CPU בייצור.
• 21:16
  אמת נוכחות של אנווידי הדב וגרסת ערכת הכלים של אנווידי הקונטיינר.
• 21:19
  בקש GPU של אנווידייה נקודה קום במפורש או שלב רישיונות ואמת זאת בעת ההפעלה.
• 21:24
  כוונן את זמן הריצה.
• 21:25
  אפשר FP-16 כברירת מחדל.
• 21:28
  הגבל INT-8 באמצעות בדיקות דיוק.
• 21:30
  קשור I.O. ישירות לזיכרון ההתקן.
• 21:33
  אפשר זיכרון מוצמד.
• 21:34
  ובחר זרמים למניעת חסימת Head of Line.
• 21:37
  כוונן מחדש או בטל את זירת ה-Ort CUDA,
• 21:39
  כאשר היא נעצרת מעבר לסט העבודה.
• 21:41
  הגדר SLS של ביצועים כקוד,
• 21:43
  בדיקה עצמית בהפעלה עם חלון השיה של הנחיות דטרמיניסטיות ורף ניצול.
• 21:47
  היא קשל במקרה של צבירת פיגורים.
• 21:49
  אוסף יכולת תצפית, מדדי GPU לכל בקשה,
• 21:52
  התראות על מסלול פגום,
• 21:53
  הנחיות קנרי וקווי בסיס להשוואה.
• 21:56
  בצע פריסת בלו-גרין עם שערי ביצועים וחזרה אוטומטית במקרה של חריגה.
• 22:00
  כאשר הפרוטוקול נאכף,
• 22:02
  העצה היא מוכחת, לא מונחת.
• 22:05
  הלקח הוא קליני.
• 22:06
  נסיגת CPU שקטה, זליגת גרסאות ונפיחות קונטיינרים אינן בגים.
• 22:10
  אלו דפוסי קשל צפויים שניתן לחסום.
• 22:12
  הרץ את הפרוטוקול, מדוד ניצול GPU,
• 22:14
  סירב למסלולים פגומים,
• 22:16
  קבע גרסאות והתייחס למנועים כאל-ארטיפקטים.
• 22:18
  אם תרצה צלילה עמוקה יותר לזמן הריצה של אונאקס
• 22:21
  ולהתנהגות הזיכרון של טנסר-ארטי ומתי להשביט זירות,
• 22:24
  צפה במקרה הבא בסדרה זו והירשם להערות המעבדה.