Costruire il modello Resnet-34 usando Pytorch: una guida per principianti

Ripubblicato da Platone

Seguaci: 0

Questo articolo è stato pubblicato come parte di Blogathon sulla scienza dei dati

Introduzione

Apprendimento approfondito si è evoluto molto negli ultimi anni e siamo tutti entusiasti di costruire reti di architetture più profonde per ottenere una maggiore precisione per i nostri modelli. Queste tecniche sono ampiamente provate per lavori relativi alle immagini come la classificazione, il raggruppamento o la sintesi. Andare in profondità può sembrare interessante, ma non aiuterà poiché le reti neurali affrontano un problema chiamato degrado.

La precisione è influenzata in larga misura qui. Questo porta anche a un problema chiamato gradiente di fuga in discesa. Questo non ci consentirà di aggiornare correttamente i pesi durante la fase di backpropagation. Durante la fase di backpropagating, usiamo la regola della catena, le derivate di ogni strato mentre scendiamo lungo la rete vengono moltiplicate.

Se usiamo livelli più profondi e abbiamo livelli nascosti come il sigmoide, le derivate vengono ridotte al di sotto di 0.25 all'interno di ogni livello. Quindi, quando molte derivate dei livelli vengono moltiplicate, il gradiente diminuisce in modo esponenziale e otteniamo un valore molto piccolo che è inutile per il calcolo del gradiente. Ciò ha portato alla creazione di Resnet da parte di Microsoft Research che utilizzava connessioni saltate per evitare il degrado. In questo articolo, discuteremo un'implementazione dell'architettura ResNet a 34 livelli utilizzando il framework Pytorch in Python.

problema del gradiente evanescente Resnet-34 — 1 Immagine

Come discusso sopra, questo diagramma ci mostra il problema del gradiente evanescente. Le derivate delle funzioni sigmoidee sono ridotte al di sotto di 0.25 e questo perde molte informazioni durante l'aggiornamento dei gradienti.

Il problema con le reti di aerei

problema con le reti semplici — 2 Immagine

Come mostrato nella figura, vediamo le reti di piani, che hanno strati più profondi. A sinistra, abbiamo l'errore del treno e l'errore del test a destra. Penseremmo che questo potrebbe essere un motivo per l'overfitting, ma qui l'errore% della rete a 56 livelli è molto peggiore sia sull'addestramento che sui dati di test, cosa che non si verifica quando il modello è in overfitting. Questo si chiama degrado.

Architettura di Resnet-34

Inizialmente, abbiamo un livello convoluzionale che ha 64 filtri con una dimensione del kernel di 7×7 questo è il prima convoluzione, quindi seguito da un livello di max-pooling. Abbiamo il passo specificato come 2 in entrambi i casi. Successivamente, in conv2_x abbiamo il livello di pooling e i seguenti livelli di convoluzione. Questi strati sono normalmente raggruppati a coppie a causa del modo in cui i residui sono collegati (le frecce mostrano che saltano ogni due strati).

Qui abbiamo i 2 layer dei quali hanno un kernel_sizedi 3×3, num_filters di 64, e tutti questi sono ripetuti x3, che corrisponde ai layer tra il pool,/2 e i filter 128, 6 layer in totale (uno coppia volte 3). Questi 2 livelli sono kernel_size di 3 × 3, num_filters è 128 e anche questi vengono ripetuti ma su questa volta 4. Questo continua fino a avg_pooling e alla funzione softmax. Ogni volta che il numero di filtri raddoppia, possiamo vedere che il primo livello specifica num_filtri/2.

Codice per definire Resnet-34 in Pytorch:

class 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. Sequential( ResidualBlock(512,512,2), ResidualBlock(2) ) self.avgpool = nn.AvgPool2d(1) # vocal_diacritic self.fc512,11 = nn.Linear(2) # grapheme_root self.fc512,168 = nn.Linear(3) # consonant_diacritic self.fc512,7 = nn.Linear(1) def forward(self,x): x = self.block2(x) x = self.block3(x) x = self.block4(x) x = self. block5(x) x = self.block0(x) x = self.avgpool(x) x = x.view(x.size(1),-1) x1 = self.fc2(x) x2 = self.fc3( x) x3 = self.fc1(x) restituisce x2,x3,xXNUMX

Questo codice ci fornisce l'implementazione completa di un modulo per Resnet-34. Ora approfondiamo la comprensione di come funziona ogni linea. Per questo accorciamo l'architettura che abbiamo visto prima. Fare riferimento ai 34 diagrammi a strati di seguito.

Possiamo vedere che abbiamo bisogno di implementare qualsiasi architettura Resnet in 5 blocchi. Il primo blocco ha 64 filtri con stride 2. seguito da max-pooling con stride 2. L'architettura utilizza il padding di 3. Poiché esiste una possibilità di spostamento della covariata interna, dobbiamo stabilizzare la rete mediante la normalizzazione batch. Usiamo l'attivazione ReLU alla fine. Il primo blocco è lo stesso per qualsiasi architettura e gli altri blocchi vengono modificati per diversi livelli e ripetuti secondo uno schema specifico. Il 1° blocco può essere implementato come:

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

A questo punto, abbiamo una connessione skip. Qual è l'idea principale delle reti residue. Il diagramma dell'architettura che abbiamo visto in precedenza aveva le connessioni saltate mostrate con frecce tratteggiate e scure. La linea tratteggiata è ciò che sta accadendo qui mentre ci spostiamo in un canale con più dimensioni rispetto a quello precedente. Il secondo blocco ha l'implementazione di un pool massimo iniziale di 1 * 1 con una dimensione del kernel di 3 * 3 e due blocchi residui come mostrato nel codice seguente. Questi due accettano 64 come canali di input e output e vengono ripetuti 3 volte come mostrato nell'architettura. Alla fine, l'ultimo è collegato al blocco successivo con un passo di 2.

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

Il contenuto dell'ultimo blocco è stato ripetuto 3 volte e avevamo indicato che con la freccia scura nel diagramma dell'architettura e la dimensione del canale di input e output rimane la stessa. Il '/2' mostrato nel diagramma dell'architettura ci parla del passo utilizzato.

Il terzo blocco prende una dimensione del kernel di 3 * 3 con un canale di input proveniente dall'ultimo blocco di 64 e che fornisce un canale di output di 128. Quindi prendiamo lo stesso 128 come canale di input e 128 come canale di output. Lo ripetiamo 4 volte come mostrato nel diagramma dell'architettura precedente.

Blocco Residuo(64,128), Blocco Residuo(128,128,2)

Allo stesso modo, costruiamo il nostro quarto e quinto blocco che hanno 4 e 5 come dimensioni del kernel.

Blocco Residuo(128,256), Blocco Residuo(256,256,2)

Blocco Residuo(256,512), Blocco Residuo(512,512,2)

Le funzioni lineari aiutano a connettere questo alla fine con la missione finale che può includere passaggi come la classificazione dei set di dati cifar 10, ecc. e l'idea è di appiattire i livelli e dare un valore probabilistico per trovare il massimo. E la funzione forward che abbiamo definito per connettere ciascuno dei blocchi. Per l'implementazione completa di Python inclusa la formazione, puoi fare riferimento a questo sito web. Possiamo anche utilizzare la tecnica di apprendimento del trasferimento di Pytorch e per quel codice, puoi fare riferimento a questo GitHub pronti contro termine.

Conclusione:

Riferimento:

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

A proposito di Me: Sono uno studente di ricerca interessato al campo dell'apprendimento profondo e dell'elaborazione del linguaggio naturale e attualmente sto perseguendo un post-laurea in Intelligenza artificiale.

Image Source

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

Sentiti libero di connetterti con me su: