טכניקת ג'די לצמצום רשתות קונבולוציוניות - גיזום

לפניך שוב המשימה של זיהוי חפצים. העדיפות היא מהירות הפעולה עם דיוק מקובל. אתה לוקח את ארכיטקטורת YOLOv3 ומאמנת אותה. הדיוק (mAp75) גדול מ-0.95. אבל קצב הריצה עדיין נמוך. שְׁטוּיוֹת.

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

מבוא

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

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

הצצה לביולוגיה

אני אוהב את זה כשלמידה עמוקה מסתכלת על רעיונות שמגיעים מהביולוגיה. אפשר לסמוך עליהם, כמו האבולוציה, (האם ידעת ש-ReLU דומה מאוד ל פונקציה של הפעלת נוירונים במוח?)

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

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

כמו כן, אתה יכול לחתוך כמה מהפיתולים החלשים מהדגם שלך. כמוצא אחרון, החבילות הנותרות יעזרו להחליף את החתוכים.

האם אתה אוהב Transfer Learning או שאתה לומד מאפס?

אפשרות מספר אחת. אתה משתמש ב-Transfer Learning ב-Yolov3. רשתית, מסכת-RCNN או U-Net. אבל רוב הזמן אנחנו לא צריכים לזהות 80 מחלקות אובייקט כמו ב-COCO. בתרגול שלי הכל מוגבל לכיתות א'-ב'. אפשר להניח שהארכיטקטורה של 1 מחלקות מיותרת כאן. זה מצביע על כך שצריך להקטין את הארכיטקטורה. יתר על כן, אני רוצה לעשות זאת מבלי לאבד את המשקולות הקיימות המתאמנות מראש.

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

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

אלגוריתם כללי

החלטנו שנוכל להסיר את החבילות. זה נראה די פשוט:

הסרת כל פיתול מלחיצה את הרשת, מה שמוביל בדרך כלל לעלייה מסוימת בשגיאות. מצד אחד, עלייה זו בשגיאה היא אינדיקטור לאופן שבו אנו מסירים פיתולים בצורה נכונה (לדוגמה, עלייה גדולה מעידה על כך שאנו עושים משהו לא בסדר). אבל עלייה קטנה היא די מקובלת ולעתים קרובות היא בוטלה על ידי אימון נוסף קל לאחר מכן עם LR קטן. הוסף שלב אימון נוסף:

עכשיו אנחנו צריכים להבין מתי אנחנו רוצים להפסיק את לולאת הלמידה<->גיזום שלנו. עשויות להיות כאן אפשרויות אקזוטיות כאשר אנחנו צריכים להקטין את הרשת לגודל ומהירות מסוימים (למשל, עבור מכשירים ניידים). עם זאת, האפשרות הנפוצה ביותר היא להמשיך במחזור עד שהשגיאה תהיה גבוהה מהמקובל. הוסף תנאי:

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

חפש חבילות שנמחקו

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

1. הקטנה ביותר של מידה L1 או גיזום_מגודל נמוך. הרעיון שפיתולים עם משקלים קטנים תורמים מעט להחלטה הסופית
2. מדד L1 הקטן ביותר תוך התחשבות בממוצע וסטיית תקן. אנו משלימים עם הערכה של אופי החלוקה.
3. מיסוך פיתולים ואי הכללה של אלו הפחות משפיעים על הדיוק הסופי. קביעה מדויקת יותר של פיתולים לא משמעותיים, אבל מאוד גוזלת זמן ומשאבים.
4. אחרים

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

תהליך ידני עבור YOLOv3

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

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

עכשיו בואו נבנה מחזור עבודה:

1. העלאת הפעלות
2. להבין כמה לחתוך
3. תפסיק
4. לימוד 10 עידנים עם LR=1e-4
5. בדיקה

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

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

כל התהליך הושלם ב-4 שלבים (מספרים כאן ובכל מקום עבור RTX 2060 Super):

שלב	mAp75	מספר פרמטרים, מיליון	גודל רשת, mb	מההתחלה, %	זמן ריצה, גברת	מצב ברית מילה
0	0.9656	60	241	100	180	-
1	0.9622	55	218	91	175	5% מכולם
2	0.9625	50	197	83	168	5% מכולם
3	0.9633	39	155	64	155	15% עבור שכבות עם 400+ פיתולים
4	0.9555	31	124	51	146	10% עבור שכבות עם 100+ פיתולים

השפעה חיובית אחת נוספה לשלב 2 - התאמה של גודל אצווה 4 לזיכרון, מה שהאיץ מאוד את תהליך ההכשרה הנוספת.
בשלב 4, התהליך הופסק בגלל אפילו הכשרה נוספת ארוכת טווח לא העלתה את mAp75 לערכים ישנים.
כתוצאה מכך, הצלחנו להאיץ את ההסקה על ידי 15%, הקטינו את הגודל ב 35% ולא להפסיד בדיוק.

אוטומציה לארכיטקטורות פשוטות יותר

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

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

import pruning
from keras.optimizers import Adam
from keras.utils import Sequence

train_batch_generator = BatchGenerator...
score_batch_generator = BatchGenerator...

opt = Adam(lr=1e-4)
pruner = pruning.Pruner("config.json", "categorical_crossentropy", opt)

pruner.prune(train_batch, valid_batch)

במידת הצורך, תוכל לשנות את פרמטרי התצורה:

{
    "input_model_path": "model.h5",
    "output_model_path": "model_pruned.h5",
    "finetuning_epochs": 10, # the number of epochs for train between pruning steps
    "stop_loss": 0.1, # loss for stopping process
    "pruning_percent_step": 0.05, # part of convs for delete on every pruning step
    "pruning_standart_deviation_part": 0.2 # shift for limit pruning part
}

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

לפיכך, אנו מאפשרים לך להסיר רק פיתולים חלשים מהתפלגות הדומות לזו הימנית ולא להשפיע על ההסרה מההתפלגות הדומות לשמאלית:

כאשר ההתפלגות מתקרבת לנורמלית, ניתן לבחור את מקדם ה-pruning_standart_deviation_part מתוך:

אני ממליץ על הנחה של 2 סיגמא. או שאתה יכול להתעלם מתכונה זו, ולהשאיר את הערך < 1.0.

הפלט הוא גרף של גודל רשת, אובדן וזמן ריצה של הרשת עבור כל הבדיקה, מנורמל ל-1.0. לדוגמה, כאן גודל הרשת הצטמצם כמעט פי 2 ללא אובדן איכות (רשת קונבולוציונית קטנה עם משקלים של 100 אלף):

מהירות הריצה נתונה לתנודות רגילות ונשארת כמעט ללא שינוי. יש לזה הסבר:

1. מספר הפיתולים משתנה מנוח (32, 64, 128) ללא הנוח ביותר עבור כרטיסי מסך - 27, 51 וכו'. יכול להיות שאני טועה כאן, אבל סביר להניח שיש לזה השפעה.
2. הארכיטקטורה אינה רחבה, אלא עקבית. על ידי הקטנת הרוחב, איננו משפיעים על העומק. לפיכך, אנו מפחיתים את העומס, אך לא משנים את המהירות.

לכן, השיפור התבטא בהפחתת עומס ה-CUDA במהלך הריצה ב-20-30%, אך לא בהפחתת זמן הריצה.

תוצאות של

בואו נהרהר. שקלנו 2 אפשרויות לגיזום - עבור YOLOv3 (כשצריך לעבוד עם הידיים) ולרשתות עם ארכיטקטורות פשוטות יותר. ניתן לראות שבשני המקרים ניתן להשיג הקטנת גודל רשת והאצה ללא אובדן דיוק. תוצאות:

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

נספח

• לאחר שלב הגיזום, ניתן להוסיף קוונטיזציה (לדוגמה, עם TensorRT)
• Tensorflow מספק יכולות עבור גיזום_מדרגה נמוכה. עובד.
• מאגר אני רוצה להתפתח ואשמח לעזור

מקור: www.habr.com