PyTorch torch.nn.Sequential-Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.SequentialEs ist ein Container in PyTorch zum schnellen Erstellen sequenzieller Modelle.
Es führt Module in der deklarierten Reihenfolge aus und eignet sich zum Aufbau einfacher linearer Netzwerke.
Funktionsdefinition
torch.nn.Sequential(*args)
Parameterbeschreibung:
*args: Beliebig viele Module, die in der Reihenfolge ausgeführt werden, in der sie übergeben werden.
Anwendungsbeispiele
Beispiel 1: Grundlegende Verwendung
Ein einfaches Netzwerk mit Sequential erstellen:
Beispiel
import torch.nn as nn
# Sequenziellen Container erstellen
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 5)
)
# Teste die Vorwärtspropagation
input_tensor = torch.randn(3, 10)
output = model(input_tensor)
print("Modellstruktur:")
print(model)
print("Eingabe-Form:", input_tensor.shape)
print("Ausgabeform:", output.shape)
Beispiel 2: Layer mit OrderedDict benennen
Geben Sie für jeden Layer einen Namen mit OrderedDict an:
Beispiel
import torch.nn as nn
from collections import OrderedDict
# Layer mit OrderedDict benennen
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))
]))
# Auf Layer kann über den Namen zugegriffen werden
print("fc1-Schicht:", model.fc1)
print("relu1-Schicht:", model.relu1)
# Test
x = torch.randn(32, 784)
output = model(x)
print("nAusgabeform:", output.shape)
Beispiel 3: CNN-Beispiel
Erstellen Sie ein konvolutionales neuronales Netz:
Beispiel
import torch.nn as nn
cnn = nn.Sequential(
# Erster Faltungsblock
nn.Conv2d(3, 32, kernel_size=3, padding=1),
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(2, 2),
# Zweiter Faltungsblock
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("CNN-Struktur:")
print(cnn)
print("nEingabeform:", x.shape)
print("Ausgabeform:", output.shape)
Beispiel 4: Zugriff auf Zwischenschicht-Ausgaben
Verwenden Sie Forward-Hooks, um auf Zwischenschichten zuzugreifen:
Beispiel
import torch.nn as nn
# Einfaches Netzwerk
model = nn.Sequential(
nn.Linear(10, 20),
nn.ReLU(),
nn.Linear(20, 10)
)
# Methode 1: Verwenden von Hooks
feature = None
def hook_fn(module, input, output):
global feature
feature = output.clone()
# Hook registrieren
model[1].register_forward_hook(hook_fn)
# Vorwärtspropagierung
x = torch.randn(1, 10)
output = model(x)
print("ReLU-Ausgabeform:", feature.shape)
print("ReLU-Ausgabe:", feature.squeeze().tolist())
Sequential vs. manuelles Definieren von forward
| Ansatz | Vorteile | Nachteile |
|---|---|---|
nn.Sequential |
Prägnant, schnell zu erstellen | Geringe Flexibilität, Layer können nicht geteilt werden |
| Manuelles Definieren von forward | Flexible Steuerung des Datenflusses | Mehr Code |
Häufige Fragen
Q1: Wie erhält man einen bestimmten Layer in Sequential?
Zugriff über Index oder Name:model[0]odermodel.fc1
Q2: Ist Sequential für alle Netzwerke geeignet?
Nicht geeignet für Netzwerke mit Skip-Verbindungen, Verzweigungsstrukturen oder komplexen Datenflüssen.
Q3: Wie ändert man Layer in Sequential?
Sie könnenmodel[index] = new_moduleum den angegebenen Layer zu ersetzen.
Anwendungsfälle
nn.SequentialZu den wichtigsten Anwendungsszenarien gehören:
- Einfache Netzwerke: Linear gestapelte MLP, CNN
- Schnelles Prototyping: Modellideen schnell validieren
- Merkmalsextraktion: Feste Netzwerkstruktur
Tipp: Für komplexe Netzwerke wird empfohlen, von nn.Module zu erben und die forward-Methode manuell zu definieren.
Andere Erweiterungen