Building Neural Networks with `torch.nn.Module`

1. torch.nn.Module : Le plan de tout modèle PyTorch

En PyTorch, chaque modèle de réseau de neurones, qu'il s'agisse d'une simple couche ou d'un réseau complexe de plusieurs millions de paramètres, est une classe Python. Plus précisément, c'est une classe qui hérite de la classe de base torch.nn.Module.

Pourquoi l'héritage est-il si important ici ? En héritant de nn.Module, notre classe de modèle personnalisée reçoit gratuitement une quantité énorme de fonctionnalités. nn.Module s'occupe de tâches complexes en coulisses, comme le suivi de tous les poids et biais de notre réseau, la mise à zéro de leurs gradients, et bien plus encore. Pensez à nn.Module comme le châssis et le moteur d'une voiture de course : PyTorch nous les fournit, et nous nous concentrons sur la conception de la carrosserie et l'agencement intérieur (nos couches et la manière dont elles sont connectées).

La vidéo suivante explique très bien ce concept fondamental.

2. Les deux méthodes essentielles : __init__ et forward

Pour construire un modèle personnalisé qui hérite de nn.Module, nous devons implémenter deux méthodes spéciales. C'est un patron de conception que vous retrouverez dans absolument tous les modèles PyTorch.

1. __init__(self) (le constructeur) : C'est ici que nous définissons les briques de notre réseau. On y déclare toutes les couches que le réseau utilisera (couches linéaires, couches de convolution, fonctions d'activation, etc.). Cette méthode est exécutée une seule fois, lors de la création de l'objet modèle. C'est l'étape de "planification".

2. forward(self, x) (la passe avant) : C'est ici que nous définissons le flux des données. On y décrit comment une donnée d'entrée x traverse les différentes couches définies dans __init__. C'est le "calcul" ou la "logique" du modèle. Cette méthode est appelée chaque fois que nous passons des données au modèle pour obtenir une prédiction.

Le point le plus important ? Nous n'avons besoin de définir que la passe avant. Grâce au mécanisme d'autograd de PyTorch que nous avons vu précédemment, PyTorch est capable de calculer automatiquement la passe arrière (backward pass) pour la descente de gradient, à partir de la définition de notre forward.

Cette vidéo résume parfaitement ces étapes.

3. Anatomie d'un modèle PyTorch

Voyons comment ces deux méthodes s'articulent dans un exemple concret. L'image ci-dessous décompose un modèle de régression linéaire simple. C'est la forme la plus basique d'un réseau de neurones.

Analysons ce code, car il contient tous les éléments fondamentaux :

• Ligne 2 : class LinearRegressionModel(nn.Module):
  C'est la déclaration de notre classe. Elle hérite de nn.Module, ce qui lui donne accès à toutes les fonctionnalités de PyTorch.

• Ligne 3-4 : def __init__(self): et super().__init__()
  C'est le constructeur. La ligne super().__init__() est obligatoire. Elle appelle le constructeur de la classe parente (nn.Module) pour s'assurer que tout est initialisé correctement en coulisses.

• Lignes 7-15 : self.weights = nn.Parameter(...) et self.bias = nn.Parameter(...)
  Ici, nous définissons les paramètres apprenables du modèle. nn.Parameter est un type de tenseur spécial qui signale à PyTorch que ces valeurs doivent être optimisées pendant l'entraînement. L'argument requires_grad=True active le calcul automatique du gradient pour ces paramètres.

  Note : Pour des couches plus complexes comme nn.Linear, PyTorch crée ces paramètres pour nous. Mais il est utile de voir comment cela se fait manuellement au moins une fois.

• Ligne 18 : def forward(self, x: torch.Tensor) -> torch.Tensor:
  C'est la définition de la passe avant. Elle prend une entrée x (un tenseur) et doit retourner une sortie (un autre tenseur).

• Ligne 19 : return self.weights * x + self.bias
  C'est le calcul effectif. On applique la formule de la régression linéaire, $y=\text{weights}\cdot x+\text{bias}$, en utilisant les paramètres que nous avons définis dans __init__.

4. Construire un réseau de neurones multicouches

Maintenant, généralisons cette structure pour construire un réseau de neurones plus standard, avec des couches cachées. Au lieu de définir les poids et les biais manuellement, nous utiliserons la couche nn.Linear de PyTorch, qui encapsule cette logique pour nous.

L'article suivant, en français, est une excellente ressource qui montre exactement comment faire cela.

Comme vous l'avez vu dans l'article, le processus est très similaire :

1. Dans __init__, nous initialisons les couches dont nous avons besoin. Par exemple :

   self.fc1 = nn.Linear(input_size, hidden_size)  # fc = fully connected
   self.relu = nn.ReLU()
   self.fc2 = nn.Linear(hidden_size, output_size)
   

2. Dans forward, nous les enchaînons pour définir le calcul :

   x = self.fc1(x)
   x = self.relu(x)
   x = self.fc2(x)
   return x
   

La vidéo suivante détaille un processus presque identique, en utilisant nn.Sequential pour regrouper les couches, ce qui est une autre technique courante.

5. Utiliser le modèle

Une fois notre classe de modèle définie, l'utiliser est très simple :

1. Instanciation : On crée un objet à partir de notre classe.

   
   
   
   # Les tailles sont des exemples
   model = SimpleNet(input_size=784, hidden_size=128, output_size=10) 
   

2. Inspection : On peut l'imprimer pour vérifier son architecture.

   print(model)
   

   PyTorch nous donnera une belle représentation de toutes les couches que nous avons définies.

3. Prédiction : On lui passe un tenseur d'entrée. Cela appelle automatiquement la méthode forward.

   input_tensor = torch.randn(64, 784) # Un batch de 64 exemples
   logits = model(input_tensor) # Appelle model.forward(input_tensor)
   print(logits.shape)
   

Conclusion

Aujourd'hui, nous avons franchi une étape décisive. Nous avons appris à structurer un réseau de neurones complet dans PyTorch en utilisant son outil le plus fondamental : la classe nn.Module.

Points clés à retenir :

• Tout modèle PyTorch est une classe Python qui hérite de torch.nn.Module.
• Cette classe doit implémenter deux méthodes essentielles :
  • __init__(self) : pour définir les couches du réseau (les briques). N'oubliez pas l'appel super().__init__().
  • forward(self, x) : pour décrire le flux des données à travers ces couches (le calcul).
• PyTorch gère automatiquement la passe arrière (backward pass) pour l'entraînement, grâce à autograd.
• Une fois la classe définie, on crée une instance du modèle, que l'on peut ensuite utiliser pour faire des prédictions.

Maintenant que nous savons comment construire l'architecture d'un modèle, la question suivante est : comment l'entraîner ? Dans la prochaine leçon, nous entamerons un nouveau module sur l'entraînement des réseaux de neurones. Nous commencerons par la toute première étape : préparer nos données pour l'entraînement à l'aide des classes TensorDataset et DataLoader de PyTorch.