Jedi tehnika konvolutsiooniliste võrkude vähendamiseks — pruning

Ees on jälle objektide tuvastamise ülesanne. Prioriteet on töö kiirus vastuvõetava täpsuse juures. Võta arhitektuur YOLOv3 ja õpi seda edasi. Täpsus (mAp75) üle 0,95. Kuid läbiviimise kiirus on endiselt madal. Kurat.

Täna jätame kvantiseerimise kõrvale. Ja allpool vaatame üle Mudeli kärpimine — üleliigsete osade eemaldamine võrgust, et kiirendada järeldusi ilma täpsuse kaotuseta. Visuaalselt — kust, kui palju ja kuidas saab kärpida. Uurime, kuidas seda käsitsi teha ja kus saab automatiseerida. Lõpus — reposoitor keras'ele.

Sissejuhatus

Eelmises töökohas, Permi Macroscopis, omandasin harjumuse — alati jälgida algoritmide täitmise aega. Ja võrgu töötlemise aega kontrolida alati adekvaatsuse filtri kaudu. Tavaliselt ei läbinud state-of-the-art tootmisest seda filtrit, mis viis mind kärpimise juurde.

Kärpimine — vana teema, millest räägiti Stanfordi loengutes 2017. aastal. Peamine idee — treenitud võrgu suuruse vähendamine ilma täpsuse kaotuseta, eemaldades erinevaid sõlmu. Kõlab vahvalt, aga harva kuulen selle rakendamisest. Tõenäoliselt puuduvad rakendused, pole venekeelseid artikleid või arvavad kõik, et kärpimine on midagi uut ja vaikivad.
Aga lähme edasi uurima

Pilguheide bioloogiasse

Mulle meeldib, kui süvaõppes saavad inspiratsiooni ideed bioloogiast. Neile, nagu ka evolutsioonile, võib toetuda (ja kas teadsid, et ReLU sarnaneb väga aju neuronite aktiveerimisfunktsiooniga?)

Mudeli kärpimise protsess on samuti seotud bioloogiaga. Võrgu reaktsiooni saab võrrelda aju plastilisusega. Mõned huvitavad näited on raamatus Norman Doidge:

1. Naisel, kes sündis ainult ühe poolega, pööras aju ennast ümber, et täita puudumise poole funktsioone
2. Noormees lasi endal maha osa ajust, mis vastutas nägemise eest. Aja jooksul võtsid teised ajupiirkonnad need funktsioonid enda kanda. (ei proovi korrata)

Nii saab ka teie mudelist eemaldada osa nõrgemaid konvolutsioone. Äärmisel juhul aitavad jäänud konvolutsioonid asendada eemaldatud osi.

Kas armastad ülekandmist õppimist või õpid nullist?

Variant number üks. Sa kasutad Transfer Learning und Yolov3, Retina, Mask-RCNN või U-Net. Kuid sagedamini ei ole meil vaja tuvastada 80 objekti kategooriat nagu COCO-s. Minu praktikas piirduvad asjad 1-2 klassiga. Võib arvestada, et 80 klassi arhitektuur on siin ülearune. Tekkib mõte, et arhitektuuri tuleks vähendada. Samal ajal tahaksin seda teha ilma olemasolevate eelõppete kaalude kaotamata.

Variant number kaks. Võib-olla on sul palju andmeid ja arvutusressursse või vajad lihtsalt superkohandatud arhitektuuri. Pole vahet. Aga sa õpetad võrku nullist. Tavaline järjekord on - vaatame andmestruktuuri, valime üleliigse võimsuse arhitektuuri ja maksimeerime dropout'ide abil üleõppimise kaitset. Olen näinud dropout'e 0.6, Karl.

Mõlemal juhul saab võrku vähendada. Motivatsioon on olemas. Nüüd liigume välja selgitama, mis asi on prune.

Üldine algoritm

Oleme otsustanud, et saame eemaldada konvolutsioonid. See näeb välja üsna lihtne:

Iga konvolutsiooni eemaldamine on võrgu jaoks stress, mis tavaliselt toob kaasa teatud tõusu veas. Ühest küljest on see veatõus näitaja, kui õigesti me konvolutsioone eemaldame (nt suur tõus näitab, et me teeme midagi valesti). Kuid väike tõus on täiesti lubatav ja tihti kaob see hilisema kerge täiendõppega väikese LR-iga. Lisame täiendõppe sammu:

Nüüd peame aru saama, millal tahame meie LearningPruning tsüklit lõpetada. Siin võivad olla eksootilised võimalused, kui me peame võrku vähendama kindla suuruse ja töötlemiskiiruseni (nt mobiilseadmete jaoks). Kuid kõige sagedasem variant on jätkata tsüklit, kuni viga ületab lubatud taseme. Lisame tingimuse:

Nii et algoritm muutub selgeks. Jääb selgeks teha, kuidas määrata eemaldatavad konvolutsioonid.

Eemaldatavate konvolutsioonide otsimine

Me peame eemaldama mõningaid konvolutsioone. Ükskõikseid eemaldada ja "otsida" igat - halb idee, kuigi see töötab. Aga kuna peame olema mõistlikud, saame mõelda ja püüda välja selekteerida "nõrgad" konvolutsioonid, mida eemaldada. Võimalusi on mitmeid:

1. Väikseim L1-meetod või low_magnitude_pruning. Idee, mis ütleb, et väikese kaaluväärtusega konvolutsioonid annavad väikese panuse lõppotsuse langetamisse.
2. Väikseim L1-meetod, arvestades keskmist ja standardhälvet. Täiendame hindamise iseloomuga jaotuse.
3. Kooridneerimise peitmine ja vähem mõjuvatest tulemustest loobumine. Täpsem määramine väheolulistest koondustest, kuid aeganõudev ja ressursimahukas.
4. Teised

Iga variandil on oma eluõigus ja rakenduse eripärad. Siin vaatleme varianti, millel on madalaim L1-mõõt.

Käsitsi protsess YOLOv3 jaoks

Tõhususe arhitektuur sisaldab jääkplokke. Kuid kuigi need on sügavate võrkude jaoks tõhusad, võivad nad meile segadust tekitada. Probleem on selles, et nendes kihtides ei saa eemaldada erinevate indeksitega koondusi:

Seega eristame kihti, millest saame koondusi vabalt eemaldada:

Nüüd loome töötsükli:

1. Eksportime aktiveerimised
2. Hinnake, kui palju on vaja sisse lõigata
3. Lõikame välja
4. Koolitame 10 epohhi LR=1e-4
5. Testime

Koonduste eksportimine on kasulik, et hinnata, kui suurt osa saame kindlal sammul eemaldada. Eksportimise näidised:

Näeme, et praktiliselt igal pool on 5% koondustest väga madala L1-normiga ja saame need eemaldada. Igal sammul kordus selline eksport ja tehti hinnang, millistest kihtidest ja kui palju on võimalik eemaldada.

Kogu protsess mahtus 4 sammu (siin ja igal pool numbrid RTX 2060 Super jaoks):

Teise sammu jooksul lisandus üks positiivne efekt — mälu suutis mahutada batši suurusega 4, mis kiirendas täiendamisprotsessi oluliselt.
Neljandas etapis peatus protsess, kuna isegi pikem täiendamine ei tõstnud mAp75 vanade väärtusteni.
Kokkuvõttes õnnestus kiirendada järelevalvet 15%, vähendada suurust 35% ja mitte kaotada täpsuses.

Automatiseerimine lihtsama arhitektuuri jaoks

Lihtsate võrguarhitektuuride (ilma tingimuslike add, concat ja jääkblokkideta) puhul on võimalik töötlemine kõikide koonduskihtide peal ning protsessi automatiseerimine.

Selle variandi rakendasin siin.
Kõik on lihtne: teilt on vaja ainult kaotuse funktsiooni, optimeerijat ja batši genereerijaid:

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)

Vajadusel saab konfigureerimise parameetreid muuta:

{
    "input_model_path": "model.h5",
    "output_model_path": "model_pruned.h5",
    "finetuning_epochs": 10, # epohide arvu, mis treenivad kärpimise sammu vahel
    "stop_loss": 0.1, # kaotus peatamiseks
    "pruning_percent_step": 0.05, # osa konvolutsioonidest, mis kustutatakse igal kärpimise sammul
    "pruning_standart_deviation_part": 0.2 # nihke määramine kärpimise osale
}

Lisaks on ellu viidud piirang, mis põhineb standardhälbel. Eesmärk on piirata eemaldatavat osa, jättes välja konvolutsioonid, mille L1 mõõtmed on juba "piisavad":

Nii võimaldame eemaldada ainult nõrkade konvolutsioonide distributsioone, mis on sarnased paremale, ja mitte mõjutada eemaldamist distributsioonidest, mis on sarnased vasakule:

Jaotuste lähenedes normaalsele jaotusest, saab kärpimise standardhälbe osa sobitada järgmiselt:

Soovitan lubada 2 sigmat. Või ei pruugi sellele omadusele tugineda, jättes väärtuse < 1.0.

Tulemuseks on graafik võrgu suurusest, kadudest ja võrgu tööaja graafik kogu testi jooksul, normeeritud tasemele 1.0. Näiteks siin oli võrgu suurust vähendatud peaaegu kaks korda ilma kvaliteedi kadumiseta (väike konvolutsioonivõrk 100k kaalu jaoks):

Töötlemise kiirus on tavalistele kõikumistele alluv ja praktiliselt ei muutunud. Sellel on seletus:

1. Konvolutsioonide arv muutub mugavast (32, 64, 128) ebamugavateks videokaartidel — 27, 51 jne. Siin võin eksida, kuid tõenäoliselt mõjutab see.
2. Arhitektuur ei ole lai, vaid järjestikune. Laiuse vähendamisel ei muuda me sügavust. Nii vähendame koormust, kuid ei muuda kiirus.

Seetõttu väljendus täiustamine CUDA koormuse vähenemises töötlusel 20-30%, kuid mitte töötlemise aja vähenemises.

Summary

Mõelgem veidi. Vaatasime kahte kärpimise varianti — YOLOv3 jaoks (kui tuleb käsitsi töötada) ja võrke lihtsama arhitektuuriga. Nähtavalt on mõlemal juhul võimalik saavutada võrgu suuruse ja kiiruseta arvutamise vähenemist täpsuse kaotamata. Tulemused:

• Suuruse vähenemine
• Töötluse kiirus
• CUDA koormuse vähenemine
• Seetõttu ökoloogilisus (Optimeerime tulevikus arvutusressursside kasutamist. Kusagil rõõmustab üks Greta Thunberg)

Lisa

• Pärast kärpimise sammu saab edendada ja kvantimist (näiteks TensorRT-ga)
• Tensorflow pakub võimalusi low_magnitude_pruning. Töötab.
• Repo soovin edasi areneda ja oleksin tänulik abi eest

Allikas: habr.com