PyTorch - Rete neurale convoluzionale

Il deep learning è una divisione dell'apprendimento automatico ed è considerato un passo cruciale compiuto dai ricercatori negli ultimi decenni. Gli esempi di implementazione del deep learning includono applicazioni come il riconoscimento delle immagini e il riconoscimento vocale.

Di seguito sono riportati i due importanti tipi di reti neurali profonde:

• Reti neurali convoluzionali
• Reti neurali ricorrenti.

In questo capitolo, ci concentreremo sul primo tipo, vale a dire, Convolutional Neural Networks (CNN).

Reti neurali convoluzionali

Le reti neurali convoluzionali sono progettate per elaborare i dati attraverso più livelli di array. Questo tipo di reti neurali vengono utilizzate in applicazioni come il riconoscimento delle immagini o il riconoscimento facciale.

La differenza principale tra la CNN e qualsiasi altra rete neurale ordinaria è che la CNN prende l'input come un array bidimensionale e opera direttamente sulle immagini piuttosto che concentrarsi sull'estrazione di caratteristiche su cui si concentrano altre reti neurali.

L'approccio dominante della CNN include la soluzione per i problemi di riconoscimento. Le migliori aziende come Google e Facebook hanno investito in progetti di ricerca e sviluppo di progetti di riconoscimento per svolgere le attività con maggiore velocità.

Ogni rete neurale convoluzionale include tre idee di base:

• Campi rispettivi locali
• Convolution
• Pooling

Cerchiamo di comprendere ciascuna di queste terminologie in dettaglio.

Campi rispettivi locali

La CNN utilizza le correlazioni spaziali che esistono all'interno dei dati di input. Ciascuno negli strati simultanei delle reti neurali connette alcuni neuroni di input. Questa regione specifica è chiamata campo ricettivo locale. Si concentra solo sui neuroni nascosti. Il neurone nascosto elaborerà i dati di input all'interno del campo menzionato non rendendosi conto dei cambiamenti al di fuori del confine specifico.

La rappresentazione del diagramma della generazione dei rispettivi campi locali è menzionata di seguito:

Convoluzione

Nella figura sopra, osserviamo che ogni connessione apprende un peso di neurone nascosto con una connessione associata con il movimento da uno strato all'altro. Qui, i singoli neuroni eseguono un cambiamento di volta in volta. Questo processo è chiamato "convoluzione".

La mappatura delle connessioni dal livello di input alla mappa degli elementi nascosti è definita come "pesi condivisi" e il bias incluso è chiamato "bias condiviso".

Pooling

Le reti neurali convoluzionali utilizzano livelli di pooling che vengono posizionati immediatamente dopo la dichiarazione della CNN. Prende l'input dell'utente come una mappa di caratteristiche che esce da reti convoluzionali e prepara una mappa di caratteristiche condensata. Il raggruppamento dei livelli aiuta a creare livelli con i neuroni dei livelli precedenti.

Implementazione di PyTorch

I passaggi seguenti vengono utilizzati per creare una rete neurale convoluzionale utilizzando PyTorch.

Passo 1

Importa i pacchetti necessari per creare una semplice rete neurale.

from torch.autograd import Variable
import torch.nn.functional as F

Passo 2

Crea una classe con la rappresentazione in batch della rete neurale convoluzionale. La nostra forma batch per l'input x è con dimensione (3, 32, 32).

class SimpleCNN(torch.nn.Module):
   def __init__(self):
      super(SimpleCNN, self).__init__()
      #Input channels = 3, output channels = 18
      self.conv1 = torch.nn.Conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.MaxPool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.Linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.Linear(64, 10)

Passaggio 3

Calcola l'attivazione delle prime modifiche alla dimensione della convoluzione da (3, 32, 32) a (18, 32, 32).

La dimensione della dimensione cambia da (18, 32, 32) a (18, 16, 16). Rimodellare la dimensione dei dati del livello di input della rete neurale a causa della quale la dimensione cambia da (18, 16, 16) a (1, 4608).

Ricorda che -1 deduce questa dimensione dall'altra dimensione data.

def forward(self, x):
   x = F.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = F.relu(self.fc1(x))
   #Computes the second fully connected layer (activation applied later)
   #Size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)