Fonction torch.nn.Sequential de PyTorch
Manuel de référence torch.nn de PyTorch
torch.nn.SequentialIl s'agit d'un conteneur dans PyTorch pour construire rapidement des modèles séquentiels.
Il exécute les modules dans l'ordre déclaré et convient à la construction de réseaux linéaires simples.
Définition de fonction
torch.nn.Sequential(*args)
Description des paramètres :
*args: Un nombre quelconque de modules, qui seront exécutés dans l'ordre dans lequel ils sont passés.
Exemples d'utilisation
Exemple 1 : Utilisation de base
Construire un réseau simple avec Sequential :
Exemple
import torch.nn as nn
# Créer un conteneur séquentiel
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 5)
)
# Tester la propagation avant
input_tensor = torch.randn(3, 10)
output = model(input_tensor)
print("Structure du modèle:")
print(model)
print("nForme de l'entrée :", input_tensor.shape)
print("Forme de sortie :", output.shape)
Exemple 2 : Nommer les couches avec OrderedDict
Spécifiez un nom pour chaque couche avec OrderedDict :
Exemple
import torch.nn as nn
from collections import OrderedDict
# Nommer les couches avec OrderedDict
model = nn.Sequential(OrderedDict([
('fc1', nn.Linear(784, 256)),
('relu1', nn.ReLU()),
('fc2', nn.Linear(256, 128)),
('relu2', nn.ReLU()),
('output', nn.Linear(128, 10))
]))
# Les couches sont accessibles par leur nom
print("couche fc1 :", model.fc1)
print("couche relu1 :", model.relu1)
# Test
x = torch.randn(32, 784)
output = model(x)
print("nForme de sortie :", output.shape)
Exemple 3 : Exemple de CNN
Construire un réseau de neurones convolutif :
Exemple
import torch.nn as nn
cnn = nn.Sequential(
# Premier bloc de convolution
nn.Conv2d(3, 32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(2, 2),
# Deuxième bloc de convolution
nn.Conv2d(32, 64, kernel_size=3, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(2, 2),
# Flatten
nn.Flatten(),
nn.Linear(64 * 8 * 8, 256),
nn.ReLU(),
nn.Dropout(0.5),
nn.Linear(256, 10)
)
# Test
x = torch.randn(4, 3, 32, 32)
output = cnn(x)
print("Structure du CNN :")
print(cnn)
print("nForme d'entrée :", x.shape)
print("Forme de sortie :", output.shape)
Exemple 4 : Accès aux sorties des couches intermédiaires
Utiliser des hooks forward pour accéder aux couches intermédiaires :
Exemple
import torch.nn as nn
# Réseau simple
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 10)
)
# Méthode 1 : Utilisation de hooks
feature = None
def hook_fn(module, input, output):
global feature
feature = output.clone()
# Enregistrer le hook
model[1].register_forward_hook(hook_fn)
# Propagation avant
x = torch.randn(1, 10)
output = model(x)
print("Forme de sortie de ReLU :", feature.shape)
print("Sortie de ReLU :", feature.squeeze().tolist())
Sequential vs Définition manuelle de forward
| Approche | Avantages | Inconvénients |
|---|---|---|
nn.Sequential |
Concis, rapide à construire | Faible flexibilité, impossible de partager des couches |
| Définir manuellement forward | Contrôle flexible du flux de données | Plus de code |
Questions courantes
Q1 : Comment obtenir une couche spécifique dans Sequential ?
Accès par index ou par nom :model[0]oumodel.fc1
Q2 : Sequential convient-il à tous les réseaux ?
Ne convient pas aux réseaux avec des connexions de saut, des structures de branchement ou des flux de données complexes.
Q3 : Comment modifier des couches dans Sequential ?
Vous pouvez utilisermodel[index] = new_modulepour remplacer la couche spécifiée.
Cas d'utilisation
nn.SequentialLes principaux scénarios d'application incluent :
- Réseaux simples: MLP, CNN empilés linéairement
- Prototypage rapide: valider rapidement des idées de modèle
- Extraction de caractéristiques: structure de réseau fixe
Astuce : pour les réseaux complexes, il est recommandé d'hériter de nn.Module et de définir manuellement la méthode forward.
Autres extensions