Skip to content

lab2.dev is launched! Build python web apps with plain English, no code required.

Introduction à nn.Linear dans PyTorch : Explication claire

Matt Popovic
Name
Matt Popovic

Updated on

L'apprentissage profond a révolutionné le domaine de l'intelligence artificielle, permettant aux machines de reproduire l'intelligence humaine de manière sans précédent. Au cœur de cette révolution se trouve PyTorch, une bibliothèque populaire d'apprentissage automatique open source qui offre deux fonctionnalités de haut niveau : le calcul de tenseur avec une accélération GPU puissante et des réseaux neuronaux profonds construits sur un système d'autogradation basé sur une bande. L'un des composants fondamentaux de PyTorch est nn.Linear, un module qui applique une transformation linéaire aux données entrantes. Cet article offre un guide complet pour comprendre nn.Linear dans PyTorch, son rôle dans les réseaux neuronaux et comment il se compare à d'autres méthodes de transformation linéaire.

nn.Linear est une couche linéaire utilisée dans les réseaux neuronaux qui applique une transformation linéaire aux données d'entrée à l'aide de poids et de biais. C'est un composant essentiel dans l'architecture de nombreux modèles d'apprentissage profond. Ce guide examinera en détail nn.Linear, y compris sa définition, son fonctionnement et ses applications dans l'apprentissage profond. Nous répondrons également aux questions fréquemment posées et aux requêtes connexes, ce qui permettra de comprendre en profondeur ce module essentiel de PyTorch.

Vous souhaitez créer rapidement une visualisation de données à partir d'un dataframe Python Pandas sans code ?

PyGWalker est une bibliothèque Python pour l'analyse exploratoire de données avec visualisation. PyGWalker (opens in a new tab) peut simplifier votre flux de travail d'analyse de données et de visualisation de données dans Jupyter Notebook, en transformant votre dataframe pandas (et dataframe polars) en une interface utilisateur de style Tableau pour l'exploration visuelle.

PyGWalker pour la visualisation de données (opens in a new tab)

Comprendre nn.Linear dans PyTorch

Qu'est-ce que nn.Linear ?

Dans le contexte des réseaux neuronaux, nn.Linear est un module fourni par PyTorch qui applique une transformation linéaire aux données entrantes. Cette transformation est représentée par la formule y = xA^T + b, où x est l'entrée, A est le poids, b est le biais et y est la sortie.

Le module nn.Linear prend deux paramètres : in_features et out_features, qui représentent respectivement le nombre de caractéristiques d'entrée et de sortie. Lorsqu'un objet nn.Linear est créé, il initialise de manière aléatoire une matrice de poids et un vecteur de biais. La taille de la matrice de poids est out_features x in_features, et la taille du vecteur de biais est out_features.

import torch
from torch import nn
 
## Création d'un objet pour la classe linéaire
linear_layer = nn.Linear(in_features=3, out_features=1)

Dans le snippet ci-dessus, nous créons une instance de nn.Linear avec trois caractéristiques d'entrée et une caractéristique de sortie. Cela donne une matrice de poids 3x1 et un vecteur de biais 1x1.

Comment fonctionne nn.Linear ?

nn.Linear fonctionne en effectuant une multiplication matricielle des données d'entrée avec la matrice de poids et en ajoutant le terme de biais. Cette opération est appliquée à chaque couche dans un réseau neuronal à alimentation directe.

## Passage de l'entrée à la couche linéaire
output = linear_layer(torch.tensor([1,2,3], dtype=torch.float32))
print(output)

Dans le snippet ci-dessus, nous passons un tenseur de taille 3 (correspondant au nombre de caractéristiques d'entrée) à la linear_layer. La sortie est un tenseur de taille 1 (correspondant au nombre de caractéristiques de sortie), qui est le résultat de la transformation linéaire.

Initialisation des poids et des biais

Les poids et les biais dans nn.Linear sont des paramètres que le modèle apprend lors de l'entraînement. Initialement, ils sont fixés à des valeurs aléatoires. Vous pouvez voir les poids et les biais à l'aide des attributs weight et bias.

## Pour voir les poids et les biais
print(linear_layer.weight)
print(linear_layer.bias)

Le bout de code ci-dessus affiche la matrice de poids et le vecteur de biais de la couche nn.Linear.

Bien que PyTorch initialise ces paramètres de manière aléatoire, vous pouvez également les définir manuellement ou utiliser différentes méthodes d'initialisation. Par exemple, vous pouvez utiliser le module torch.nn.init pour appliquer des méthodes d'initialisation spécifiques aux poids et aux biais. Voici un exemple d'utilisation de l'initialisation uniforme de Xavier :

import torch.nn.init as init
 
## Initialiser les poids en utilisant l'initialisation uniforme de Xavier
init.xavier_uniform_(linear_layer.weight)
 
## Initialiser le biais à zéro
init.zeros_(linear_layer.bias)

Dans le bout de code ci-dessus, nous utilisons la fonction xavier_uniform_ de torch.nn.init pour initialiser les poids de notre linear_layer. Le biais est initialisé à zéro en utilisant la fonction zeros_. Ces méthodes d'initialisation peuvent aider à améliorer le processus d'apprentissage du réseau neuronal.

Comparaison de nn.Linear et nn.Conv2d

nn.Linear et nn.Conv2d sont tous deux des modules fondamentaux de PyTorch utilisés à des fins différentes. Alors que nn.Linear applique une transformation linéaire aux données d'entrée, nn.Conv2d applique une convolution 2D à un signal d'entrée composé de plusieurs plans d'entrée.

La principale différence entre nn.Linear et nn.Conv2d réside dans leur application. nn.Linear est généralement utilisé dans les couches entièrement connectées où chaque neurone d'entrée est connecté à chaque neurone de sortie. D'autre part, nn.Conv2d est utilisé dans les couches convolutionnelles, qui sont principalement utilisées dans les réseaux neuronaux convolutionnels (CNN) pour des tâches telles que le traitement d'images.

En termes de leurs paramètres, nn.Linear requiert le nombre de caractéristiques d'entrée et le nombre de caractéristiques de sortie. nn.Conv2d requiert le nombre de canaux d'entrée (ou la profondeur de l'entrée), le nombre de canaux de sortie et la taille du noyau.

Applications de nn.Linear dans l'apprentissage profond

nn.Linear est un module polyvalent dans PyTorch et trouve de nombreuses applications dans l'apprentissage profond. Voici quelques exemples :

  1. Perceptron Multi-Couches (MLP) : Les MLP sont un type de réseau de neurones à propagation avant qui se composent d'au moins trois couches de nœuds : une couche d'entrée, une couche cachée et une couche de sortie. Chaque couche est entièrement connectée à la suivante, et nn.Linear est utilisé pour implémenter ces connexions.

  2. Régression Linéaire : Dans les tâches de régression linéaire, nn.Linear peut être utilisé pour implémenter l'équation linéaire que le modèle apprend.

  3. Transformation des Données : nn.Linear peut être utilisé pour transformer les données d'entrée dans une dimension supérieure pour des tâches plus complexes.

  4. Modèles d'Apprentissage Profond : De nombreux modèles d'apprentissage profond, tels que les autoencodeurs, utilisent nn.Linear dans leur architecture.

Dans le segment suivant, nous examinerons en détail l'utilisation de nn.Linear dans un modèle PyTorch, notamment comment initialiser les poids et les biais, et comment l'utiliser dans un modèle. Nous fournirons également des exemples de ses applications en apprentissage profond.

Utiliser nn.Linear dans un Modèle PyTorch

Intégrer nn.Linear dans un modèle PyTorch consiste à définir la couche dans le constructeur du modèle, puis à l'appliquer aux données d'entrée dans la méthode forward. Voici un exemple d'un simple réseau de neurones à propagation avant qui utilise nn.Linear :

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 2)
 
    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
 
# Créer une instance du réseau
net = Net()

Dans l'exemple de code ci-dessus, nous définissons un réseau Net avec deux couches linéaires (fc1 et fc2). La méthode forward définit la propagation avant de l'entrée à travers le réseau. La fonction F.relu applique la fonction d'activation ReLU à la sortie de la première couche linéaire avant de la passer à la deuxième couche linéaire.

Erreurs Courantes et Solutions pour nn.Linear dans PyTorch

Lors de l'utilisation de nn.Linear, vous pouvez rencontrer certaines erreurs courantes. En voici quelques-unes ainsi que leurs solutions :

  1. Taille d'Entrée Incompatible : La taille d'entrée doit correspondre au paramètre in_features de nn.Linear. Si elles ne correspondent pas, vous obtiendrez une erreur d'exécution. Pour résoudre ce problème, assurez-vous que la taille du tenseur d'entrée correspond au paramètre in_features.

  2. Tailles Incorrectes pour les Poids et les Biais : La matrice des poids et le vecteur des biais doivent avoir des tailles qui correspondent aux paramètres in_features et out_features. Si ce n'est pas le cas, vous obtiendrez une erreur d'exécution. Pour résoudre ce problème, assurez-vous que les tailles de la matrice des poids et du vecteur des biais sont correctes.

  3. Utilisation de nn.Linear avec une Entrée en 3D : nn.Linear attend une entrée en 2D, mais il peut arriver que vous passiez accidentellement une entrée en 3D (par exemple, à partir d'une couche de convolution dans un réseau CNN). Cela entraînera une erreur d'exécution. Pour résoudre ce problème, vous pouvez utiliser torch.flatten ou view pour remodeler l'entrée en 2D.

Conclusion

En conclusion, nn.Linear est un composant fondamental dans PyTorch et l'apprentissage profond. Il joue un rôle crucial dans la mise en œuvre de transformations linéaires dans les réseaux de neurones, et le comprendre peut grandement aider à la construction et au dépannage de modèles d'apprentissage profond. Que vous soyez un débutant qui commence tout juste avec PyTorch ou un praticien expérimenté, maîtriser nn.Linear est une compétence précieuse dans votre boîte à outils d'apprentissage profond.

Questions Fréquemment Posées

Quel est le but d'un vecteur de biais dans nn.Linear ?

Le vecteur de biais dans nn.Linear permet au modèle de décaler la sortie de la transformation linéaire le long de l'axe y. Cela peut être crucial pour ajuster le modèle aux données, notamment lorsque les données ne sont pas centrées autour de l'origine. Sans le biais, le modèle passerait toujours par l'origine, ce qui pourrait limiter sa capacité à s'adapter aux données.

Comment initialiser les poids et les biais d'une couche linéaire dans PyTorch ?

Les poids et les biais d'une couche linéaire dans PyTorch peuvent être initialisés lors de la création d'un objet nn.Linear. Par défaut, ils sont initialisés à des valeurs aléatoires. Cependant, vous pouvez les définir manuellement ou utiliser différentes méthodes d'initialisation fournies par le module torch.nn.init.

Quelle est la différence entre nn.Linear et nn.Conv2d dans PyTorch ?

nn.Linear et nn.Conv2d sont tous deux utilisés pour implémenter des couches dans les réseaux de neurones, mais ils ont des objectifs différents. nn.Linear applique une transformation linéaire aux données d'entrée et est généralement utilisé dans les couches entièrement connectées. D'autre part, nn.Conv2d applique une convolution 2D à un signal d'entrée et est principalement utilisé dans les couches de convolution pour des tâches comme le traitement d'images.