הבלוג של ארתיום :: בינה מלאכותית

התקדמות חשובה בתמיכה ב־OpenCL ב־pytorch.

רקע

היום pytorch היא אחת התשתיות המובילות בעולם למידה עמוקה. יש לה יתרונות רבות, אבל מבחינת המפתח זה קוד איכותי ותיעוד טוב. הקוד כתוב בצורה מאוד מודרנית עם שימוש נכון ביכולות C++‎ מה שמאוד מקל על הפיתוח. אני עובד בתקופה האחרונה על פיתוח מנוע עבור pytorch מבוסס OpenCL כחלופה ל־cuda.

כבר כתבתי בעבר על חשיבות התמיכה ב־OpenCL.

אבל בכל זאת אזכיר כמה נקודות מבחינת קהילת תוכנה חופשית וקוד פתוח:

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

הפרוייקט ב־github‏

אז מה חדש? קלות אינטגרציה!

עם שחרור גרסה 1.13 של pytorch חל שיפור משמעותי ב־out-of-tree-backend. עכשיו הוספת מנוע אימון מבוסס OpenCL היא פשוטה מאוד ולמעשה שאלה של מספר דקות, אפילו בוונידוס העניין יחסית פשוט. המשמעות שאפשר להשתמש במנוע OpenCL בקלות רבה הן בלינוקס והן בווינדוס.

מה עם הביצועים? אם משווים מול גרסת cuda/cudnn על אותו ה־gpu מדובר בין 50 ל־70 אחוז ביצועי cuda באימון ובין כ־60 ל־80 באבלואציה (תלוי ברשת כמובן).

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

המנוע עצמו מבוסס על ספריית dlprimitives‏ שאני מפתח במקביל והיא חלופה ל־cuDNN על בסיס OpenCL וגם מנוע חיזוי שעובד עם מודלים בפורמט ONNX - שזה נושא גדול בפני עצמו.

מה המשמעות של זה?

משתמשי AMD יכולים לאמן רשתות. הם לא מוגבלים למספר מצומצם של דגמים ש־rocm תומך בהם או לשימוש בלינוקס בלבד. התמיכה היא גורפת מ־APUים ישנים כמו Stoney Ridge ועד ל־RDNA 2 וגם זה עובד על "חלונות" למי שמעוניין.

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

מחפש עזרה...

מישהו יודע איך אפשר לבנות ולפרסם whl לפלטפורמות שונות? רצוי איזה שירות ענן שיעשה זאת? כדי שזה יהיה ממש במרחק של pip install :-)

מעשה בשני NaNים

לאחרונה ניסיתי להריץ אימון של GAN על pytorch עם תמיכה ב־dlprimitives. אחד דברים הלא נעימים באימון של GANים באופן כללי זה שהם לא ממש יציבים ומתבדרים בקלות.

שמתי לב שבגרסת cuda הוא רץ ללא דופי ובגרסה שלי הוא נתקע. נתקע על ביצוע backpropogation ב־convolution. אחד ההבדלים העיקריים באגלוריתם בהשוואה לשאר היה שימוש בפעולות אטומיות לחישוב סכום (טריק מאוד נפוץ במימוש קונבולוציה)

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

כתבתי שאלה ב־Stackoverflow העתקתי קטע קוד... ואז נפל האסימון

float oldv = *ptr;
for(;;) {
    float newv = oldv + v;
    float prev = as_float(atomic_cmpxchg((__global volatile int *)(ptr),as_int(oldv),as_int(newv)));
    if(prev == oldv)
        return;
    oldv = prev;
}

קחו לכם כמה דקות.

פעולת comxchg ב־OpenCL עובדת רק על int. לכן הייתי צריך לעשות bit-casting ל־int ובחזרה (as_float ו־as_int בדיוק עושים את זה). ואז תנאי הבדיקה prev==old ביצעתי ב־float במקום בשלמים.

כך שאם הערכים שווים אז ההחלפה הצליחה. אבל מה שכחתי? NaN == NaN תמיד נותן false! ולכן תקעתי בלולאה אינסופית כי התנאי לעולם לא ייתקיים. החלפתי לבדיקה בערכים שלמים (קרי ייצוג בינארי) והכל עבד חלק.

מסקנה NaN הוא טריקי... יש לכבדו

עדכוני dlprimitives

מספר עדכונים:

התקדמות יפה עם pytorch - בוצעה ולידציה של מרבית הרשתות של סיווג הנמצאות ה־torchvision:
- alexnet
- resnet18
- resnet50
- vgg16
- densenet161
- googlenet
- squeezenet1_0
- inception_v3
- shufflenet_v2_x1_0
- mobilenet_v2
- mobilenet_v3_large
- mobilenet_v3_small
- resnext50_32x4d
- wide_resnet50_2
- mnasnet1_0
- efficientnet_b0
- efficientnet_b4
- regnet_y_400mf
מה שאומר שניתן לאמן עכשיו הרבה סוגי רשתות. על הדרך מצאתי לא מעט באגים ותיקנתי אותם
ניסיתי לעשות אינטגרציה עם OneDNN של אינטל (מאין cudnn ל־GPU שלהם) רק כדי לגלות שהביצועים שלהם בפורמט NCHW גרועים. כיוון שרוב התשתיות עובדות עם הפורמט הזה pytorch, caffe, mxnet ועוד אז OneDNN לא ממש רלוונטי בינתיים. אחזור לשם כשיקרה אחד מהשניים:
- אינטל יתקנו את הביצועים עבור הפורמט הנפוץ
- אני אפתח תמיכה ב־NHWC לטובת TensorFlow בו זה פורמט ברירת מחדל

המשך יבוא

התחלתי להתקדם לאימון בקוד פתוח: pytorch עם תמיכה ב־OpenCL

תקציר: הצלחתי לבצע inference של AlexNet ב־pytorch ב־OpenCL. הביצועים זהים לפעלה ישירה של dlprimitives.

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

http://blog.dlprimitives.org/post/5

מדוע אנחנו זקוקים ל־deep-learning מבוסס OpenCL?

במאמר חדש http://blog.dlprimitives.org/post/2 אני סוקר את הסיבות והצורך בהקמת תשתית למידה חישובית מבוססת OpenCL. אני מתייחס כאן לסיבות שהן לאו דווקא סיבות "אידואולוגיות" כמו שימוש בקוד פתוח אלא גם מתייחס לנושאים טכניים ומהותיים:

מחקר ואלגוריתמים
וניהול פרויקטים לטווח רחוק
שיפור מוצר ע"י תחרותיות

השוואה בין תפוחים ירוקים ואדומים

כשמודבר ב־Deep Learning זה מאוד קשה להשוות בין GPU של החברות המובילות AMD ו־NVidia. בניגוד למשחקי מחשב שנותנים לך מדדים ברורים על עלות מול תועלת, תחום DL נשלט באופן בלעדי ע"י NVidia. גם אם קיימים פתרונות של AMD הם לא תמיד עובדים. למשל כרטיסי RDNA/RDNA2 עדיין לא נתמכים ע"י AMD לטובת Deep Learning - והם בעצם הכרטיסים הזמינים היחידים היום בשוק.

ובכן כחלק מפרויקט DLPrimitives עשיתי השוואה כזו:

http://blog.dlprimitives.org/post/1

וכן גם השקתי בלוג חדש לטובת עדכונים על הפרויקט.

רשתות נוירונים בקוד פתוח... להפשיל שרוולים

כתבתי בעבר על המצב העגום של תחום ה־deep learning בקוד פתוח - שלמעשה לא קיים. אחרי ש־Google בפועל הרגו את ה־plaidml עם keras והפיתוח של Caffe הופסק אז נוצר המצב בו אין כל דרך לאמן רשתות בעזרת פלטפורמה פתוחה - OpenCL.

יש סיבות טובות לעבוד עם OpenCL מעבר לשמירה על הקוד הפתוח. למשל לפתח תוכנה שתעבוד על כל כרטיס גרפי סביר ובכל מערכת הפעלה - בלי להסתבך.

אז הרמתי את הכפפה: https://github.com/artyom-beilis/dlprimitives

זהו פרויקט חדש בשם DLPrimitives שאמור לתת מענה לסוגיה. הוא אמור לספק ספריה בסגנון cudnn/miopen שמממשת את הפעולות הבסיסיות של Deep-Learning וגם לספק כלים ל־inference. בנוסף, הרעיון הוא להתחבר כ־backend לאחד ה־deep learning frameworks העדכניים כמו pytorch, tensorflow או mxnet.

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

לחסרי סבלנות - הצלחתי להגיע ל־150%-200% של ביצועי caffe-opencl ו־plaidml על פלטפורמת amd ו־nvidia ולהגיע לכ־50% עד 70% של ביצועי המימושים הספציפיים שלהם על בסיס cudnn/miopen.

כל התוצאות:

https://github.com/artyom-beilis/dlprimitives/blob/master/docs/summary.md

סיכום לעצלנים - ממוצע על 5 רשתות נפוצות alexnet, resnet18, resnet50, vgg, mobilenet:

GPU	Batch	Train, Cuda/HIP	Test, Cuda/HIP	Train, Plaidml/Caffe	Test, Plaidml/Caffe
gtx960	16	51%	60.73%	171%	167.33%
gtx960	8	59%	72.03%	187%	155.25%
gtx1080	16	42%	41.34%	207%	137.52%
rtx2060s	16	49%	57.53%	211%	149.48%
rx560	16	53%	56.82%	153%	115.63%
rx560	8	55%	54.19%	172%	122.64%
intel-hd530	8			109%	66.12%

אומנם זו התחלה אבל כבר התחלה טובה!

רשתות נוירונים בקוד פתוח... תמונת מצב

כידוע היום שוק ה־deep learning נשלט באופן כמעט בלעדי ע"י nVidia. אומנם כל תשתיות למידה החישובית הפופולריות כגן TensorFlow, PyTorch, Caffe, MXNet ואחרות משוחררות כקוד פתוח, אבל בליבו של כל אחד מהם, ללא יוצא מן הכלל, רצות ספריות cublas ו־cudnn המאפשרות לנצל את החומרה בצורה מיטבית. כולן כמובן קוד בסגור ומסוגר הרץ על בסיס CUDA. כמובן, גם הוא API פרטי וקנייני של חברת nVidia.

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

אבל אני רוצה קוד פתוח?

אז יש מספר פתרונות וכיוונים:

לאמן הכל ב־CPU בלבד.
להשתמש בתשתית ROCm של AMD.
להשתמש ב־OpenCL במקום ב־CUDA ואז חוץ מדרייבר של nVidia הכל יהיה פתוח (פחות או יותר)

המשך...

על למידה חישובית, תכנה חופשית ומה שביניהם

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

היום קיימות עשרות תשחתיות (frameworks) לעבודה עם רשתות נוירונים - וכל הפופולריים ביניהם הם תכנה חופשית: tensorflow, pytorch, caffe, keras, mxnet ועוד רבים אחרים הם תכנה חופשית שמופצת תחת רשיונות די מתרניים. חברות ענק שעומדות מאוחרי חלק מהם כמו facebook ו־google דואגים להחזיק את הקוד הפתוח - כי רק כך ניתן לשרוד בעולם הזה בו השיטות והמאמרים שפורסמו לפני שנה כבר לא מספיק עדכניים.

אבל, יש פה אבל אחד גדול מאוד. כל התשתיות האלה, דורשות שימוש ב־GPU על מנת לקבל תוצאות בזמן סביר. נקח לדוגמה את הרשת המקורית הידועה בשם alex-net שהייתה אחת פרצות הדרך מהמשעותיות ביותר בתחום הלמידה החישובי בשני עשורים אחרונים. זמן אימון הרשת ב־2012 לקח סדר גודל של שבועיים תוך שימוש בשני כרטיסים גרפיים.

כמובן אין כל פסול בשימוש בכרטיסים גרפיים - הם בסה"כ עושים מה שהם יודעים לעשות טוב number-crunching. אבל, היום כמט כל התשתיות מסתמכות של טכנולוגיה אחת וספק אחד - כולם משתמשים ב־cuda וב־nVidia. יתרה מזו חלק מהתשתיות מסתכמות באופן בלעדי על ספריה סוגרה אחת בשם cuDNN שמאפשרת לנצל את כל החישוב של החומרה עד תום. cuDNN ו־cuBLAS הן הספריות שבלעדיהם tensorflow או pytorch פשוט לא יכולים להקיים מבחינת לקוח הקצה.

כן, קיימות תשתיות שמאפשרות אימון גם על טכנולוגיה פתוחה. לדוגמה ל־caffe יש ענף opencl העובד על בסיס טכנולוגיות פתוחות ויודע לרוץ גם על כרטיסים של AMD ואפילו של Intel. אבל

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

בהתחשב בעובדה שחלק מהאימונים יכולים לקחת שעות רבות אפילו ימים זה הופך את הענף של opencl לפחות רלוונטי. הסיבה לאיטיות היא שהמימוש לא נהנה האופטימיזציות מטורפות וכתיבה ב־assembly ש־nVidia הייתה יכולה לעשות ב־cudnn ו־cuBlas.

אבל מה עם AMD? האם הם ישנים? כן ולא. AMD דאגו לפתח אלטרנטיבה בשם ROCm. למעשה אם אתה עובד על לינוקס ויש לך כרטיס כמו rx580 או Vega 56 אתה יכול באמץ סביר להריץ את ה־tensorflow ו־pytorch ואפילו caffe על AMD. והיתרון הגדול של ROCm הוא שמדובר בקוד פתוח לחלוטין. החסרון?.. מאיפה להתחיל

ROCm תומך אך ורק בלינוקס אם אתה על Mac או על Windows... לא
ספריית MIOpen שלהם שמהווה מאין תחליף ל־cudnn, אפילו שתומכת ב־OpenCL עובדת אך ורק על דיריבר rocm של AMD. משמעות - אומנם זה קוד פתוח אבל זה vendor-lock-in לא פחות מ־cudnn של nvidia
ROCm לא תומך עדיין ברטיסים הגרפיים העדכניים ביותר מבוססי rdna כמו Rx 5700XT וחבריו. עברה שנה מאז שהכטריסים האלה הושקו אבל עדיין לא ניתן להשתמש בהם לטובת למידה חישובית.
הוא גם לא נותן מענה ל־APUs. הכרטיסים הגרפיים המובנים שבאים במעבדים כמו Razen 3400G - לא יעבדו עם tensorflow או pytorch. ויש לציין של־Vega 11 שבא עם 3400G יש יותר כוח החישוב מ־GTX 580 ש־alex-net המקורי אומן עליו.

למעשה נראה כי AMD עשתה הכל כדי למנוע ממישו אפילו להסתכל בכיוון שלהם לטובת deep-learnים.

מה עם פתרונות עבור intel? הרי גם להם יש GPU? מעבר לעובד שביצועי Intel GPU הם בדיחה, גם intel דאגה לכתוב ספריית deep-learning משלה שלא עובדת עם שום כרטיס גרפי אחר.

שורה תחתונה

למרות שמבחוץ נראה שכל נושא למידה חישובית על רשתות נוירונים מתבסס על תכנה חופשית, במציאות יש רק דרך אחת לעבוד - לעבוד עם הקוד הסגור של ספק אחד. ללא שילוב של nVidia/cuda/cudnn התחזיות של Deep-Learning די עגומות

בינה מלאכותית על ZX Spectrum

המחשב הראשון שלי היה ZX Spectrum. למדתי עליו לתכנת, למדתי לכתוב קוד אסמבלי, וגם את ההבנה איך מעבדים בנויים רכשתי שם.

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

היום אני עוסק בתחום בבינה מלאכותית ומשתמש בכרטיסים גרפיים חזקים ביותר שהביצועים שלהם נמדדים ב־Terra FLOPS. אבל לאחרונה נתקעתי בסימולטור של ZX Spectrum ועלה במוחי רעיון. האם אפשר לקחת את המשימות שאני עושה היום ולעשות אותה על המחשב של אז?

אז לקחתי את ה-Hello World של למידה חישובית זיהוי ספרות בכתב היד והחלטתי לממש את זה ב-ZX Spectrum.

להלן התוצאות:

https://github.com/artyom-beilis/zx_spectrum_deep_learning

ניתן למצוא מאמר מלא באנגלית והסברים מלאים על התהליך כאן:

http://blog.cppcms.com/post/125