कन्व्होल्यूशनल नेटवर्क्स कमी करण्यासाठी जेडी तंत्र - रोपांची छाटणी

तुमच्या आधी पुन्हा वस्तू शोधण्याचे काम आहे. प्राधान्य स्वीकार्य अचूकतेसह ऑपरेशनची गती आहे. तुम्ही YOLOv3 आर्किटेक्चर घ्या आणि ते पुढे प्रशिक्षित करा. अचूकता(mAp75) 0.95 पेक्षा जास्त आहे. पण रन रेट अजूनही कमी आहे. बकवास.

आज आपण परिमाणीकरण बायपास करू. आणि कट अंतर्गत आम्ही पाहू मॉडेल रोपांची छाटणी — अचूकता न गमावता अनुमानाला गती देण्यासाठी नेटवर्कचे अनावश्यक भाग ट्रिम करणे. कुठे, किती आणि कसे कापायचे ते स्पष्ट आहे. हे व्यक्तिचलितपणे कसे करायचे आणि तुम्ही ते कोठे स्वयंचलित करू शकता ते पाहू या. शेवटी केरांवर एक भांडार आहे.

परिचय

माझ्या मागील कामाच्या ठिकाणी, पर्ममधील मॅक्रोस्कोप, मला एक सवय लागली - अल्गोरिदमच्या अंमलबजावणीच्या वेळेचे नेहमी निरीक्षण करणे. आणि नेटवर्क रनटाइम नेहमी पर्याप्तता फिल्टरद्वारे तपासा. सहसा उत्पादनातील अत्याधुनिक हे फिल्टर पास करत नाही, ज्यामुळे मला रोपांची छाटणी झाली.

छाटणी हा एक जुना विषय आहे ज्यावर चर्चा झाली होती स्टॅनफोर्ड व्याख्याने 2017 मध्ये. विविध नोड्स काढून अचूकता न गमावता प्रशिक्षित नेटवर्कचा आकार कमी करणे ही मुख्य कल्पना आहे. हे छान वाटतं, पण मी त्याच्या वापराबद्दल क्वचितच ऐकतो. कदाचित, तेथे पुरेशी अंमलबजावणी नाही, रशियन-भाषेतील कोणतेही लेख नाहीत किंवा प्रत्येकजण याला छाटणीचे ज्ञान मानतो आणि शांत राहतो.
पण आपण ते वेगळे करूया

जीवशास्त्राची एक झलक

जेव्हा डीप लर्निंग जीवशास्त्रातून आलेल्या कल्पनांकडे पाहते तेव्हा मला ते आवडते. ते, उत्क्रांतीप्रमाणे, विश्वासार्ह असू शकतात (तुम्हाला माहित आहे का की ReLU सारखे आहे मेंदूतील न्यूरॉन सक्रियतेचे कार्य?)

मॉडेल छाटणी प्रक्रिया देखील जीवशास्त्राच्या जवळ आहे. येथे नेटवर्कच्या प्रतिसादाची तुलना मेंदूच्या प्लॅस्टिकिटीशी केली जाऊ शकते. पुस्तकात दोन मनोरंजक उदाहरणे आहेत. नॉर्मन डॉज:

1. केवळ अर्ध्या भागासह जन्मलेल्या स्त्रीच्या मेंदूने हरवलेल्या अर्ध्या भागाची कार्ये करण्यासाठी स्वतःला पुन्हा प्रोग्राम केले आहे.
2. त्या व्यक्तीने दृष्टीसाठी जबाबदार असलेल्या त्याच्या मेंदूचा भाग काढून टाकला. कालांतराने, मेंदूच्या इतर भागांनी ही कार्ये ताब्यात घेतली. (आम्ही पुनरावृत्ती करण्याचा प्रयत्न करत नाही)

त्याचप्रमाणे, तुम्ही तुमच्या मॉडेलमधून काही कमकुवत कवच काढू शकता. शेवटचा उपाय म्हणून, उर्वरित बंडल कट केलेल्या पुनर्स्थित करण्यात मदत करतील.

तुम्हाला ट्रान्सफर लर्निंग आवडते की तुम्ही सुरवातीपासून शिकत आहात?

पर्याय क्रमांक एक. तुम्ही Yolov3 वर ट्रान्सफर लर्निंग वापरता. रेटिना, मास्क-आरसीएनएन किंवा यू-नेट. परंतु बहुतेक वेळा आम्हाला COCO प्रमाणे 80 ऑब्जेक्ट क्लासेस ओळखण्याची गरज नसते. माझ्या सराव मध्ये, सर्वकाही ग्रेड 1-2 पर्यंत मर्यादित आहे. येथे 80 वर्गांसाठीचे आर्किटेक्चर अनावश्यक आहे असे गृहीत धरू शकते. हे सूचित करते की वास्तुकला लहान करणे आवश्यक आहे. शिवाय, मला हे विद्यमान पूर्व-प्रशिक्षित वजन न गमावता करायचे आहे.

पर्याय क्रमांक दोन. कदाचित तुमच्याकडे भरपूर डेटा आणि संगणन संसाधने असतील किंवा फक्त सुपर-कस्टम आर्किटेक्चरची आवश्यकता असेल. काही फरक पडत नाही. पण तुम्ही सुरवातीपासून नेटवर्क शिकत आहात. डेटा स्ट्रक्चर पाहणे, अत्याधिक शक्ती असलेले आर्किटेक्चर निवडणे आणि ड्रॉपआउट्सना पुन्हा प्रशिक्षण देण्यापासून पुढे ढकलणे ही नेहमीची प्रक्रिया आहे. मी 0.6 ड्रॉपआउट पाहिले, कार्ल.

दोन्ही प्रकरणांमध्ये, नेटवर्क कमी केले जाऊ शकते. प्रवृत्त. आता सुंता रोपांची छाटणी कोणत्या प्रकारची आहे ते शोधूया

सामान्य अल्गोरिदम

आम्ही ठरवले की आम्ही बंडल काढू शकतो. हे अगदी सोपे दिसते:

नेटवर्कसाठी कोणतीही गोंधळ काढून टाकणे तणावपूर्ण आहे, ज्यामुळे सामान्यत: काही त्रुटी वाढतात. एकीकडे, त्रुटीतील ही वाढ हे दर्शवते की आपण किती योग्यरित्या आवर्तन काढतो (उदाहरणार्थ, मोठी वाढ दर्शवते की आपण काहीतरी चुकीचे करत आहोत). परंतु एक लहान वाढ अगदी स्वीकार्य आहे आणि नंतरच्या हलक्या अतिरिक्त प्रशिक्षणाद्वारे लहान एलआरसह काढून टाकली जाते. अतिरिक्त प्रशिक्षण चरण जोडा:

आता आपल्याला आपले शिक्षण<->प्रूनिंग लूप कधी थांबवायचे आहे हे शोधून काढावे लागेल. जेव्हा आम्हाला नेटवर्कला एका विशिष्ट आकारात आणि गतीपर्यंत (उदाहरणार्थ, मोबाइल डिव्हाइससाठी) कमी करण्याची आवश्यकता असते तेव्हा येथे विदेशी पर्याय असू शकतात. तथापि, त्रुटी स्वीकार्य होण्यापेक्षा जास्त होईपर्यंत सायकल चालू ठेवणे हा सर्वात सामान्य पर्याय आहे. एक अट जोडा:

तर, अल्गोरिदम स्पष्ट होते. हटविलेले कॉन्व्होल्यूशन कसे ठरवायचे हे शोधणे बाकी आहे.

हटविलेले पॅकेज शोधा

आम्हाला काही गोंधळ काढण्याची गरज आहे. पुढे धावणे आणि कोणालाही "शूटिंग" करणे ही वाईट कल्पना आहे, जरी ती कार्य करेल. परंतु तुमचे डोके असल्याने, तुम्ही विचार करू शकता आणि काढण्यासाठी "कमकुवत" संकल्पना निवडण्याचा प्रयत्न करू शकता. अनेक पर्याय आहेत:

1. सर्वात लहान L1-माप किंवा low_magnitude_pruning. लहान वजनासह convolutions अंतिम निर्णय थोडे योगदान देते की कल्पना
2. सर्वात लहान L1-माप सरासरी आणि मानक विचलन लक्षात घेऊन. आम्ही वितरणाच्या स्वरूपाच्या मूल्यांकनासह पूरक आहोत.
3. मास्किंग कॉन्व्हॉल्यूशन आणि ते वगळणे जे अंतिम अचूकतेवर कमीतकमी प्रभाव टाकतात. क्षुल्लक परिसंवादांचे अधिक अचूक निर्धारण, परंतु खूप वेळ घेणारे आणि संसाधने घेणारे.
4. इतर

प्रत्येक पर्यायाला जीवनाचा अधिकार आणि त्याची स्वतःची अंमलबजावणी वैशिष्ट्ये आहेत. येथे आम्ही सर्वात लहान L1-मापासह पर्यायाचा विचार करतो

YOLOv3 साठी मॅन्युअल प्रक्रिया

मूळ आर्किटेक्चरमध्ये अवशिष्ट ब्लॉक्स आहेत. परंतु खोल नेटवर्कसाठी ते कितीही थंड असले तरीही ते आपल्याला काही प्रमाणात अडथळा आणतील. अडचण अशी आहे की आपण या स्तरांमधील भिन्न निर्देशांकांसह सामंजस्य हटवू शकत नाही:

म्हणून, लेयर्स निवडू या ज्यामधून आपण मुक्तपणे सलोखा हटवू शकतो:

आता कार्य चक्र तयार करूया:

1. सक्रियता अपलोड करत आहे
2. किती कापायचे ते शोधत आहे
3. ते कापून टाका
4. LR=10e-1 सह 4 युग शिकणे
5. चाचणी

एका विशिष्ट टप्प्यावर आपण किती भाग काढू शकतो याचा अंदाज लावण्यासाठी कन्व्होल्यूशन अनलोड करणे उपयुक्त आहे. अनलोडिंग उदाहरणे:

आम्ही पाहतो की जवळजवळ सर्वत्र 5% कॉन्व्होल्युशनमध्ये एल1-नॉर्म खूप कमी आहे आणि आम्ही ते काढून टाकू शकतो. प्रत्येक पायरीवर, हे अनलोडिंग पुनरावृत्ती होते आणि कोणते स्तर आणि किती कापले जाऊ शकतात याचे मूल्यांकन केले गेले.

संपूर्ण प्रक्रिया 4 चरणांमध्ये पूर्ण झाली (RTX 2060 Super साठी येथे आणि सर्वत्र क्रमांक):

पाऊल	mAp75	पॅरामीटर्सची संख्या, दशलक्ष	नेटवर्क आकार, mb	सुरुवातीपासून, %	धावण्याची वेळ, ms	सुंता स्थिती
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 पट कमी केला गेला (100k वजनासह लहान कंव्होल्युशनल नेटवर्क):

धावण्याचा वेग सामान्य चढउतारांच्या अधीन असतो आणि अक्षरशः अपरिवर्तित राहतो. यासाठी एक स्पष्टीकरण आहे:

1. कन्व्होल्यूशनची संख्या सोयीस्कर (32, 64, 128) वरून व्हिडिओ कार्डसाठी सर्वात सोयीस्कर नाही - 27, 51, इ. मी येथे चुकीचे असू शकते, परंतु बहुधा त्याचा परिणाम होईल.
2. आर्किटेक्चर व्यापक नाही, परंतु सुसंगत आहे. रुंदी कमी करून, आम्ही खोलीवर परिणाम करत नाही. अशा प्रकारे, आम्ही भार कमी करतो, परंतु वेग बदलत नाही.

त्यामुळे, धावण्याच्या कालावधीत CUDA लोडमध्ये 20-30% ने घट झाल्यामुळे सुधारणा व्यक्त केली गेली, परंतु धावण्याच्या वेळेत घट झाली नाही.

परिणाम

चिंतन करूया. आम्ही छाटणीसाठी 2 पर्यायांचा विचार केला - YOLOv3 साठी (जेव्हा तुम्हाला तुमच्या हातांनी काम करावे लागेल) आणि सोप्या आर्किटेक्चरसह नेटवर्कसाठी. हे पाहिले जाऊ शकते की दोन्ही प्रकरणांमध्ये अचूकता न गमावता नेटवर्क आकार कमी करणे आणि वेग वाढवणे शक्य आहे. परिणाम:

• आकार कमी करणे
• प्रवेग रन
• CUDA लोड कमी करणे
• परिणामी, पर्यावरण मित्रत्व (आम्ही संगणकीय संसाधनांचा भविष्यातील वापर अनुकूल करतो. कुठेतरी एक आनंदी आहे ग्रेटा थनबर्ग)

परिशिष्ट

• छाटणीच्या चरणानंतर, तुम्ही परिमाण जोडू शकता (उदाहरणार्थ, TensorRT सह)
• Tensorflow साठी क्षमता प्रदान करते low_magnitude_pruning. कार्य करते.
• भांडार मला विकसित करायचे आहे आणि मला मदत करण्यात आनंद होईल

स्त्रोत: www.habr.com