Bygga Resnet-34-modell med Pytorch – en guide för nybörjare

Återutgiven av Platon

anhängare: 0

Denna artikel publicerades som en del av Data Science Blogathon

Beskrivning

Djup lärning har utvecklats mycket under de senaste åren och vi är alla glada över att bygga djupare arkitekturnätverk för att få mer precision för våra modeller. Dessa tekniker testas i stor utsträckning för bildrelaterade verk som klassificering, klustering eller syntes. Att gå djupt kan se häftigt ut men det hjälper inte eftersom neurala nätverk står inför ett problem som kallas nedbrytning.

Noggrannheten påverkas i hög grad här. Detta leder också till ett problem som kallas Vanishing gradient descend. Detta tillåter oss inte att korrekt uppdatera vikterna under steget för bakpropagering. Under backpropageringssteget använder vi kedjeregeln, derivaten av varje lager när vi går ner i nätverket multipliceras.

Om vi använder djupare lager och har dolda lager som sigmoid, skalas derivaten ned till 0.25 inom varje lager. Så när många lagerderivat multipliceras minskar gradienten exponentiellt och vi får ett mycket litet värde som är värdelöst för gradientberäkningen. Detta ledde till att Resnet skapades av Microsoft Research som använde överhoppade anslutningar för att undvika försämring. I den här artikeln kommer vi att diskutera en implementering av 34 lager ResNet -arkitektur med hjälp av Pytorch -ramverket i Python.

försvinnande gradientproblem Resnet-34 — Bild 1

Som diskuterats ovan visar detta diagram oss det försvinnande gradientproblemet. Derivaten av sigmoidfunktioner skalas ner till 0.25 och detta förlorar mycket information samtidigt som gradienterna uppdateras.

Problemet med flygnät

Som visas i figuren ser vi plannäten som har djupare lager. Till vänster har vi tågfel och testfel till höger. Vi skulle tro att det här kan vara ett stämningsansökan för övermontering, men här är felprocenten i 56-lagersnätverket mycket värst på både träning och testdata som inte händer när modellen övermonteras. Detta kallas nedbrytning.

Arkitektur av Resnet-34

Inledningsvis har vi ett konvolutionslager som har 64 filter med en kärnstorlek på 7 × 7 detta är första konvolution, sedan följt av ett max-poolande lager. Vi har steget specificerat som 2 i båda fallen. Nästa, i conv2_x vi har poollagret och följande konvolutionslager. Dessa lager är normalt grupperade i par på grund av hur resterna är anslutna (pilarna visar att de hoppar vartannat lager).

Här har vi de två lagren som har en kärna_storlek på 2 × 3, num_filter på 3, och alla dessa upprepas x64, vilket motsvarar lagren mellan poolen,/3 och filtret 2 ett, totalt 128 lager (ett par gånger 6). Dessa 3 lager är kernel_storlek på 2 × 3, num_filters är 3, och dessa upprepas också men vid denna tidpunkt 128. Detta fortsätter tills avg_pooling och softmax -funktionen. Varje gång antalet filter fördubblas kan vi se att det första lagret anger num_filters/2.

Kod för att definiera Resnet-34 i Pytorch:

klass ResNet34 (nn.Module): def __init __ (self): super (ResNet34, self) .__ init __ () self.block1 = nn.Sequential (nn.Conv2d (1,64, kernel_size = 2, stride = 2, padding = 3, bias = False), nn.BatchNorm2d (64), nn.ReLU (True)) self.block2 = nn.Sequential (nn.MaxPool2d (1,1), ResidualBlock (64,64), ResidualBlock (64,64,2) , 3)) self.block64,128 = nn.Sequential (ResidualBlock (128,128,2), ResidualBlock (4)) self.block128,256 = nn.Sequential (ResidualBlock (256,256,2), ResidualBlock (5)) self.block256,512 = nn. Sekventiell (ResidualBlock (512,512,2 2), ResidualBlock (2 1)) self.avgpool = nn.AvgPool512,11d (2) # vokal_diakritisk self.fc512,168 = nn.Linear (3) # grapheme_root self.fc512,7 = nn.Linear (1) # konsonant_diakritisk self.fc2 = nn.Linear (3) def forward (self, x): x = self.block4 (x) x = self.block5 (x) x = self.block0 (x) x = self. block1 (x) x = self.block1 (x) x = self.avgpool (x) x = x.view (x.size (1),-2) x2 = self.fc3 (x) x3 = self.fc1 ( x) x2 = self.fc3 (x) retur xXNUMX, xXNUMX, xXNUMX

Denna kod ger oss fullständig implementering av en modul för Resnet-34. Låt oss nu dyka djupt in i att förstå hur varje rad fungerar. Låt oss förkorta den arkitektur vi såg tidigare. Se de 34 skiktade diagrammen nedan.

Vi kan se att vi måste implementera vilken Resnet -arkitektur som helst i 5 block. Det första blocket har 64 filter med en steg på 2. följt av max-poolning med steg 2. Arkitekturen använder vaddering av 3. Eftersom det finns en chans till internt kovariatskifte måste vi stabilisera nätverket genom batch-normalisering. Vi använder ReLU -aktivering i slutet. Det första blocket är detsamma för vilken arkitektur som helst och resten block ändras för olika lager och upprepas i ett specifikt mönster. 1: a blocket kan implementeras som:

nn.Conv2d(1,64,kernel_size=2,stride=2,padding=3,bias=False),
nn.BatchNorm2d(64),
nn.ReLU(True)

Vid denna tidpunkt har vi en hoppa -anslutning. Vilket är huvudidén med kvarvarande nätverk. Arkitekturdiagrammet vi såg tidigare hade hoppade över anslutningar med prickiga och mörka pilar. Den prickade linjen är vad som händer här när vi går in i en kanal med större storlek än den tidigare. Det andra blocket har implementeringen av en initial maxpool på 1 * 1 med en kärnstorlek på 3 * 3 och två kvarvarande block som visas i koden nedan. Dessa två tar in 64 som in- och utgångskanaler och upprepas 3 gånger som visas i arkitekturen. I slutändan är den sista ansluten till nästa block med en steg på 2.

nn.MaxPool2d (1,1), ResidualBlock (64,64), ResidualBlock (64,64,2)

Det sista blockets innehåll upprepades 3 gånger och vi hade indikerat att med den mörka pilen i arkitekturdiagrammet och in- och utgångskanalstorleken förblir densamma. '/2' som visas i arkitekturdiagrammet berättar om steget som används.

Det tredje blocket tar en kärnstorlek på 3 * 3 med en ingångskanal som kommer från det sista blocket på 64 och ger en utgångskanal på 128. Sedan tar vi samma 128 som ingång och 128 som utgångskanal. Vi upprepar detta 4 gånger som visas i det tidigare arkitekturdiagrammet.

ResidualBlock (64,128), ResidualBlock (128,128,2)

På samma sätt bygger vi våra fjärde och femte block som har 4 och 5 som kärnstorlekar.

ResidualBlock (128,256), ResidualBlock (256,256,2)

ResidualBlock (256,512), ResidualBlock (512,512,2)

De linjära funktionerna hjälper till att ansluta detta slutligen till slutuppdraget som kan innefatta steg som att klassificera cifar 10 -datamängderna etc. och tanken är att platta ut lagren och ge ett sannolikhetsvärde för att hitta max. Och framåtfunktionen som vi definierade för att ansluta vart och ett av blocken. För fullständig pythonimplementering inklusive utbildning kan du hänvisa till detta webbplats. Vi kan också använda Pytorchs överföringsinlärningsteknik och för den koden kan du hänvisa till denna GitHub repa.

Slutsats:

Referens:

https://www.kaggle.com/khoongweihao/resnet-34-pytorch-starter-kit
https://datascience.stackexchange.com/questions/33022/how-to-interpert-resnet50-layer-types

Om mig: Jag är en forskarstudent som är intresserad av djupinlärning och naturligt språkbearbetning och för närvarande fortsätter efter examen i artificiell intelligens.

Image Source

Bild 1,2: https://towardsdatascience.com/the-vanishing-gradient-problem-69bf08b15484
Bild 3,4: https://datascience.stackexchange.com/questions/33022/how-to-interpert-resnet50-layer-types
Förhandsgranskningsbild: https://www.zdnet.com/pictures/10-cool-robots-at-this-years-robobusiness-conference/2/

Anslut mig gärna på: