DNN Model Optimization Series Deel I: Wat is de oefening?

Waarom moet u uw DNN-model optimaliseren?

Bij Deeplite geloven we dat AI (Kunstmatige Intelligentie) is hier om de manier waarop we omgaan met dingen die we gebruiken om een ​​beter leven te creëren, te verbeteren. Van een drone die het terrein inspecteert of een camera op zoek naar defecten in het fabricagemateriaal tot je telefoon die je identiteit verifieert, deep learning stelt ons in staat om ingewikkelde patronen uit grote hoeveelheden gegevens te herkennen en te interpreteren.

Naarmate geavanceerde technische industrieën groeien en zich ontwikkelen, hebben ze steeds complexere AI en op deep learning gebaseerde oplossingen nodig voor hun dagelijkse toepassingen. De huidige oplossingen in robotica, medische apparatuur, IoT-apparaten, autonome voertuigen of slimme productie vereisen uitgebreidere en nauwkeurigere DNN-modellen (Deep Neural Networks) met aanzienlijk meer lagen en parameters dan ooit tevoren.

De onderstaande tabel is samengesteld door Deeplite om het probleem te illustreren. in de evolutie van DNN-architecturen in het afgelopen decennium en hun consistente groei in diepte en omvang. Hier kunt u heel goed zien hoe de verbetering van de modelnauwkeurigheid correleert met de toename van de geheugengrootte (MB), de rekenkosten (Giga MAC's), het aantal parameters (miljoen) en de inferentietijd (voor batchgrootte 128) .

De belangrijkste reden voor de explosie in deze complexiteit is de noodzaak van het succes van een DNN-model, gemeten aan de hand van de correctheid, nauwkeurigheid, foutenpercentage, F1-score en een gebied onder de curve (AUC). In autonome auto's kan een ML-storing bijvoorbeeld gevaarlijk of zelfs levensbedreigend zijn. Daarom kan een diepere DNN-architectuur concurrerende resultaten opleveren op benchmark-datasets voor alle applicaties, terwijl het consumeren van deze uitgebreide state-of-art DNN-modellen in meerdere productieklare real-time systemen een uitdaging is vanwege de geheugenbeperkingen in het apparaat en de inferentietijd knelpunten.

Laten we bijvoorbeeld eens kijken hoe duur een enkele convolutielaag kan zijn… (Normaal gesproken bevatten de leerbare parameters van een DNN-model gewichten en vooroordelen. Maar laten we een korte oefening doen en voorlopig alleen de gewichtsparameters bekijken).

Stel je een convolutielaag voor met 512 korrels, elk met (3 x 3) gewichtswaarden. De invoervorm van deze laag (128 x 224 x 224 x 256) geeft de uitvoervorm (128 x 224 x 224 x 512), uitgaande van een opvulling en stap van 1. Zo'n convolutielaag heeft (3 x 3 x 256 x 512 ) verschillende gewichtswaarden om te leren. Elke gewichtswaarde wordt weergegeven als een float32-gegevenstype, dat 4 bytes geheugen (32 bits) in beslag neemt. Het geheugen dat nodig is om deze gewichtsparameters op te slaan is dus (3 x 3 x 256 x 512 x 4) bytes = 4,5 MB.

Bovendien produceert deze laag een vormuitvoer (128 x 224 x 224 x 512) en het geheugen dat nodig is om deze uitvoer van de laag op te slaan is (128 x 224 x 224 x 512 x 4) bytes = 12,25 GB. Tijdens training en backpropagation zou deze laag een vormverloop (128 x 224 x 224 x 512) moeten berekenen, wat een extra geheugen van (128 x 224 x 224 x 512 x 4) bytes = 12,25 GB vereist. Door de toevoeging van één standaard convolutielaag is het extra geheugen dat nodig is dus:

• om de gewichtsparameters op de schijf op te slaan: 4,5 MB
• het RAM-geheugen dat nodig is om door te sturen en de uitvoer af te leiden: 12,25 GB
• de RAM die nodig is om het model terug te verspreiden en te trainen: 12.25GB

Zoals te zien is in het bovenstaande voorbeeld, kunnen succesvolle DNN-architecturen erg groot en rekenkundig kostbaar worden. De geheugen-, tijd-, hardware- en energiebeperkingen voorkomen dat deep learning doordringt tot meerdere industriële toepassingen en deze verbetert. Er is een directe behoefte aan het optimaliseren en comprimeren van deze DNN-architecturen om ze te kunnen consumeren. Bij Deeplite omarmen we het belang van DNN-modeloptimalisatie om AI-toepassingen mogelijk te maken, zelfs met zeer beperkte middelen, en het nuttig te maken voor ons dagelijks leven. Daarom hebben we besloten onze kennis te delen in deze meerdelige blogserie over DNN-optimalisatie en te laten zien hoe we de uitdagingen van het produceren van een gebruiksvriendelijk DNN-modeloptimalisatieraamwerk aangaan.

Ga klein om groot te worden

Optimalisatie is een vrij ruim begrip en kan veel betekenen dingen. Laten we dus eens kijken naar wat DNN-architectuuroptimalisatie eigenlijk inhoudt.

Fundamenteel gaat DNN-architectuuroptimalisatie over het verminderen van het aantal parameters in uw model. Minder parameters vereisen minder geheugenruimte, wat resulteert in een kleiner aantal berekeningen en een betere inferentietijd. Er zijn meerdere methoden onderzocht in de literatuur die het aantal parameters verminderen. Deze technieken, zoals weergegeven in de volgende afbeelding, kunnen grofweg worden onderverdeeld in vier categorieën: 1) het verwijderen van parameters, 2) het zoeken naar parameters, 3) het ontleden van parameters en 4) het kwantificeren van parameters.

Let op, deze indeling benadrukt de belangrijkste technieken voor optimalisatie en is niet uitputtend.

Laten we het hebben over elk van deze DNN-optimalisatietechnieken, hoe verschillen ze van elkaar, hun voor- en nadelen, en of er een is die beter bij uw situatie past.

Bestaande oplossingen voor optimalisatie van DNN-architectuur

1. Parameter verwijderen

Heb je ooit gehoord van de uitdrukking 'DNN-model is overgeparametriseerd met overbodige gewichten'? Dit betekent in feite dat als een DNN-model een ontelbaar aantal gewichtsparameters heeft, deze niet allemaal zullen bijdragen aan het verkrijgen van de gewenste output. Ze zijn dus nutteloos en kunnen uit het model worden geëlimineerd.
Het primaire doel van de parameterverwijderingstechniek is om die 'nutteloze' gewichten te identificeren die niet bijdragen aan de output en ze te elimineren om een ​​kleiner model te bereiken. Dit kan worden bereikt door de gewichten te snoeien of het hele model te distilleren. Deze techniek brengt uitdagingen met zich mee zoals:

• Tijd en rekenbronnen toewijzen. Om de geschiktheid van elk nieuw kandidaat-gedistilleerd model te meten, moeten ze uitputtend worden getraind met behulp van de b.v. de opleidingsgegevens van de leraar. Dit proces kan lang en arbeidsintensief zijn.
• Identificatie van de onbelangrijke parameters die kunnen worden verwijderd.
• Identificatie van de limieten . Hoe ver kunnen we gaan met de verwijdering zonder de nauwkeurigheid of prestaties onder de gewenste drempel te laten vallen?

2. Parameter zoeken

DNN-modeloptimalisatie kan ook worden gezien als een zoektaak. Laten we zeggen dat we een set van alle mogelijke verschillende DNN-modellen hebben, en we zoeken naar het model met minder parameters dan het originele model, maar met vergelijkbare nauwkeurigheidsprestaties. In dit geval wordt het oorspronkelijke model de leraar genoemd en het nieuwe model waarnaar we zoeken de leerling.

Het leerlingmodel leert van de gewichten van de leraar. Vervolgens distilleren we ofwel het leerlingmodel uit het leraarsmodel, ofwel doorzoeken we de architectuur van het leerlingmodel helemaal opnieuw. Bijvoorbeeld, Lottery Ticket Hypothesis is een populaire nieuwe techniek voor modeloptimalisatie als zoekprobleem !

Afhankelijk van het aantal hyperparameters dat wordt overwogen, kan de zoekruimte belachelijk groot worden. Het nadeel van deze techniek is dus dat het zoeken en vinden van een geschikt studentenmodel tijdrovend en arbeidsintensief kan zijn. Bovendien is de nauwkeurigheid van het nieuwe leerlingmodel in de steekproef onbekend totdat er voldoende fijnafstemming is uitgevoerd op de trainingsgegevens van de leraar. Deze extra overhead van meer trainings- en afstemmingsstappen draagt ​​bij aan de uitdaging van de benodigde tijd en middelen. In de praktijk zijn onbeperkte, realtime systemen die zoeken naar het juiste leerlingmodel mogelijk niet efficiënt.

3. Parameter Ontleding

Hier is hoe ontleding werkt. We fragmenteren een enorme gewichtsmatrix (of tensor) in kleinere stukjes, zodat er zo min mogelijk informatieverlies is, zo min mogelijk informatieverlies.

Stel je een volledig verbonden neuraal netwerk voor met verborgen lagen van (100, 200) neuronen elk. De gewichtsmatrix die deze twee lagen verbindt, zou de vorm hebben van 100 200 = 20000 gewichtsparameters. Maar wat als we elke laag in dit netwerk ontleden in een reeks kleinere lagen met elk (100, 2, 2, 200) neuronen? In dit geval zou de gewichtsmatrix die deze sets lagen verbindt de vorm (100 x 2) + (2 x 2) + (2 x 200) = 604 gewichtsparameters hebben, wat resulteert in ~97% compressie.

Het nadeel van de gewichtsdecompositietechniek is de moeilijkheid om de juiste decompositierang voor een gegeven tensor van het gewicht te vinden, waardoor we zoveel mogelijk informatie kunnen behouden terwijl we toch kleinere matrixwaarden berekenen.

4. Parameterkwantisatie

Laten we omwille van het experiment aannemen dat ons DNN-model niet overgeparametriseerd is en dat elke afzonderlijke gewichtswaarde erin belangrijk is. Gezien het feit dat elke gewichtswaarde 4 bytes geheugen nodig heeft met een precisie van float32. Het idee achter kwantisering is om het geheugen dat nodig is voor elke gewichtswaarde te verminderen. Door de precisie van alle gewichtswaarden om te zetten naar Int16, wordt de grootte van het model teruggebracht tot 50%. Het logisch wijzigen van de precisie van gewichtswaarden naar Int8, 4bits, 2bits of zelfs binair (1 bit) zal de modelgrootte verder verkleinen.

In plaats van kwantisering kunnen we ook gewichtswaarden binning uitvoeren, waarbij de oorspronkelijke precisie van gewichtswaarden behouden blijft. Laten we aannemen dat een convolutielaag een gewichtstensor van vorm (3 x 3 x 256 x 512) heeft en alle 1179648 unieke en verschillende float32-waarden kan bevatten. Het idee achter binning is om het aantal mogelijke unieke waarden in de gewichtstensor te verminderen. Daarom kunnen we in plaats van 1179648 unieke waarden het aantal unieke waarden terugbrengen tot 4, waardoor we slechts 2 bits nodig hebben om alle vereiste gewichtswaarden op te slaan.

Het belangrijkste nadeel van de kwantiserings- en binningtechniek is dat deze gewoonlijk leidt tot veel informatieverlies. Hoe agressiever de kwantisering is, hoe minder hoop we hebben op het behouden van de juiste informatie. Een 2-bits kwantisering kan bijvoorbeeld slechts vier unieke gewichtswaarden opslaan.

Valkuilen van DNN-modeloptimalisatie

Hoewel elke optimalisatietechniek zijn voordelen, uitdagingen en nadelen heeft, heeft Deeplite besloten om u een overzicht te geven van de valkuilen waar u op moet letten bij het uitvoeren van uw optimalisatie in een productie-opstelling.

Behoud van de juistheid

Behoud van de juistheid

Hoe verminderen we het aantal parameters, maar behouden we een gelijkwaardige nauwkeurigheidsprestatie? Het behouden van de prestaties omvat meer dan één mogelijke verliesfunctie, inclusief aangepaste manieren om netwerken te evalueren. Een geoptimaliseerd model is alleen nuttig als de functionele nauwkeurigheid behouden blijft op de relevante criteria (cross-entropie, SME, gemiddelde gemiddelde precisie (mAP), F1-score, IoU enz.)

Multiple Metrics

Er zijn meerdere meetwaarden om te optimaliseren: het aantal parameters, de modelgrootte, de inferentietijd, de rekenkosten in termen van MAC's enz. Het optimaliseren van zelfs een van die meetwaarden is een uitdaging, dus pas op wanneer u ze samen probeert te optimaliseren.

Begeleide optimalisatie

Verschillende toepassingen kunnen vereisen dat een of enkele van deze meetwaarden zeer geoptimaliseerd zijn, terwijl andere over het hoofd worden gezien of zelfs worden genegeerd.

Real-time systemen zouden bijvoorbeeld vereisen dat de inferentietijd laag is, maar zouden niet veel verwachten kleinere modelgrootte. Zorg ervoor dat u uw modeloptimalisatie begeleidt om deze specifieke statistieken te bevoordelen, afhankelijk van het doel van uw DNN-model.

Aangepaste bewerkingen

De generieke implementatie van Conv2D-bewerking in populaire bibliotheken zoals PyTorch, Tensorflow, Keras of Caffe2 ondersteunt geen specifieke snoei- en kwantiseringsmethoden.

Hoe implementeren we aangepaste convolutiebewerking met vergelijkbare efficiëntie? Er bestaan ​​verschillende implementaties van convolutiebewerkingen tussen frameworks en aangepaste bewerkingen worden niet altijd ondersteund of zijn niet altijd gemakkelijk te optimaliseren met behulp van handgemaakte technieken, met name over meerdere netwerken. Een van de moeilijkheden bij optimalisatie is het ondersteunen en implementeren van verschillende bewerkingen terwijl de prestaties van het model worden verbeterd.

Hardware-ondersteuning

De compiler en de hardware-uitvoering van het geoptimaliseerde model kunnen een uitdaging zijn. De meeste optimalisatietechnieken zijn gericht op GPU- of serverklasse CPU-uitvoering. Kunnen we DNN-architecturen optimaliseren voor verschillende en gespecialiseerde hardware zoals Android, Arduino en verschillende ASIC's die nu de strijd aangaan. Bovendien, hoe kunnen we optimale netwerkarchitecturen leren die inzicht geven in mogelijke hardware-optimalisaties die de prestaties maximaliseren.

Black-box Framework

Gezien de complexiteit van het optimaliseren van DNN-modellen en de mogelijkheid die wordt geboden wanneer DNN's met succes worden geoptimaliseerd, is er grote behoefte aan een black-box-optimalisatieraamwerk, waarbij de eindgebruiker alleen het getrainde model, de trainingsdataset en een gemakkelijke manier kan leveren om beperkingen op te leggen voor optimalisatie. De ervaring en bruikbaarheid van de eindgebruiker is een cruciale vereiste bij het optimaliseren van de productiepijplijnen.

Je zou kunnen stellen dat er tal van onderzoekspapers en blogs zijn, en technische artikelen die tot doel hebben veel van de bovengenoemde uitdagingen aan te pakken en op te lossen. Afgezien van de bovenstaande technische uitdagingen, verhinderen enkele niet-technische problemen dat DNN-optimalisaties doordringen in wijdverbreide toepassingen:

• De doelstellingen van de onderzoekspapers verschillen van die van commerciële toepassingen.
  Gewoonlijk zijn onderzoekspapers gericht op het vinden van één goed geoptimaliseerd model dat de maximale nauwkeurigheidsprestaties van het leraarsmodel behoudt. Toch zijn de kosten en tijd die gemoeid zijn met het zoeken naar dat geoptimaliseerde model vaak geen probleem. In productiesystemen zijn de kosten voor het vinden van het geoptimaliseerde model net zo belangrijk als de nauwkeurigheidsprestaties van het geoptimaliseerde model.
• Openbare resultaten zijn gericht op het benchmarken van de gegevens en het model.
  De resultaten die in het publieke domein en in technische artikelen worden gevonden, zijn vaak de optimalisatieresultaten die zijn verkregen op gangbare DNN-architecturen ten opzichte van benchmarkgegevenssets. Tot op zekere hoogte zijn de optimalisatietechnieken overgepast voor deze architectuurstijlen en dataset-eigenschappen. Er is echter behoefte aan het optimaliseren van elke stijl van DNN-architectuur op elke soort vision-dataset in een productieomgeving. Dus niet alle gepubliceerde technieken in de literatuur passen bij de productiebehoeften.

Hoe kan Deeplite helpen?

Om de kansen die worden gecreëerd door geoptimaliseerde DNN-modellen te maximaliseren, kunnen ingenieurs in meerdere markten en toepassingsdomeinen, evenals onderzoekers, nu automatisch hun modellen optimaliseren met behulp van de optimalisatiesoftware van Deeplite. Deeplite implementeert een complete black-box, een zeer gebruiksvriendelijk en geïntegreerd framework voor DNN-modeloptimalisatie. Het enige wat u hoeft te doen is het vooraf getrainde model te voorzien van de trainings- en testgegevens met behulp van het lokale pip-pakket of de gedockte engine.

Vervolgens geeft u eventuele beperkingen of richtlijnen op voor het optimaliseren van het model, zoals de maximale tolerantie in nauwkeurigheidsvermindering of foutenpercentage die in uw geval is toegestaan ​​en het gewenste compressieniveau. Deeplite gebruikt een gepatenteerde optimalisatie-engine genaamd Neutrino™ om de complexiteit van het model te begrijpen en voer de meest geschikte optimalisatie uit, met minimale inspanning van de eindgebruiker.

U kunt ook kiezen tussen verschillende optimalisatieniveaus, zoals niveau 1, niveau 2 en niveau 3. Elk dieper niveau biedt agressievere optimalisatie ten koste van extra tijd bij het verkrijgen van het geoptimaliseerde model.

Hier leest u hoe het ziet er in actie uit.

Zoals te zien is in de demo, hoeft u met Deeplite niet te worstelen met het implementeren van complexe snoeitechnieken of aangepaste bewerkingen bovenop de DNN-architecturen. Al het zware werk wordt verwijderd door de gebruiksvriendelijke optimalisatie-engine van Deeplite. Is Deeplite de juiste oplossing voor uw DNN-projecten? Vraag hier een demo aan.

Deeplite's Neutrino™-engine is beschikbaar op locatie, via een Python pip-distributie. Het is programmeerbaar en zeer integreerbaar in bestaande workflows en ontwikkelingslevenscycli. Deeplite streeft er ook naar een bibliotheek-agnostische interface te bieden voor modeloptimalisatie, ondersteuning van PyTorch- en Tensorflow-modellen.

Onze engine gebruikt een combinatie van verschillende technieken voor gewichtsvermindering samen met een geavanceerde zoekopdracht, om het meest geoptimaliseerde model te vinden met zo min mogelijk zoekkosten.

Dat was het voor nu! We hopen dat je ons artikel met plezier hebt gelezen! We zullen zeker meer berichten publiceren over uitdagingen in DNN-modeloptimalisatie. Meld u aan voor de blognieuwsbrief van Deeplite als u op de hoogte wilt blijven.

Ontmoet de blogauteurs:

Anush Sankaran
Senior Research Scientist, Deeplite

Anastasia Hamel
Digital Marketing Manager, Deeplite

0

Tags: Algorithms Deeplite Software Tools