કન્વોલ્યુશનલ નેટવર્ક્સને ઘટાડવા માટે જેડી ટેકનિક - કાપણી

તમે ફરીથી વસ્તુઓ શોધવાનું કાર્ય છે તે પહેલાં. અગ્રતા સ્વીકાર્ય ચોકસાઈ સાથે કામગીરીની ઝડપ છે. તમે YOLOv3 આર્કિટેક્ચર લો અને તેને વધુ તાલીમ આપો. ચોકસાઈ(mAp75) 0.95 કરતા વધારે છે. પરંતુ રન રેટ હજુ પણ ઓછો છે. વાહિયાત.

આજે આપણે પરિમાણને બાયપાસ કરીશું. અને કટ હેઠળ આપણે જોઈશું મોડલ કાપણી — ચોકસાઈ ગુમાવ્યા વિના અનુમાનને ઝડપી બનાવવા માટે નેટવર્કના બિનજરૂરી ભાગોને ટ્રિમ કરવું. તે સ્પષ્ટ છે કે ક્યાં, કેટલું અને કેવી રીતે કાપવું. ચાલો આ મેન્યુઅલી કેવી રીતે કરવું અને તમે તેને ક્યાં સ્વચાલિત કરી શકો તે શોધી કાઢીએ. અંતે કેરા પર એક ભંડાર છે.

પરિચય

મારા અગાઉના કામના સ્થળે, પર્મમાં મેક્રોસ્કોપ, મેં એક આદત મેળવી લીધી - એલ્ગોરિધમ્સના અમલના સમયનું હંમેશા નિરીક્ષણ કરવું. અને હંમેશા પર્યાપ્તતા ફિલ્ટર દ્વારા નેટવર્ક રનટાઇમ તપાસો. સામાન્ય રીતે ઉત્પાદનમાં અદ્યતન આ ફિલ્ટર પસાર કરતું નથી, જે મને કાપણી તરફ દોરી ગયું.

કાપણી એ એક જૂનો વિષય છે જેની ચર્ચા કરવામાં આવી હતી સ્ટેનફોર્ડ પ્રવચનો 2017 માં. મુખ્ય વિચાર વિવિધ ગાંઠો દૂર કરીને ચોકસાઈ ગુમાવ્યા વિના પ્રશિક્ષિત નેટવર્કના કદને ઘટાડવાનો છે. તે સરસ લાગે છે, પરંતુ હું તેના ઉપયોગ વિશે ભાગ્યે જ સાંભળું છું. સંભવતઃ, ત્યાં પૂરતા અમલીકરણો નથી, ત્યાં કોઈ રશિયન-ભાષાના લેખો નથી, અથવા ફક્ત દરેક જણ તેને કાપણીનું જ્ઞાન માને છે અને મૌન રહે છે.
પરંતુ ચાલો તેને અલગ લઈએ

જીવવિજ્ઞાનની એક ઝલક

જ્યારે ડીપ લર્નિંગ બાયોલોજીમાંથી આવતા વિચારોને જુએ છે ત્યારે મને તે ગમે છે. તેઓ, ઉત્ક્રાંતિની જેમ, વિશ્વાસ કરી શકાય છે (શું તમે જાણો છો કે ReLU ખૂબ સમાન છે મગજમાં ન્યુરોન સક્રિયકરણનું કાર્ય?)

મોડલ કાપણી પ્રક્રિયા પણ જીવવિજ્ઞાનની નજીક છે. અહીં નેટવર્કના પ્રતિભાવને મગજની પ્લાસ્ટિસિટી સાથે સરખાવી શકાય છે. પુસ્તકમાં કેટલાક રસપ્રદ ઉદાહરણો છે. નોર્મન ડોજ:

1. માત્ર એક અર્ધ સાથે જન્મેલી સ્ત્રીનું મગજ ગુમ થયેલા અડધા ભાગના કાર્યો કરવા માટે પોતાને ફરીથી પ્રોગ્રામ કરે છે.
2. વ્યક્તિએ દ્રષ્ટિ માટે જવાબદાર તેના મગજના ભાગને ગોળી મારી દીધી હતી. સમય જતાં, મગજના અન્ય ભાગોએ આ કાર્યો પર કબજો કર્યો. (અમે પુનરાવર્તન કરવાનો પ્રયાસ કરી રહ્યા નથી)

તેવી જ રીતે, તમે તમારા મોડેલમાંથી કેટલાક નબળા કન્વોલ્યુશનને કાપી શકો છો. છેલ્લા ઉપાય તરીકે, બાકીના બંડલ કાપેલાને બદલવામાં મદદ કરશે.

શું તમને ટ્રાન્સફર લર્નિંગ ગમે છે કે તમે શરૂઆતથી શીખો છો?

વિકલ્પ નંબર એક. તમે Yolov3 પર ટ્રાન્સફર લર્નિંગનો ઉપયોગ કરો છો. રેટિના, માસ્ક-આરસીએનએન અથવા યુ-નેટ. પરંતુ મોટાભાગે આપણે COCO જેવા 80 ઓબ્જેક્ટ વર્ગોને ઓળખવાની જરૂર નથી. મારી પ્રેક્ટિસમાં, બધું 1-2 ગ્રેડ સુધી મર્યાદિત છે. કોઈ એવું માની શકે છે કે 80 વર્ગો માટેનું આર્કિટેક્ચર અહીં બિનજરૂરી છે. આ સૂચવે છે કે આર્કિટેક્ચરને નાનું બનાવવાની જરૂર છે. તદુપરાંત, હું હાલના પૂર્વ પ્રશિક્ષિત વજનને ગુમાવ્યા વિના આ કરવા માંગુ છું.

વિકલ્પ નંબર બે. કદાચ તમારી પાસે ઘણા બધા ડેટા અને કમ્પ્યુટિંગ સંસાધનો છે, અથવા ફક્ત એક સુપર-કસ્ટમ આર્કિટેક્ચરની જરૂર છે. વાંધો નથી. પરંતુ તમે શરૂઆતથી નેટવર્ક શીખી રહ્યા છો. સામાન્ય પ્રક્રિયા એ છે કે ડેટા સ્ટ્રક્ચર જોવાનું, એક આર્કિટેક્ચર પસંદ કરવું કે જે શક્તિમાં વધુ હોય અને ડ્રોપઆઉટ્સને ફરીથી તાલીમમાંથી દબાણ કરો. મેં 0.6 ડ્રોપઆઉટ જોયા, કાર્લ.

બંને કિસ્સાઓમાં, નેટવર્ક ઘટાડી શકાય છે. પ્રેરિત. હવે ચાલો જાણીએ કે સુન્નત કાપણી કયા પ્રકારની છે

સામાન્ય અલ્ગોરિધમનો

અમે નક્કી કર્યું કે અમે બંડલ્સ દૂર કરી શકીએ છીએ. તે એકદમ સરળ લાગે છે:

કોઈપણ કન્વ્યુલેશનને દૂર કરવું નેટવર્ક માટે તણાવપૂર્ણ છે, જે સામાન્ય રીતે ભૂલમાં થોડો વધારો તરફ દોરી જાય છે. એક તરફ, ભૂલમાં આ વધારો એ સૂચક છે કે આપણે કેટલી યોગ્ય રીતે કન્વોલ્યુશનને દૂર કરીએ છીએ (ઉદાહરણ તરીકે, મોટો વધારો સૂચવે છે કે આપણે કંઈક ખોટું કરી રહ્યા છીએ). પરંતુ એક નાનો વધારો તદ્દન સ્વીકાર્ય છે અને ઘણી વખત નાના LR સાથે અનુગામી પ્રકાશ વધારાની તાલીમ દ્વારા દૂર કરવામાં આવે છે. એક વધારાનું તાલીમ પગલું ઉમેરો:

હવે આપણે આપણા લર્નિંગપ્રુનિંગ લૂપને ક્યારે બંધ કરવા માંગીએ છીએ તે શોધવાની જરૂર છે. જ્યારે આપણે નેટવર્કને ચોક્કસ કદ અને ઝડપ સુધી ઘટાડવાની જરૂર હોય ત્યારે અહીં વિચિત્ર વિકલ્પો હોઈ શકે છે (ઉદાહરણ તરીકે, મોબાઇલ ઉપકરણો માટે). જો કે, ભૂલ સ્વીકાર્ય કરતાં વધુ ન થાય ત્યાં સુધી ચક્ર ચાલુ રાખવાનો સૌથી સામાન્ય વિકલ્પ છે. શરત ઉમેરો:

તેથી, અલ્ગોરિધમ સ્પષ્ટ બને છે. કાઢી નાખેલ કન્વોલ્યુશન કેવી રીતે નક્કી કરવું તે શોધવાનું બાકી છે.

કાઢી નાખેલ પેકેજો માટે શોધો

અમારે કેટલાક કન્વ્યુલેશન્સ દૂર કરવાની જરૂર છે. આગળ દોડવું અને કોઈપણને "શૂટીંગ" કરવું એ ખરાબ વિચાર છે, જો કે તે કામ કરશે. પરંતુ તમારી પાસે માથું હોવાથી, તમે વિચારી શકો છો અને દૂર કરવા માટે "નબળા" કન્વોલ્યુશન પસંદ કરવાનો પ્રયાસ કરી શકો છો. ત્યાં ઘણા વિકલ્પો છે:

1. સૌથી નાનું L1-માપ અથવા ઓછી_મેગ્નિટ્યુડ_કાપણી. આ વિચાર કે નાના વજનવાળા કન્વોલ્યુશન અંતિમ નિર્ણયમાં થોડો ફાળો આપે છે
2. સરેરાશ અને પ્રમાણભૂત વિચલનને ધ્યાનમાં લેતા સૌથી નાનું L1-માપ. અમે વિતરણની પ્રકૃતિના મૂલ્યાંકન સાથે પૂરક છીએ.
3. કન્વોલ્યુશનને માસ્ક કરવું અને અંતિમ ચોકસાઈને ઓછામાં ઓછી અસર કરે છે તેને બાકાત રાખવું. મામૂલી સંક્રમણોનું વધુ સચોટ નિર્ધારણ, પરંતુ ખૂબ જ સમય માંગી લેતું અને સંસાધન-વપરાશ.
4. અન્ય

દરેક વિકલ્પોમાં જીવનનો અધિકાર અને તેની પોતાની અમલીકરણ સુવિધાઓ છે. અહીં આપણે સૌથી નાના L1-માપ સાથેના વિકલ્પને ધ્યાનમાં લઈએ છીએ

YOLOv3 માટે મેન્યુઅલ પ્રક્રિયા

મૂળ આર્કિટેક્ચરમાં શેષ બ્લોક્સ છે. પરંતુ ડીપ નેટવર્ક્સ માટે તેઓ ગમે તેટલા ઠંડા હોય, તેઓ અમને કંઈક અંશે અવરોધ કરશે. મુશ્કેલી એ છે કે તમે આ સ્તરોમાં વિવિધ અનુક્રમણિકાઓ સાથેના સમાધાનને કાઢી શકતા નથી:

તેથી, ચાલો સ્તરો પસંદ કરીએ જેમાંથી આપણે મુક્તપણે સમાધાન કાઢી શકીએ:

ચાલો હવે કાર્ય ચક્ર બનાવીએ:

1. સક્રિયકરણો અપલોડ કરી રહ્યાં છીએ
2. કેટલું કાપવું તે નક્કી કરવું
3. કાપી નાખો
4. LR=10e-1 સાથે 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 ગણું ઓછું કરવામાં આવ્યું હતું (100k વજન સાથેનું નાનું કન્વોલ્યુશનલ નેટવર્ક):

દોડવાની ઝડપ સામાન્ય વધઘટને આધીન છે અને વર્ચ્યુઅલ રીતે યથાવત રહે છે. આ માટે એક સમજૂતી છે:

1. કન્વોલ્યુશનની સંખ્યા અનુકૂળ (32, 64, 128) થી વિડીયો કાર્ડ્સ માટે સૌથી અનુકૂળ નથી - 27, 51, વગેરેમાં બદલાય છે. હું અહીં ખોટો હોઈ શકું છું, પરંતુ મોટે ભાગે તેની અસર થાય છે.
2. આર્કિટેક્ચર વ્યાપક નથી, પરંતુ સુસંગત છે. પહોળાઈ ઘટાડીને, અમે ઊંડાઈને અસર કરતા નથી. આમ, અમે ભાર ઘટાડીએ છીએ, પરંતુ ઝડપમાં ફેરફાર કરતા નથી.

તેથી, રન દરમિયાન CUDA લોડમાં 20-30% ના ઘટાડા દ્વારા સુધારો દર્શાવવામાં આવ્યો હતો, પરંતુ રન ટાઈમમાં ઘટાડો થયો નથી.

પરિણામો

ચાલો પ્રતિબિંબિત કરીએ. અમે કાપણી માટે 2 વિકલ્પો ધ્યાનમાં લીધા - YOLOv3 માટે (જ્યારે તમારે તમારા હાથથી કામ કરવું હોય) અને સરળ આર્કિટેક્ચરવાળા નેટવર્ક્સ માટે. તે જોઈ શકાય છે કે બંને કિસ્સાઓમાં ચોકસાઈ ગુમાવ્યા વિના નેટવર્ક કદમાં ઘટાડો અને ગતિ પ્રાપ્ત કરવી શક્ય છે. પરિણામો:

• કદ ઘટાડવું
• પ્રવેગક રન
• CUDA લોડ ઘટાડવું
• પરિણામે, પર્યાવરણીય મિત્રતા (અમે કમ્પ્યુટિંગ સંસાધનોના ભાવિ ઉપયોગને શ્રેષ્ઠ બનાવીએ છીએ. ક્યાંક કોઈ ખુશ છે ગ્રેટા થનબર્ગ)

પરિશિષ્ટ

• કાપણીના પગલા પછી, તમે પરિમાણ ઉમેરી શકો છો (ઉદાહરણ તરીકે, TensorRT સાથે)
• ટેન્સરફ્લો માટે ક્ષમતાઓ પૂરી પાડે છે ઓછી_મેગ્નિટ્યુડ_કાપણી. કામ કરે છે.
• ભંડાર હું વિકાસ કરવા માંગુ છું અને મદદ કરવામાં આનંદ થશે

સોર્સ: www.habr.com