మీరు మళ్ళీ వస్తువులను గుర్తించే పని ముందు. ఆమోదయోగ్యమైన ఖచ్చితత్వంతో ఆపరేషన్ వేగం ప్రాధాన్యత. మీరు YOLOv3 నిర్మాణాన్ని తీసుకొని దానికి మరింత శిక్షణ ఇవ్వండి. ఖచ్చితత్వం(mAp75) 0.95 కంటే ఎక్కువ. కానీ రన్ రేట్ ఇంకా తక్కువగానే ఉంది. చెత్త.
ఈ రోజు మనం పరిమాణీకరణను దాటవేస్తాము. మరియు కట్ కింద మేము చూస్తాము మోడల్ కత్తిరింపు — ఖచ్చితత్వం కోల్పోకుండా అనుమితిని వేగవంతం చేయడానికి నెట్‌వర్క్ యొక్క అనవసరమైన భాగాలను కత్తిరించడం. ఎక్కడ, ఎంత మరియు ఎలా కట్ చేయాలో స్పష్టంగా ఉంది. దీన్ని మాన్యువల్‌గా ఎలా చేయాలో మరియు మీరు దీన్ని ఎక్కడ ఆటోమేట్ చేయవచ్చో తెలుసుకుందాం. చివరలో కేరాస్‌పై రిపోజిటరీ ఉంది.
పరిచయం
నా మునుపటి పని ప్రదేశంలో, పెర్మ్‌లోని మాక్రోస్కోప్‌లో, నేను ఒక అలవాటును సంపాదించాను - అల్గారిథమ్‌ల అమలు సమయాన్ని ఎల్లప్పుడూ పర్యవేక్షించడం. మరియు ఎల్లప్పుడూ అడిక్వసీ ఫిల్టర్ ద్వారా నెట్‌వర్క్ రన్‌టైమ్‌ను తనిఖీ చేయండి. సాధారణంగా ఉత్పత్తిలో స్టేట్ ఆఫ్ ది ఆర్ట్ ఈ ఫిల్టర్‌ని పాస్ చేయదు, ఇది నన్ను కత్తిరింపుకు దారితీసింది.
కత్తిరింపు అనేది చర్చించబడిన పాత అంశం 2017లో వివిధ నోడ్‌లను తొలగించడం ద్వారా ఖచ్చితత్వాన్ని కోల్పోకుండా శిక్షణ పొందిన నెట్‌వర్క్ పరిమాణాన్ని తగ్గించడం ప్రధాన ఆలోచన. ఇది చాలా బాగుంది, కానీ దాని ఉపయోగం గురించి నేను చాలా అరుదుగా వింటాను. బహుశా, తగినంత అమలులు లేవు, రష్యన్ భాషా కథనాలు లేవు, లేదా ప్రతి ఒక్కరూ దానిని కత్తిరింపు జ్ఞానంగా భావించి మౌనంగా ఉంటారు.
కానీ దానిని విడిగా తీసుకుందాం
జీవశాస్త్రంలో ఒక సంగ్రహావలోకనం
డీప్ లెర్నింగ్ జీవశాస్త్రం నుండి వచ్చిన ఆలోచనలను చూసినప్పుడు నేను దానిని ఇష్టపడతాను. పరిణామం వంటి వాటిని విశ్వసించవచ్చు (ReLU చాలా పోలి ఉంటుందని మీకు తెలుసా ?)
మోడల్ కత్తిరింపు ప్రక్రియ కూడా జీవశాస్త్రానికి దగ్గరగా ఉంటుంది. ఇక్కడ నెట్‌వర్క్ ప్రతిస్పందనను మెదడు యొక్క ప్లాస్టిసిటీతో పోల్చవచ్చు. పుస్తకంలో కొన్ని ఆసక్తికరమైన ఉదాహరణలు ఉన్నాయి. :
- ఒక సగం మాత్రమే జన్మించిన మహిళ యొక్క మెదడు తప్పిపోయిన సగం యొక్క విధులను నిర్వహించడానికి తనను తాను రీప్రోగ్రామ్ చేసుకుంది.
- ఆ వ్యక్తి దృష్టికి కారణమైన అతని మెదడులోని భాగాన్ని కాల్చాడు. కాలక్రమేణా, మెదడులోని ఇతర భాగాలు ఈ విధులను చేపట్టాయి. (మేము పునరావృతం చేయడానికి ప్రయత్నించడం లేదు)
అదేవిధంగా, మీరు మీ మోడల్ నుండి కొన్ని బలహీనమైన మెలికలు కత్తిరించవచ్చు. చివరి ప్రయత్నంగా, మిగిలిన కట్టలు కత్తిరించిన వాటిని భర్తీ చేయడానికి సహాయపడతాయి.
మీరు బదిలీ అభ్యాసాన్ని ఇష్టపడుతున్నారా లేదా మీరు మొదటి నుండి నేర్చుకుంటున్నారా?
ఎంపిక నంబర్ వన్. మీరు Yolov3లో బదిలీ అభ్యాసాన్ని ఉపయోగిస్తున్నారు. రెటీనా, మాస్క్-RCNN లేదా U-Net. కానీ చాలా సార్లు మనం COCOలో లాగా 80 ఆబ్జెక్ట్ క్లాస్‌లను గుర్తించాల్సిన అవసరం లేదు. నా ఆచరణలో, ప్రతిదీ 1-2 తరగతులకు పరిమితం చేయబడింది. 80 తరగతులకు సంబంధించిన ఆర్కిటెక్చర్ ఇక్కడ అనవసరంగా ఉందని అనుకోవచ్చు. ఇది నిర్మాణాన్ని చిన్నదిగా చేయాల్సిన అవసరం ఉందని సూచిస్తుంది. అంతేకాకుండా, ఇప్పటికే ఉన్న ముందస్తు శిక్షణ పొందిన బరువులను కోల్పోకుండా దీన్ని చేయాలనుకుంటున్నాను.
ఎంపిక సంఖ్య రెండు. బహుశా మీరు చాలా డేటా మరియు కంప్యూటింగ్ వనరులను కలిగి ఉండవచ్చు లేదా సూపర్-కస్టమ్ ఆర్కిటెక్చర్ అవసరం కావచ్చు. పర్వాలేదు. కానీ మీరు మొదటి నుండి నెట్‌వర్క్‌ని నేర్చుకుంటున్నారు. డేటా స్ట్రక్చర్‌ను చూడటం, అధిక శక్తి కలిగిన నిర్మాణాన్ని ఎంచుకోవడం మరియు తిరిగి శిక్షణ నుండి డ్రాప్‌అవుట్‌లను నెట్టడం సాధారణ విధానం. నేను 0.6 డ్రాపౌట్‌లను చూశాను, కార్ల్.
రెండు సందర్భాల్లో, నెట్‌వర్క్‌ను తగ్గించవచ్చు. ప్రేరణ పొందింది. సున్తీ కత్తిరింపు ఎలాంటిదో ఇప్పుడు తెలుసుకుందాం
సాధారణ అల్గోరిథం
మేము కట్టలను తీసివేయవచ్చని నిర్ణయించుకున్నాము. ఇది చాలా సరళంగా కనిపిస్తుంది:
ఏదైనా కన్వల్యూషన్‌ను తీసివేయడం అనేది నెట్‌వర్క్‌కు ఒత్తిడిని కలిగిస్తుంది, ఇది సాధారణంగా లోపంలో కొంత పెరుగుదలకు దారితీస్తుంది. ఒకవైపు, ఈ లోపం పెరుగుదల అనేది మనం మెలికలు తిరిగిన వాటిని ఎంత సరిగ్గా తొలగిస్తామో సూచించే సూచిక (ఉదాహరణకు, పెద్ద పెరుగుదల మనం ఏదో తప్పు చేస్తున్నామని సూచిస్తుంది). కానీ చిన్న పెరుగుదల చాలా ఆమోదయోగ్యమైనది మరియు చిన్న LRతో తదుపరి కాంతి అదనపు శిక్షణ ద్వారా తరచుగా తొలగించబడుతుంది. అదనపు శిక్షణ దశను జోడించండి:
ఇప్పుడు మనం మన లెర్నింగ్<->ప్రూనింగ్ లూప్‌ను ఎప్పుడు ఆపాలనుకుంటున్నామో గుర్తించాలి. మేము నెట్‌వర్క్‌ని నిర్దిష్ట పరిమాణం మరియు వేగానికి తగ్గించాల్సిన అవసరం వచ్చినప్పుడు ఇక్కడ అన్యదేశ ఎంపికలు ఉండవచ్చు (ఉదాహరణకు, మొబైల్ పరికరాల కోసం). అయినప్పటికీ, లోపం ఆమోదయోగ్యమైన దానికంటే ఎక్కువగా మారే వరకు చక్రం కొనసాగించడం అత్యంత సాధారణ ఎంపిక. షరతును జోడించండి:
కాబట్టి, అల్గోరిథం స్పష్టమవుతుంది. తొలగించబడిన మెలికలు ఎలా నిర్ణయించాలో గుర్తించడానికి ఇది మిగిలి ఉంది.
తొలగించబడిన ప్యాకేజీల కోసం శోధించండి
మేము కొన్ని మెలికలు తీసివేయాలి. ముందుకు పరుగెత్తడం మరియు ఎవరినైనా "షూట్" చేయడం చెడ్డ ఆలోచన, అయినప్పటికీ అది పని చేస్తుంది. కానీ మీకు తల ఉన్నందున, మీరు ఆలోచించవచ్చు మరియు తొలగింపు కోసం "బలహీనమైన" మెలికలు ఎంచుకోవచ్చు. అనేక ఎంపికలు ఉన్నాయి:
- . చిన్న బరువులతో కూడిన మెలికలు తుది నిర్ణయానికి తక్కువ సహకారం అందిస్తాయనే ఆలోచన
- అతిచిన్న L1-కొలత సగటు మరియు ప్రామాణిక విచలనాన్ని పరిగణనలోకి తీసుకుంటుంది. మేము పంపిణీ యొక్క స్వభావాన్ని అంచనా వేయడంతో అనుబంధిస్తాము.
- . అతితక్కువ మెలికల యొక్క మరింత ఖచ్చితమైన నిర్ణయం, కానీ చాలా సమయం తీసుకుంటుంది మరియు వనరు-మిక్కిలి.
- ఇతర
ప్రతి ఎంపికకు జీవించే హక్కు మరియు దాని స్వంత అమలు లక్షణాలు ఉన్నాయి. ఇక్కడ మేము చిన్న L1-కొలతతో ఎంపికను పరిశీలిస్తాము
YOLOv3 కోసం మాన్యువల్ ప్రక్రియ
అసలు ఆర్కిటెక్చర్ అవశేష బ్లాక్‌లను కలిగి ఉంటుంది. అయితే డీప్ నెట్‌వర్క్‌ల కోసం అవి ఎంత కూల్‌గా ఉన్నా, అవి మనకు కొంత అడ్డుగా ఉంటాయి. ఇబ్బంది ఏమిటంటే, మీరు ఈ లేయర్‌లలో విభిన్న సూచికలతో సయోధ్యలను తొలగించలేరు:
కాబట్టి, మనం సయోధ్యలను ఉచితంగా తొలగించగల లేయర్‌లను ఎంచుకుందాం:
ఇప్పుడు పని చక్రాన్ని రూపొందిద్దాం:
- యాక్టివేషన్‌లను అప్‌లోడ్ చేస్తోంది
- ఎంత కట్ చేయాలనేది కనిపెట్టడం
- తొలగించు
- LR=10e-1తో 4 యుగాలు నేర్చుకోవడం
- పరీక్షిస్తోంది
ఒక నిర్దిష్ట దశలో మనం ఎంత భాగాన్ని తొలగించగలమో అంచనా వేయడానికి కన్వల్యూషన్‌లను అన్‌లోడ్ చేయడం ఉపయోగపడుతుంది. అన్‌లోడ్ ఉదాహరణలు:
దాదాపు ప్రతిచోటా 5% మెలికలు చాలా తక్కువ L1-కట్టుబాటును కలిగి ఉన్నాయని మేము చూస్తాము మరియు మేము వాటిని తీసివేయగలము. ప్రతి దశలో, ఈ అన్‌లోడ్ పునరావృతమవుతుంది మరియు ఏ పొరలు మరియు ఎన్ని కత్తిరించబడవచ్చో అంచనా వేయబడింది.
మొత్తం ప్రక్రియ 4 దశల్లో పూర్తయింది (RTX 2060 సూపర్ కోసం ఇక్కడ మరియు ప్రతిచోటా సంఖ్యలు):
| దశ | 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 కొలతలతో కాన్వల్యూషన్‌లను మినహాయించి, తీసివేయబడిన భాగాన్ని పరిమితం చేయడం లక్ష్యం:
అందువల్ల, కుడివైపు ఉన్న పంపిణీల నుండి బలహీనమైన కన్వల్యూషన్‌లను మాత్రమే తీసివేయడానికి మేము మిమ్మల్ని అనుమతిస్తాము మరియు ఎడమవైపు ఉన్న పంపిణీల నుండి తీసివేతను ప్రభావితం చేయకూడదు:
పంపిణీ సాధారణ స్థాయికి చేరుకున్నప్పుడు, కత్తిరింపు_ప్రామాణిక_విచలనం_భాగ గుణకం దీని నుండి ఎంచుకోవచ్చు:
నేను 2 సిగ్మా యొక్క ఊహను సిఫార్సు చేస్తున్నాను. లేదా మీరు <1.0 విలువను వదిలివేసి, ఈ లక్షణాన్ని విస్మరించవచ్చు.
అవుట్‌పుట్ అనేది మొత్తం పరీక్ష కోసం నెట్‌వర్క్ పరిమాణం, నష్టం మరియు నెట్‌వర్క్ రన్‌టైమ్ యొక్క గ్రాఫ్, ఇది 1.0కి సాధారణీకరించబడింది. ఉదాహరణకు, ఇక్కడ నెట్‌వర్క్ పరిమాణం నాణ్యతను కోల్పోకుండా దాదాపు 2 రెట్లు తగ్గించబడింది (100k బరువులు కలిగిన చిన్న కన్వల్యూషనల్ నెట్‌వర్క్):
నడుస్తున్న వేగం సాధారణ హెచ్చుతగ్గులకు లోబడి ఉంటుంది మరియు వాస్తవంగా మారదు. దీనికి వివరణ ఉంది:
- కన్వల్యూషన్‌ల సంఖ్య అనుకూలమైన (32, 64, 128) నుండి వీడియో కార్డ్‌లకు అత్యంత అనుకూలమైనది కాదు - 27, 51, మొదలైనవి. నేను ఇక్కడ తప్పు కావచ్చు, కానీ చాలా మటుకు దాని ప్రభావం ఉంటుంది.
- ఆర్కిటెక్చర్ విస్తృతమైనది కాదు, కానీ స్థిరంగా ఉంటుంది. వెడల్పును తగ్గించడం ద్వారా, మేము లోతును ప్రభావితం చేయము. అందువలన, మేము లోడ్ను తగ్గిస్తాము, కానీ వేగాన్ని మార్చవద్దు.
అందువల్ల, రన్ సమయంలో CUDA లోడ్‌లో 20-30% తగ్గింపులో మెరుగుదల వ్యక్తీకరించబడింది, కానీ రన్ టైమ్‌లో తగ్గింపులో కాదు
ఫలితాలు
ప్రతిబింబిద్దాం. మేము కత్తిరింపు కోసం 2 ఎంపికలను పరిగణించాము - YOLOv3 (మీరు మీ చేతులతో పని చేయాల్సి వచ్చినప్పుడు) మరియు సరళమైన నిర్మాణాలతో కూడిన నెట్‌వర్క్‌ల కోసం. రెండు సందర్భాల్లోనూ కచ్చితత్వం కోల్పోకుండా నెట్‌వర్క్ పరిమాణం తగ్గింపు మరియు వేగాన్ని సాధించడం సాధ్యమవుతుందని చూడవచ్చు. ఫలితాలు:
- పరిమాణాన్ని తగ్గించడం
- త్వరణం రన్
- CUDA లోడ్ను తగ్గించడం
- ఫలితంగా, పర్యావరణ అనుకూలత (కంప్యూటింగ్ వనరుల భవిష్యత్తు వినియోగాన్ని మేము ఆప్టిమైజ్ చేస్తాము. ఎక్కడో ఒకరు సంతోషంగా ఉన్నారు )
అపెండిక్స్
- కత్తిరింపు దశ తర్వాత, మీరు పరిమాణీకరణను జోడించవచ్చు (ఉదాహరణకు, TensorRTతో)
- Tensorflow సామర్థ్యాలను అందిస్తుంది . పనిచేస్తుంది.
- నేను అభివృద్ధి చేయాలనుకుంటున్నాను మరియు సహాయం చేయడానికి సంతోషిస్తాను
మూలం: www.habr.com