Jedi technique para sa pagbabawas ng convolutional network - pruning

Bago ka muli ay ang gawain ng pag-detect ng mga bagay. Ang priyoridad ay ang bilis ng operasyon na may katanggap-tanggap na katumpakan. Kunin mo ang arkitektura ng YOLOv3 at sanayin mo pa ito. Ang katumpakan(mAp75) ay higit sa 0.95. Pero mababa pa rin ang run rate. Crap.

Ngayon ay i-bypass natin ang quantization. At sa ilalim ng hiwa ay titingnan natin Modelong Pruning — pag-trim ng mga kalabisan na bahagi ng network upang mapabilis ang Inference nang walang pagkawala ng katumpakan. Malinaw kung saan, magkano at kung paano mag-cut. Alamin natin kung paano ito gagawin nang manu-mano at kung saan mo ito ma-automate. Sa dulo mayroong isang imbakan sa keras.

Pagpapakilala

Sa aking nakaraang lugar ng trabaho, Macroscop sa Perm, nakuha ko ang isang ugali - na palaging subaybayan ang oras ng pagpapatupad ng mga algorithm. At palaging suriin ang runtime ng network sa pamamagitan ng isang sapat na filter. Karaniwan ang state-of-the-art sa produksyon ay hindi pumasa sa filter na ito, na humantong sa akin sa Pruning.

Ang pruning ay isang lumang paksa na tinalakay sa Nag-lecture si Stanford noong 2017. Ang pangunahing ideya ay upang bawasan ang laki ng sinanay na network nang hindi nawawala ang katumpakan sa pamamagitan ng pag-alis ng iba't ibang mga node. Mukhang cool, ngunit bihira kong marinig ang tungkol sa paggamit nito. Marahil, walang sapat na mga pagpapatupad, walang mga artikulo sa wikang Ruso, o isinasaalang-alang lamang ng lahat ang kaalaman sa pruning at nananatiling tahimik.
Ngunit paghiwalayin natin ito

Isang sulyap sa biology

Gusto ko ito kapag ang Deep Learning ay tumitingin sa mga ideya na nagmumula sa biology. Sila, tulad ng ebolusyon, ay mapagkakatiwalaan (alam mo ba na ang ReLU ay halos kapareho sa function ng neuron activation sa utak?)

Ang proseso ng Model Pruning ay malapit din sa biology. Ang tugon ng network dito ay maihahalintulad sa kaplastikan ng utak. Mayroong ilang mga kagiliw-giliw na halimbawa sa aklat. Norman Doidge:

1. Ang utak ng isang babaeng isinilang na may kalahati lamang ay nag-reprogram sa sarili upang maisagawa ang mga tungkulin ng nawawalang kalahati.
2. Binaril ng lalaki ang bahagi ng kanyang utak na responsable para sa pangitain. Sa paglipas ng panahon, kinuha ng ibang bahagi ng utak ang mga function na ito. (hindi namin sinusubukang ulitin)

Gayundin, maaari mong putulin ang ilan sa mga mahihinang convolutions mula sa iyong modelo. Bilang isang huling paraan, ang natitirang mga bundle ay makakatulong na palitan ang mga hiwa.

Mahilig ka ba sa Transfer Learning o natututo ka ba mula sa simula?

Opsyon numero uno. Gumagamit ka ng Transfer Learning sa Yolov3. Retina, Mask-RCNN o U-Net. Ngunit kadalasan ay hindi natin kailangang kilalanin ang 80 object classes tulad ng sa COCO. Sa aking pagsasanay, ang lahat ay limitado sa grade 1-2. Maaaring ipagpalagay ng isa na ang arkitektura para sa 80 mga klase ay kalabisan dito. Ito ay nagpapahiwatig na ang arkitektura ay kailangang gawing mas maliit. Higit pa rito, nais kong gawin ito nang hindi nawawala ang mga umiiral nang paunang sinanay na timbang.

Opsyon bilang dalawa. Marahil ay marami kang data at mga mapagkukunan sa pag-compute, o kailangan lang ng super-custom na arkitektura. Hindi mahalaga. Ngunit natututo ka sa network mula sa simula. Ang karaniwang pamamaraan ay tingnan ang istruktura ng data, pumili ng isang arkitektura na SOBRA sa kapangyarihan, at itulak ang mga dropout mula sa muling pagsasanay. May nakita akong 0.6 dropouts, Karl.

Sa parehong mga kaso, ang network ay maaaring mabawasan. Motivated. Ngayon, alamin natin kung anong uri ng pruning ng pagtutuli

Pangkalahatang algorithm

Napagpasyahan namin na maaari naming alisin ang mga bundle. Mukhang medyo simple:

Ang pag-alis ng anumang convolution ay nakaka-stress para sa network, na kadalasang humahantong sa ilang pagtaas ng error. Sa isang banda, ang pagtaas ng error na ito ay isang tagapagpahiwatig kung gaano ka tama ang pag-alis natin ng mga convolution (halimbawa, ang malaking pagtaas ay nagpapahiwatig na may ginagawa tayong mali). Ngunit ang isang maliit na pagtaas ay lubos na katanggap-tanggap at kadalasang inaalis sa pamamagitan ng kasunod na magaan na karagdagang pagsasanay na may maliit na LR. Magdagdag ng karagdagang hakbang sa pagsasanay:

Ngayon ay kailangan nating malaman kung kailan natin gustong ihinto ang ating Learning<->Pruning loop. Maaaring may mga kakaibang opsyon dito kapag kailangan nating bawasan ang network sa isang tiyak na laki at bilis (halimbawa, para sa mga mobile device). Gayunpaman, ang pinakakaraniwang opsyon ay ipagpatuloy ang cycle hanggang sa maging mas mataas ang error kaysa sa katanggap-tanggap. Magdagdag ng kundisyon:

Kaya, ang algorithm ay nagiging malinaw. Ito ay nananatiling upang malaman kung paano matukoy ang mga tinanggal na convolutions.

Maghanap ng mga tinanggal na bundle

Kailangan nating alisin ang ilang mga convolutions. Ang pagmamadali at "pagbaril" sa sinuman ay isang masamang ideya, bagaman ito ay gagana. Ngunit dahil may ulo ka, maaari kang mag-isip at subukang pumili ng mga "mahina" na convolution para alisin. Mayroong ilang mga pagpipilian:

1. Pinakamaliit na L1-measure o low_magnitude_pruning. Ang ideya na ang mga convolution na may maliliit na timbang ay gumagawa ng maliit na kontribusyon sa panghuling desisyon
2. Pinakamaliit na L1-measure na isinasaalang-alang ang mean at standard deviation. Nagdaragdag kami ng pagtatasa sa uri ng pamamahagi.
3. Pagtatakpan ng mga convolution at hindi kasama ang mga hindi gaanong nakakaimpluwensya sa panghuling katumpakan. Mas tumpak na pagpapasiya ng mga hindi gaanong kabuluhan na mga convolution, ngunit napakatagal at nakakaubos ng mapagkukunan.
4. Mga iba

Ang bawat isa sa mga opsyon ay may karapatan sa buhay at sarili nitong mga tampok sa pagpapatupad. Dito namin isinasaalang-alang ang opsyon na may pinakamaliit na L1-measure

Manu-manong proseso para sa YOLOv3

Ang orihinal na arkitektura ay naglalaman ng mga natitirang bloke. Pero kahit gaano sila ka-cool para sa malalalim na network, medyo hahadlangan nila tayo. Ang kahirapan ay hindi mo maaaring tanggalin ang mga pagkakasundo sa iba't ibang mga index sa mga layer na ito:

Samakatuwid, pumili tayo ng mga layer kung saan maaari nating malayang tanggalin ang mga pagkakasundo:

Ngayon, bumuo tayo ng isang siklo ng trabaho:

1. Pag-upload ng mga pag-activate
2. Inaalam kung magkano ang dapat i-cut
3. Gupitin
4. Pag-aaral ng 10 panahon gamit ang LR=1e-4
5. Pagsubok

Ang pag-unload ng mga convolution ay kapaki-pakinabang upang matantya kung gaano karaming bahagi ang maaari nating alisin sa isang tiyak na hakbang. Mga halimbawa ng pagbabawas:

Nakikita namin na halos lahat ng lugar 5% ng mga convolution ay may napakababang L1-norm at maaari naming alisin ang mga ito. Sa bawat hakbang, inulit ang pagbabawas na ito at ginawa ang pagtatasa kung aling mga layer at ilan ang maaaring putulin.

Nakumpleto ang buong proseso sa 4 na hakbang (mga numero dito at saanman para sa RTX 2060 Super):

Hakbang	mAp75	Bilang ng mga parameter, milyon	Laki ng network, mb	Mula sa simula, %	Oras ng pagtakbo, ms	Kondisyon ng pagtutuli
0	0.9656	60	241	100	180	-
1	0.9622	55	218	91	175	5% ng lahat
2	0.9625	50	197	83	168	5% ng lahat
3	0.9633	39	155	64	155	15% para sa mga layer na may 400+ convolutions
4	0.9555	31	124	51	146	10% para sa mga layer na may 100+ convolutions

Isang positibong epekto ang idinagdag sa hakbang 2 - ang laki ng batch 4 ay umaangkop sa memorya, na lubos na nagpabilis sa proseso ng karagdagang pagsasanay.
Sa hakbang 4, ang proseso ay itinigil dahil kahit na ang pangmatagalang karagdagang pagsasanay ay hindi nagtaas ng mAp75 sa mga lumang halaga.
Bilang resulta, nagawa naming pabilisin ang hinuha sa pamamagitan ng 15%, bawasan ang laki ng 35% at hindi eksaktong mawala.

Automation para sa mas simpleng mga arkitektura

Para sa mas simpleng mga arkitektura ng network (nang walang conditional add, concaternate at residual blocks), medyo posible na tumuon sa pagproseso ng lahat ng convolutional layer at i-automate ang proseso ng pagputol ng convolutions.

Ipinatupad ko ang opsyong ito dito.
Simple lang: kailangan mo lang ng loss function, optimizer at batch generators:

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)

Kung kinakailangan, maaari mong baguhin ang mga parameter ng config:

{
    "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
}

Bilang karagdagan, ang isang limitasyon batay sa karaniwang paglihis ay ipinatupad. Ang layunin ay upang limitahan ang bahagi na aalisin, hindi kasama ang mga convolution na may "sapat na" L1 na mga sukat:

Kaya, pinapayagan ka naming alisin ang mga mahihinang convolution lamang mula sa mga distribusyon na katulad ng sa kanan at hindi makakaapekto sa pag-alis mula sa mga distribusyon na katulad ng kaliwa:

Kapag ang distribusyon ay lumalapit sa normal, ang pruning_standart_deviation_part coefficient ay maaaring mapili mula sa:

Inirerekumenda ko ang isang pagpapalagay ng 2 sigma. O maaari mong balewalain ang feature na ito, na iniiwan ang value na < 1.0.

Ang output ay isang graph ng laki, pagkawala, at runtime ng network para sa buong pagsubok, na na-normalize sa 1.0. Halimbawa, dito nabawasan ang laki ng network ng halos 2 beses nang walang pagkawala ng kalidad (maliit na convolutional network na may 100k na timbang):

Ang bilis ng pagpapatakbo ay napapailalim sa mga normal na pagbabago at nananatiling halos hindi nagbabago. Mayroong paliwanag para dito:

1. Ang bilang ng mga convolution ay nagbabago mula sa maginhawa (32, 64, 128) hanggang sa hindi pinaka-maginhawa para sa mga video card - 27, 51, atbp. Maaaring mali ako dito, ngunit malamang na may epekto ito.
2. Ang arkitektura ay hindi malawak, ngunit pare-pareho. Sa pamamagitan ng pagbabawas ng lapad, hindi namin naaapektuhan ang lalim. Kaya, binabawasan namin ang pagkarga, ngunit hindi binabago ang bilis.

Samakatuwid, ang pagpapabuti ay ipinahayag sa isang pagbawas sa CUDA load sa panahon ng pagtakbo ng 20-30%, ngunit hindi sa isang pagbawas sa oras ng pagtakbo

Mga resulta ng

Magmuni-muni tayo. Isinasaalang-alang namin ang 2 pagpipilian para sa pruning - para sa YOLOv3 (kapag kailangan mong magtrabaho gamit ang iyong mga kamay) at para sa mga network na may mas simpleng mga arkitektura. Makikita na sa parehong mga kaso posible na makamit ang pagbawas sa laki ng network at pagpapabilis nang walang pagkawala ng katumpakan. Mga resulta:

• Pagbawas ng laki
• Pagpapabilis ng pagtakbo
• Pagbawas ng CUDA Load
• Bilang resulta, pagiging magiliw sa kapaligiran (Ina-optimize namin ang hinaharap na paggamit ng mga mapagkukunan sa pag-compute. Sa isang lugar ay masaya ang isa Greta Thunberg)

Apendiks

• Pagkatapos ng pruning step, maaari kang magdagdag ng quantization (halimbawa, sa TensorRT)
• Nagbibigay ang Tensorflow ng mga kakayahan para sa mababang_magnitude_pruning. Gumagana.
• imbakan Gusto kong umunlad at ikalulugod kong tumulong

Pinagmulan: www.habr.com