PyTorch torch.nn.Module-Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.ModuleEs ist die Basisklasse für alle neuronalen Netzwerkmodule in PyTorch.
Alle benutzerdefinierten Netzwerkmodelle sollten von dieser Klasse erben, da sie Parametermanagement, Gerätemigration, Modellspeicherung und weitere Funktionen bietet.
Klassendefinition
torch.nn.Module
Hauptattribute
parameters(): Gibt alle lernbaren Parameter des Modells zurück.named_parameters(): Gibt einen Iterator von Parameternamen und -werten zurück.children(): Gibt die Submodule des Modells zurück.named_children(): Gibt einen Iterator von Submodulnamen und Modulen zurück.modules(): Gibt alle Module zurück.state_dict(): Gibt ein Dictionary zurück, das alle Parameter enthält.
Anwendungsbeispiele
Beispiel 1: Erstellen eines benutzerdefinierten Moduls
Von nn.Module erben, um ein benutzerdefiniertes Netzwerk zu erstellen:
Beispiel
import torch
import torch.nn as nn
class SimpleNet(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(SimpleNet, self).__init__()
# Netzwerkschichten definieren
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
# Vorwärtspropagation definieren
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
# Modell instanziieren
model = SimpleNet(input_dim=784, hidden_dim=256, output_dim=10)
# Test
x = torch.randn(32, 784)
output = model(x)
print(Modellstruktur:)
print(model)
print(nEingabeform:, x.shape)
print(Ausgabeform:, output.shape)
import torch.nn as nn
class SimpleNet(nn.Module):
def __init__(self, input_dim, hidden_dim, output_dim):
super(SimpleNet, self).__init__()
# Netzwerkschichten definieren
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_dim, output_dim)
def forward(self, x):
# Vorwärtspropagation definieren
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
# Modell instanziieren
model = SimpleNet(input_dim=784, hidden_dim=256, output_dim=10)
# Test
x = torch.randn(32, 784)
output = model(x)
print(Modellstruktur:)
print(model)
print(nEingabeform:, x.shape)
print(Ausgabeform:, output.shape)
Beispiel 2: Parameter verwalten
Auf Modellparameter zugreifen und sie verwalten:
Beispiel
import torch
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3)
self.bn1 = nn.BatchNorm2d(16)
self.fc = nn.Linear(16 * 14 * 14, 10)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
model = Net()
# Anzahl der Parameter zählen
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(Gesamtparameter:, total_params)
print(Trainierbare Parameter:, trainable_params)
# Zugriff auf bestimmte Parameter
print(nconv1 Gewichtsform:, model.conv1.weight.shape)
print(fc Bias-Form:, model.fc.bias.shape)
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 16, 3)
self.bn1 = nn.BatchNorm2d(16)
self.fc = nn.Linear(16 * 14 * 14, 10)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
model = Net()
# Anzahl der Parameter zählen
total_params = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(Gesamtparameter:, total_params)
print(Trainierbare Parameter:, trainable_params)
# Zugriff auf bestimmte Parameter
print(nconv1 Gewichtsform:, model.conv1.weight.shape)
print(fc Bias-Form:, model.fc.bias.shape)
Beispiel 3: Modell speichern und laden
Modell speichern und laden:
Beispiel
import torch
import torch.nn as nn
import tempfile
import os
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(10, 5)
def forward(self, x):
return self.fc(x)
model = Net()
# Das gesamte Modell speichern
with tempfile.NamedTemporaryFile(delete=False, suffix='.pth') as f:
torch.save(model, f.name)
path_full = f.name
# state_dict speichern (empfohlene Methode)
with tempfile.NamedTemporaryFile(delete=False, suffix='.pth') as f:
torch.save(model.state_dict(), f.name)
path_state = f.name
# Modell laden
loaded_model = Net()
loaded_model.load_state_dict(torch.load(path_state))
loaded_model.eval()
# Das geladene Modell testen
x = torch.randn(2, 10)
output1 = model(x)
output2 = loaded_model(x)
print(Ursprüngliche Ausgabe:, output1[0].tolist())
print(Ausgabe nach dem Laden:, output2[0].tolist())
# Aufräumen
os.remove(path_full)
os.remove(path_state)
import torch.nn as nn
import tempfile
import os
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(10, 5)
def forward(self, x):
return self.fc(x)
model = Net()
# Das gesamte Modell speichern
with tempfile.NamedTemporaryFile(delete=False, suffix='.pth') as f:
torch.save(model, f.name)
path_full = f.name
# state_dict speichern (empfohlene Methode)
with tempfile.NamedTemporaryFile(delete=False, suffix='.pth') as f:
torch.save(model.state_dict(), f.name)
path_state = f.name
# Modell laden
loaded_model = Net()
loaded_model.load_state_dict(torch.load(path_state))
loaded_model.eval()
# Das geladene Modell testen
x = torch.randn(2, 10)
output1 = model(x)
output2 = loaded_model(x)
print(Ursprüngliche Ausgabe:, output1[0].tolist())
print(Ausgabe nach dem Laden:, output2[0].tolist())
# Aufräumen
os.remove(path_full)
os.remove(path_state)
Beispiel 4: Gerätemigration
Das Modell zwischen verschiedenen Geräten migrieren:
Beispiel
import torch
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(10, 5)
def forward(self, x):
return self.fc(x)
model = Net()
# Aktuelles Gerät prüfen
print(Gerät des Parameters:, model.fc.weight.device)
# Auf GPU verschieben (falls verfügbar)
if torch.cuda.is_available():
model = model.cuda()
print(Nach dem Verschieben auf GPU:, model.fc.weight.device)
# Zurück zur CPU verschieben
model = model.cpu()
print(Nach dem Zurückverschieben auf die CPU:, model.fc.weight.device)
import torch.nn as nn
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(10, 5)
def forward(self, x):
return self.fc(x)
model = Net()
# Aktuelles Gerät prüfen
print(Gerät des Parameters:, model.fc.weight.device)
# Auf GPU verschieben (falls verfügbar)
if torch.cuda.is_available():
model = model.cuda()
print(Nach dem Verschieben auf GPU:, model.fc.weight.device)
# Zurück zur CPU verschieben
model = model.cpu()
print(Nach dem Zurückverschieben auf die CPU:, model.fc.weight.device)
Beispiel 5: Initialisierung mit apply
Verwenden Sie apply, um rekursiv zu initialisieren:
Beispiel
import torch
import torch.nn as nn
def init_weights(module):
if isinstance(module, nn.Linear):
nn.init.xavier_uniform_(module.weight)
if module.bias is not None:
nn.init.zeros_(module.bias)
elif isinstance(module, nn.Conv2d):
nn.init.kaiming_normal_(module.weight)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(10, 20)
self.fc2 = nn.Linear(20, 5)
def forward(self, x):
return self.fc2(self.fc1(x))
model = Net()
model.apply(init_weights)
print(fc1-Gewicht:, model.fc1.weight[0, :3].tolist())
print(fc2-Gewicht:, model.fc2.weight[0, :3].tolist())
import torch.nn as nn
def init_weights(module):
if isinstance(module, nn.Linear):
nn.init.xavier_uniform_(module.weight)
if module.bias is not None:
nn.init.zeros_(module.bias)
elif isinstance(module, nn.Conv2d):
nn.init.kaiming_normal_(module.weight)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(10, 20)
self.fc2 = nn.Linear(20, 5)
def forward(self, x):
return self.fc2(self.fc1(x))
model = Net()
model.apply(init_weights)
print(fc1-Gewicht:, model.fc1.weight[0, :3].tolist())
print(fc2-Gewicht:, model.fc2.weight[0, :3].tolist())
Beispiel 6: Komplexe Netzwerkstruktur
Ein Netzwerk mit Verzweigungen erstellen:
Beispiel
import torch
import torch.nn as nn
class BranchNet(nn.Module):
def __init__(self):
super(BranchNet, self).__init__()
# Basisnetz
self.shared = nn.Linear(10, 20)
# Verzweigung
self.branch_a = nn.Linear(20, 5)
self.branch_b = nn.Linear(20, 3)
def forward(self, x):
feat = self.shared(x)
out_a = self.branch_a(feat)
out_b = self.branch_b(feat)
return out_a, out_b
model = BranchNet()
x = torch.randn(4, 10)
out_a, out_b = model(x)
print(Ausgabe von Branch A:, out_a.shape)
print(Ausgabe von Branch B:, out_b.shape)
import torch.nn as nn
class BranchNet(nn.Module):
def __init__(self):
super(BranchNet, self).__init__()
# Basisnetz
self.shared = nn.Linear(10, 20)
# Verzweigung
self.branch_a = nn.Linear(20, 5)
self.branch_b = nn.Linear(20, 3)
def forward(self, x):
feat = self.shared(x)
out_a = self.branch_a(feat)
out_b = self.branch_b(feat)
return out_a, out_b
model = BranchNet()
x = torch.randn(4, 10)
out_a, out_b = model(x)
print(Ausgabe von Branch A:, out_a.shape)
print(Ausgabe von Branch B:, out_b.shape)
FAQ
Q1: Warum muss super().__init__() aufgerufen werden?
Es ruft die Initialisierungsmethode der Elternklasse auf und stellt dadurch sicher, dass das Modul Parameter korrekt registriert.
<h3 Q2: Wie kann man die Modellstruktur anzeigen?Geben Sie direkt print(model) aus oder verwenden Sie die summary-Funktion aus torchvision.
<h3 Q3: Was ist der Unterschied zwischen parameters() und modules()?parameters() gibt lernbare Parameter zurück, während modules() alle Module zurückgibt.
Anwendungsfälle
nn.ModuleEs ist die Grundlage für den Aufbau aller benutzerdefinierten neuronalen Netzwerke. Die wichtigsten Anwendungsszenarien umfassen:
- Definieren der Netzwerkstruktur: Jedes benutzerdefinierte neuronale Netzwerk
- Modellverwaltung: Speichern, Laden, Migration
- Parameterverwaltung: Optimierer-Updates, Gradientenberechnung
Hinweis: Alle benutzerdefinierten Module müssen die forward-Methode implementieren.
Andere Erweiterungen