PyTorch - Réseau neuronal convolutif

L'apprentissage en profondeur est une division de l'apprentissage automatique et est considéré comme une étape cruciale franchie par les chercheurs au cours des dernières décennies. Les exemples de mise en œuvre de l'apprentissage en profondeur incluent des applications telles que la reconnaissance d'image et la reconnaissance vocale.

Les deux types importants de réseaux de neurones profonds sont donnés ci-dessous -

Réseaux de neurones convolutifs
Réseaux de neurones récurrents.

Dans ce chapitre, nous nous concentrerons sur le premier type, à savoir les réseaux de neurones convolutionnels (CNN).

Réseaux de neurones convolutifs

Les réseaux de neurones convolutifs sont conçus pour traiter les données à travers plusieurs couches de tableaux. Ce type de réseaux neuronaux est utilisé dans des applications telles que la reconnaissance d'image ou la reconnaissance faciale.

La principale différence entre CNN et tout autre réseau de neurones ordinaire est que CNN prend les entrées sous forme de tableau bidimensionnel et opère directement sur les images plutôt que de se concentrer sur l'extraction de caractéristiques sur laquelle se concentrent d'autres réseaux de neurones.

L'approche dominante de CNN inclut la solution aux problèmes de reconnaissance. Des entreprises de premier plan comme Google et Facebook ont investi dans des projets de recherche et de développement de projets de reconnaissance pour mener à bien leurs activités plus rapidement.

Chaque réseau neuronal convolutif comprend trois idées de base -

Champs respectifs locaux
Convolution
Pooling

Comprenons chacune de ces terminologies en détail.

Champs respectifs locaux

CNN utilise des corrélations spatiales qui existent dans les données d'entrée. Chacun dans les couches concurrentes des réseaux de neurones se connecte à certains neurones d'entrée. Cette région spécifique est appelée champ réceptif local. Il se concentre uniquement sur les neurones cachés. Le neurone caché traitera les données d'entrée à l'intérieur du champ mentionné sans réaliser les changements en dehors de la limite spécifique.

La représentation schématique de la génération des champs respectifs locaux est mentionnée ci-dessous -

Convolution

Dans la figure ci-dessus, nous observons que chaque connexion apprend un poids de neurone caché avec une connexion associée avec le mouvement d'une couche à l'autre. Ici, les neurones individuels effectuent un changement de temps en temps. Ce processus est appelé «convolution».

Le mappage des connexions de la couche d'entrée à la carte d'entités cachées est défini comme des «poids partagés» et le biais inclus est appelé «biais partagé».

mise en commun

Les réseaux de neurones convolutifs utilisent des couches de regroupement qui sont positionnées immédiatement après la déclaration CNN. Il prend les entrées de l'utilisateur comme une carte des caractéristiques qui sort des réseaux convolutifs et prépare une carte des caractéristiques condensée. La mise en commun des couches aide à créer des couches avec des neurones des couches précédentes.

Implémentation de PyTorch

Les étapes suivantes sont utilisées pour créer un réseau neuronal convolutif à l'aide de PyTorch.

Étape 1

Importez les packages nécessaires pour créer un réseau de neurones simple.

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

Étape 2

Créez une classe avec une représentation par lots du réseau neuronal convolutif. Notre forme de lot pour l'entrée x est de dimension (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)

Étape 3

Calculez l'activation du premier changement de taille de convolution de (3, 32, 32) à (18, 32, 32).

La taille de la dimension passe de (18, 32, 32) à (18, 16, 16). Remodeler la dimension des données de la couche d'entrée du réseau neuronal en raison de laquelle la taille passe de (18, 16, 16) à (1, 4608).

Rappelons que -1 déduit cette dimension de l'autre dimension donnée.

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)