Jedai tehnika konvolutsioonivõrkude vähendamiseks — pruning

Ees on taas objektide tuvastamise ülesanne. Peamine prioriteet on töö kiirus vastuvõetava täpsuse juures. Kasutad YOLOv3 arhitektuuri ja täiendad seda. Täpsus (mAp75) üle 0.95. Kuid töötlemise kiirus on endiselt madal. Kuradi.

Täna jätame kvantiseerimise kõrvale. Ja allpool vaatame Model Pruning — üleliigsete osade eemaldamine võrgu kiirendamiseks ilma täpsuse kaotamiseta. Selgelt — kust, kui palju ja kuidas on võimalik lõigata. Arutame, kuidas seda käsitsi teha ja kus saab automatiseerida. Lõpus — repository keras'e jaoks.

Sissejuhatus

Eelmisel töökohtadel, permis Macroscopis, omandasin ma ühe harjumuse — alati jälgida algoritmide täitmise aega. Ja võrgu töötlemise aega kontrollida alati adekvaatsuse filtri kaudu. Tavaliselt ei vasta state-of-the-art tootmises sellele filtrile, mis viis mind Pruning'uni.

Pruning — vana teema, millest räägiti Stanfordi loengutes 2017. aastal. Peamine idee — koolitatud võrgu suuruse vähendamine ilma täpsuse kaotamiseta, eemaldades mitmesuguseid sõlmi. Kõlab hästi, kuid ma harva kuulen selle rakendamisest. Tõenäoliselt puuduvad rakendused, ei ole venekeelseid artikleid või lihtsalt peetakse pruning’t omaette teadmisteks ja vaikivad.
Aga läheme siis arutama

Vaade bioloogiale

Mulle meeldib, kui sügavale õppimisse toovad ideid bioloogiast. Neile, nagu ka evolutsioonile, võib usaldada (kas teadsite, et ReLU on väga sarnane ajurakkude aktiveerimise funktsiooniga?)

Model Pruning protsess on samuti lähedane bioloogiale. Võrgu reaktsiooni saab võrrelda aju plastilisusega. Raamatus on paar huvitavat näidet Norman Doidge'i:

1. Naise aju, kellel oli sündides vaid üks pool, programmeeris end ise ümber, et täita puuduvat poole funktsioone
2. Noormees tulistas endale osa ajust, mis vastutab nägemise eest. Aja jooksul võtsid teised ajupiirkonnad need funktsioonid enda kanda. (ei püüa korrata)

Nii saab ka teie mudelist eemaldada osad nõrgad konvolutsioonid. Äärmisel juhul aitavad allesjäänud konvolutsioonid asendada eemaldatud.

Kas armastad Transfer Learningut või õpid algusest peale?

Variant number üks. Kasutad Transfer Learningut Yolov3-l. Retina, Mask-RCNN või U-Net. Kuid sageli pole meil vaja tuvastada 80 klassi objekte, nagu COCO-s. Minu praktikas piirduvad asjad 1-2 klassiga. Võib eeldada, et 80 klassile mõeldud arhitektuur on siin üleliigne. Tundub, et see tuleks vähendada. Ja oleks soovitav teha seda ilma olemasolevaid eelõpetatud kehiseid kaotamata.

Variant number kaks. Võib-olla on sul palju andmeid ja arvutusvõimekust või lihtsalt vaja ülireguleeritud arhitektuuri. Pole oluline. Kuid õpid võrku algusest peale. Tavaline järjekord — vaatame andmestruktuuri, valime ÜLELIIGSE võimsusega arhitektuuri ja pushime dropout'e üleõppimise vastu. Olen näinud dropout'e 0.6, Karl.

Mõlemal juhul saab võrku vähendada. Oleme motiveeritud. Nüüd liigume edasi arutama, mis asi see pruning on.

Üldine algoritm

Oleme otsustanud, et saame eemaldada konvolutsioonid. See tundub üsna lihtne:

Iga konvolutsiooni eemaldamine on võrgu jaoks stress, mis toob tavaliselt kaasa ka teatud tõusu vea. Ühelt poolt on see vea tõus märk sellest, kui õigesti me konvolutsioonide eemaldamisega tegeleme (näiteks suur tõus ütleb, et me teeme midagi valesti). Kuid väike tõus on täiesti aktsepteeritav ja sageli kõrvaldatakse järgnevate kergete õpetustega väikese LR-ga. Lisame õpetamise etapi:

Nüüd peame aru saama, millal soovime lõpetada meie Learning<->Pruning tsükli. Siin võivad olla eksootilised variandid, kus peame võrku vähendama teatud suurusele ja töötlemise kiiruseni (näiteks mobiilseadmete jaoks). Siiski on kõige sagedasem variant — tsükli jätkamine seni, kuni viga ei ole üle lubatud. Lisame tingimuse:

Nii et algoritm on arusaadav. Jääb avatuks, kuidas määrata eemaldatavad konvolutsioonid.

Eemaldatavate konvolutsioonide otsimine

Peame eemaldama mõned konvolutsioonid. Karm ründamine ja igaühe "maha tulistamine" on halb idee, kuigi see töötab. Kuid kuna pea on olemas, saab mõelda ja proovida eristada eemaldamiseks „nõrgad” konvolutsioonid. Variant on mitu:

1. Väikseim L1-mõõde või low_magnitude_pruning. Idee, mis ütleb, et väikesed kaaludega konvolutsioonid annavad vähese panuse lõppotsusesse.
2. Väikseim L1-mõõde arvestades keskmist ja стандартhälvet. Täiendame jaotuse iseloomu hindamisega.
3. Konvolutsioonide maskeerimine ja nende väike mõju lõpptäpsusele välistamine.. Täpsem määratlemine väikese tähtsusega konvolutsioonidest, kuid üsna ajamahukas ja ressursimahukas.
4. Muud

Igal variandil on eluõigus ja oma rakenduse omadused. Siin vaatame väikseimale L1-mõõtmele põhinevat varianti.

Käsitsi protsess YOLOv3 jaoks

Algse arhitektuuris on jäänud jääkplokid. Kuigi need on sügavate võrkude jaoks äärmiselt kasulikud, võivad need meid siiski takistada. Probleem on selles, et erinevate indeksitega kokkulangevusi ei saa nende kihtide sees kustutada:

Seega eristame kihte, kust saame vabalt kokkulangevusi eemaldada:

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

1. Laadime välja aktiveeringud
2. Kalkuleerime, kui palju kärpida
3. Kärpime
4. Treeni 10 epohi LR=1e-4
5. Testime

Kokkusurumine on kasulik, et hinnata, kui palju me teatud sammul eemaldada saame. Näited väljalaskmisest:

Nägime, et praktiliselt igal pool on 5% kokkusurumisest üsna madala L1-normiga ja saame need eemaldada. Igal sammul korrati sellist väljalaset ja hinnati, millistelt kihtidelt ja kui palju saab kärpida.

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

Teise etapi juurde lisandus üks positiivne efekt — mälu mahub batch-size 4, mis kiirendas täiendõppe protsessi.
Neljas etapp peatati, kuna isegi pikaajaline täiendõpe ei tõstnud mAp75 varasematele tasemetele.
Kokkuvõttes õnnestus kiirendada inference'i 15%, vähendada suurust 35% ja mitte kaotada täpsuses.

Automatiseerimine lihtsamate arhitektuuride jaoks

Lihtsamate võrguarhitektuuride (ilma tingimuslike add, concatenate ja residual plokkideta) puhul on täiesti võimalik orienteeruda kõigi kokkusurumiste töötlemisel ja automatiseerida kokkusurumise eemaldamise protsess.

Sellise variandi olen ma rakendanud siit.
Kõik on lihtne: teilt on ainult vajalik kahanemise funktsioon, optimeerija ja batch-generaadoreid:

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, # epohhide arv treenimise ajal kärpimise etappide vahel
    "stop_loss": 0.1, # kaotus peatamise protsessi jaoks
    "pruning_percent_step": 0.05, # osa konvolutsioonidest, mis eemaldatakse igal kärpimise sammul
    "pruning_standart_deviation_part": 0.2 # piiri seotuse kärpimise osa
}

Lisaks on rakendatud piirang, mis põhineb standardhälbel. Eesmärk on piirata eemaldatavate osakaalu, välistades kokkusurumised, mille L1-mõõdikud on juba "piisavad":

Sellega lubame eemaldada ainult nõrgad kokkusurumised jaotustest, mis meenutavad paremat, ning mitte mõjutada eemaldamist jaotustest, mis meenutavad vasakut:

Jaotuse lähenedes normaalsele, saab pruning_standart_deviation_part koosta jälgida:

Soovitan 2 sigma piirangut. Või võib selle eripära mitte silmas pidada, jättes väärtuse < 1.0.

Lõpptulemusena saadakse võrgusuuruse, kaotuse ja käitamisaja graafikid kogu katse jooksul, normeeritud 1.0-le. Näiteks siin oli võrgu suurus peaaegu kahekordistunud kvaliteedi kaotamata (väike konvolutsiooniline võrgu 100k kaaluga):

Käitamisaeg allub normaalsetele kõikumistele ja ei ole praktiliselt muutunud. Sellel on seletus:

1. Kokkusurumiste arv muutub mugavast (32, 64, 128) ebamugavaks videokaartidele — 27, 51 jne. Siin võin eksida, kuid tõenäoliselt see mõjutab.
2. Arhitektuur ei ole lai, kuid järjestikune. Laidude vähendamine ei muuda sügavust. Seega vähendame koormat, kuid ei muuda kiirus.

Seetõttu väljendub paranemine CUDA koormuse vähenemises 20-30% käitamisel, kuid mitte käitamise aja vähenemises.

Kokkuvõte

Reflekteerime. Oleme vaadanud kahte pruning'i varianti — YOLOv3 jaoks (kui tuleb kätega töötada) ja lihtsama arhitektuuriga võrke. On ilmne, et mõlemas olukorras saab saavutada võrgu suuruse vähendamise ja kiirendamise ilma täpsuse kaotamata. Tulemused:

• Suuruse vähenemine
• Käitamise kiirus
• CUDA koormuse vähenemine
• Järgnevalt ka keskkonnaalane mõju (me optimeerime tulevase arvutusressursside kasutamise). Kuskil on üks Greta Thunberg)

Lisa

• Pärast kärpimist saab veel töötada ka kvantimisega (näiteks TensorRT kaudu)
• Tensorflow pakub võimalusi low_magnitude_pruning. See töötab.
• Repo soovin seda edasi arendada ja olen avatud abile

Allikas: habr.com