Introduction : nn.Linear dans PyTorch, clairement expliqué

Name

Matt Popovic

Updated on 14/11/2025

nn.Linear est l’un des blocs de base les plus importants dans PyTorch.
Que vous construisiez un simple Multi-Layer Perceptron (MLP), un Transformer, ou un système de deep learning à grande échelle, les couches linéaires sont partout — elles réalisent des transformations affines rapides sur vos données.

Avec PyTorch 2.x, les couches linéaires bénéficient désormais de kernels mis à jour, d’optimisations du compilateur (torch.compile) et d’une meilleure accélération GPU. Ce guide mis à jour couvre tout ce que vous devez savoir, des bases jusqu’aux usages modernes en deep learning.

Vous voulez créer rapidement de la Data Visualization à partir d’un DataFrame pandas en no code ?

PyGWalker est une bibliothèque Python pour l’Exploratory Data Analysis avec Visualisation.
Elle transforme votre DataFrame pandas ou polars en une interface façon Tableau dans Jupyter Notebook.

👉 PyGWalker on GitHub (opens in a new tab)

(opens in a new tab)

Comprendre nn.Linear dans PyTorch

Qu’est-ce que nn.Linear ?

nn.Linear applique une transformation affine aux données d’entrée :

[ y = xA^T + b ]

• x : tenseur d’entrée
• A : matrice de poids (out_features × in_features)
• b : vecteur de biais (out_features)
• y : tenseur de sortie

Le module prend deux arguments obligatoires :

nn.Linear(in_features, out_features, bias=True)

Exemple :

import torch
from torch import nn
 
linear_layer = nn.Linear(in_features=3, out_features=1)

Cela crée :

• forme des poids : 1 × 3
• forme du biais : 1

Comment fonctionne nn.Linear ?

Un passage avant (forward pass) réalise :

• une multiplication matricielle avec les poids
• une addition du biais (si activé)

output = linear_layer(torch.tensor([1., 2., 3.]))
print(output)

📌 Utilisation moderne : entrées batchées

PyTorch applique nn.Linear à la dernière dimension.
Il fonctionne donc directement avec :

Entrées 2D (batch, features)

[batch, in_features]

Entrées 3D (batch, seq_len, features)

Courant dans les Transformers :

[batch, seq_len, in_features] → [batch, seq_len, out_features]

Exemple :

x = torch.randn(32, 128, 512)   # batch=32, seq_len=128, hidden=512
linear = nn.Linear(512, 1024)
y = linear(x)                   # output: [32, 128, 1024]

Aucun reshape n’est nécessaire — c’est important pour les projections d’attention (Q, K, V).

Initialiser les poids et les biais

PyTorch initialise les poids avec Kaiming Uniform par défaut, mais vous pouvez personnaliser cela avec torch.nn.init.

import torch.nn.init as init
 
init.xavier_uniform_(linear_layer.weight)
init.zeros_(linear_layer.bias)

Quand utiliser bias=False

On désactive souvent le biais lorsque :

• une couche de normalisation suit la couche linéaire
  (par exemple LayerNorm dans les Transformers)
• pour les couches de projection Q/K/V dans les blocs d’attention
• pour les couches linéaires à l’intérieur des blocs résiduels

Exemple :

nn.Linear(embed_dim, embed_dim, bias=False)

Comparaison entre nn.Linear et nn.Conv2d

Différences clés :

• Les couches linéaires utilisent des connexions denses (tout-à-tout).
• Conv2d utilise des kernels locaux dans l’espace, ce qui réduit le nombre de paramètres et introduit un biais inductif.

Applications de nn.Linear en deep learning

1. Multi-Layer Perceptron (MLP)

layer = nn.Linear(256, 128)

2. Modèles Transformer

Un Transformer standard utilise des couches linéaires pour :

• les projections Q, K, V
• les réseaux feed-forward (MLP)
• les têtes de sortie

Exemple :

q = nn.Linear(d_model, d_model, bias=False)

3. Têtes de classification

classifier = nn.Linear(hidden_dim, num_classes)

4. Autoencodeurs

L’encodeur et le décodeur utilisent des couches linéaires pour compresser puis reconstruire les données.

Utiliser nn.Linear dans un modèle PyTorch

import torch.nn.functional as F
from torch import nn
 
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 5)
        self.fc2 = nn.Linear(5, 2)
 
    def forward(self, x):
        x = F.relu(self.fc1(x))
        return self.fc2(x)
 
net = Net()

Conseils modernes pour PyTorch 2.x (important !)

🚀 1. torch.compile optimise les couches linéaires

model = torch.compile(net)

La compilation fusionne certaines opérations pour une exécution GPU plus rapide.

⚡ 2. AMP pour un entraînement plus rapide sur GPU

with torch.cuda.amp.autocast():
    output = model(x)

📉 3. Linear quantifié pour l’inférence

import torch.ao.quantization as quant

Réduit la taille du modèle et accélère l’inférence.

🔧 4. Utiliser F.linear pour des opérations fusionnées personnalisées

import torch.nn.functional as F
y = F.linear(x, weight, bias)

Utile lorsque vous combinez manuellement plusieurs opérations.

Erreurs fréquentes et comment les corriger

1. Mismatch de formes

RuntimeError: mat1 and mat2 shapes cannot be multiplied

Correction : assurez-vous que la dernière dimension de l’entrée correspond à in_features.

2. Passer des entrées 3D sans laisser nn.Linear gérer la forme

Évitez les reshape inutiles — Linear gère déjà les tenseurs 3D.

3. Oublier .float() lorsqu’on mélange des tenseurs entiers

x = x.float()

Conclusion

nn.Linear est un module en apparence simple mais fondamental dans PyTorch.
Des MLPs aux Transformers en passant par les modèles génératifs modernes, les couches linéaires représentent une grande partie du calcul dans les systèmes de deep learning actuels.

Comprendre :

• leur fonctionnement
• la façon dont elles gèrent différentes formes d’entrée
• comment les optimiser avec PyTorch 2.x

vous rendra nettement plus efficace pour construire des modèles neuronaux.

FAQ

Quel est le rôle du vecteur de biais dans nn.Linear ?

Le biais permet au modèle de décaler les valeurs de sortie indépendamment de l’entrée. Cela améliore la flexibilité, en particulier lorsque les entrées ne sont pas centrées autour de zéro.

Comment initialiser les poids et les biais ?

PyTorch les initialise automatiquement, mais vous pouvez les surcharger avec torch.nn.init (par exemple, initialisation Xavier).

Différence entre nn.Linear et nn.Conv2d ?

nn.Linear applique une transformation affine dense ; nn.Conv2d applique une convolution spatiale. Les couches linéaires sont utilisées dans les MLPs et les Transformers, tandis que les couches Conv2d sont utilisées dans les CNNs pour les données d’image.