הבלוג של ארתיום
בלוג על לינוקס, תוכנה חופשית, מוזיקה, סלסה, ומה לא!
מאמרים בנושא פיתוח.
מעשה בשני 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 הוא טריקי... יש לכבדו
התחלתי להתקדם לאימון בקוד פתוח: pytorch עם תמיכה ב־OpenCL
תקציר: הצלחתי לבצע inference של AlexNet ב־pytorch ב־OpenCL. הביצועים זהים לפעלה ישירה של dlprimitives.
הדרך עוד ארוכה אבל פחות קצת יותר ברורה מה לעשות. המאמר המלא באנגלית בבלוג הפיתוח:
http://blog.dlprimitives.org/post/5
השוואה בין תפוחים ירוקים ואדומים
כשמודבר ב־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% |
אומנם זו התחלה אבל כבר התחלה טובה!
מקוביות לכוכבים
לאחרונה רכשתי טלסקופ פשוט וחזק וצללתי לתחום שעניין אותי עוד מילדות - אסטרונומיה. בתור מתחיל אחת הבעיות הקשות ביותר זה למצוא את גרמי השמיים שאתה מעוניין לצפות בהם. מובן שיש לא מעט אפליקציות "פלניטריום" חופשיות וסוגרות כמו Google SkyMap שמקלות על החיפושים. בסופו של דבר זה לא מסובך למצוא בשמיים משהו בהיר כמו ירח, כוכב לכת או קלאסטר פליאדות - כי גם בתוך העיר רואים את הדברים הבהירים ביותר.
הבעיה זה למצוא את הדברים שעמומים יותר - שבשבילם קונים טלסקופ בקוטר גדול - שיאסוף הרבה אור. אז איך מוצאים מה שלא רואים בעיניים? יש מספר שיטות:
- לקנות טלסקופ עם חצובה רובוטית שתדע לכוון אותך לכל גרם שמיים שתרצה תמורת סוכם לא סימלי. בשביל חובב אסטרונומיה מתחיל מדובר בסוכם כסף לא מבוטל.
- זה להשתמש בשיטת star hopping.
אז במה מדבור?
הרעיון זה למצוא נקודות ייחוס - כוכבים שקל לזהות ולזוז מהם בכיוון הרצוי. לדוגמה:
אם רוצים למצוא קלאסטר M41 (שמסומן בעיגול צהוב) אז אפשר למצוא את סיריוס ואת אדרה ולכיוון את הטלסקופ למיקום של 1/3 ו־2/3 ביניהם. כמובן שזה דורש: (א) שבסביבת האוביקט שאתה מחפש יהיו כוכבים בהירים וקלים לזיהוי. (ב) שנקודות ייחסו יהיו קלות להערכה בעין. שיטה זו דורשת גם הרבה מיומנות וגם שמיים חשוכים יחסית כדי להקל על הניווט מה שלא תמיד מתאפשר בתנאי העיר.
ומה לגבי אפליקציות כמו SkyMap הרי הן יודעות לכוון אותך למקום הרצוי? הבעיה שלסנסורים של טלפון יש שגיאה המגיע עד כ־5 מעלות בערך בעוד ששדה הראיה של טלסקופ טיפוסי למתחילים נע בין 1.0 ל־2.5 מעלות. אבל זו רק חצי בעיה. השגיאה של המצפן יכולה להגיע עד עשרות מעלות. מה שהופך כל תוכנות הפלנטריום לא רלונטיות לכיוון מדויק של הטלסקופ אלא רק להערכה כללית של כיוון הצפייה.
אז עלה בראשי רעיון
אומנם הסנסורים לא מדויקים אבל לטלפון יש גם סנסור gyro. אפשר לקרוא אותם בעזרת Device Orientation Event ואז אם במקום למדוד את הכיוון האובסולטי למדוד את השינוי נוכל להגיע לדיוק יותר גבוה! גם בציר גובה בגם בציר הכיוון (מצפן)
כיוון שאני מעולם לא פיתחתי אפליקציות אז בחרתי לעבור עם WebApi ולממש הכל ב־JavaScript. בצורה זו אוכל בקלות לבנות אפליקציה גם ל־Android וגם ל־iPhone (כי הרבה חובבי אסטרונומיה אוהבים iPhoneים). בסה"כ מדובר בקצת גיאומטריה חישובית וגם בבסיס הנתונים.
כיוון שהתכוונתי לבנות אפליקצית קוד פתוח אז יכולתי לדוג קוד פחות או יותר מכל מקום כולל מכוסה ב־GPL. ומצאתי
- את הכוכבים ובעיקר קבוצות כוכבים מצאתי פה: https://github.com/eleanorlutz/western_constellations_atlas_of_space
- את אוסף ה־Deep Space Objects מצאתי כאן: https://github.com/mattiaverga/OpenNGC
- את הפנקציות לחישוב מיקום כוכבי הלכת מצאתי כאן: https://github.com/TheSiebi/SpacePointer
כל מה שנשאר לי זה להמיר את ה־csvים ל־JSON להמיר כמה פונקציות חישוביות מ־python ל־javascript ולהסתבך בהרבה טרנספורמציות לינאריות. וכמון לכתוב גם UI נחמד.
אז הנה התוצאה: https://artyom-beilis.github.io/skyhopper.html לטלפון חכם בלבד.
וכמבו הנה הקוד: https://github.com/artyom-beilis/skyhopper
אז איך זה עובד?
- אתה מחבר את הטלפון לטלסקופ
- מכוון אותו לכוכב שקל לזהות
- מבצע איפוס ע"י לחיצה על כוכב שכיוונת אליו במפת הכוכבים על המסך
- בוחר את המטרה בה אתה מעוניין לצפות
- מזיז אל הטלסקופ בהתאם להוראות והאפליקציה מודדת את התזוזה ונותנת משוב - מודדת את שינוי הזווית בגובה וברוחב הנדרש ומכוונת אותך ליעד!
בדקתי את האפליקציה כבר מספר לילות ובד"כ מגיע בדיוק למטרה! לפעמים הג'ירו מאבד כיוון אבל בכל מקרה מומלץ לבצע איפוס לפני כל תזוזה לאובייקט חדש.
כך הצלחתי למצוא מספר לא מבוטל של גרמי שמיים בתנאי עיר שבכלל לא חלמתי למצוא אותם לפני!
מסקנות מתחום כתיבת הקוד
זו נראה לי הפעם הראשונה שהשתמשתי במספר רב של מקורות שאפילו מופיעים תחת רישיון GPL. מה שׁזירז את הפיתוח בצורה דרמטית. קיבלתי מהר משוב מאנשים בתחום אסטרונומיה שעזרו לי לשפר את הממשק עם הצעות מאוד נכונות. כל זה אפשר לי להגיע לתוצאה די מוגמרת תוך מספר ערבים
