PyTorch-Grundlagen für neuronale Netze

Ein neuronales Netz ist ein Berechnungsmodell, das die Art und Weise nachahmt, wie das menschliche Gehirn Informationen verarbeitet. Es besteht aus vielen miteinander verbundenen Knoten (Neuronen), die in Schichten angeordnet sind.

Die Stärke neuronaler Netze liegt in ihrer Fähigkeit, automatisch komplexe Muster und Merkmale aus großen Datenmengen zu lernen, ohne die Notwendigkeit manuell entworfener Merkmalsextraktoren.

Mit der Entwicklung des Deep Learning sind neuronale Netzwerke zu einer Schlüsseltechnologie für die Lösung vieler komplexer Probleme geworden.

Neuron

Ein Neuron ist die Grundeinheit eines neuronalen Netzwerks. Es empfängt Eingangssignale, berechnet eine gewichtete Summe, addiert einen Bias und leitet das Ergebnis dann durch eine Aktivierungsfunktion, um eine Ausgabe zu erzeugen.

Die Gewichte und Bias-Werte eines Neurons sind die Parameter, die während des Lernprozesses des Netzwerks angepasst werden müssen.

Eingabe und Ausgabe:

  • Eingabe: Die Eingabe ist der Ausgangspunkt des Netzwerks und kann Merkmalsdaten wie Bildpixelwerte oder Textwortvektoren sein.
  • Ausgabe: Die Ausgabe ist der Endpunkt des Netzwerks und stellt das Vorhersageergebnis des Modells dar, wie z. B. das Klassenlabel in einer Klassifikationsaufgabe.

Ein Neuron empfängt mehrere Eingaben (z. B. x1, x2, ..., xn). Wenn die gewichtete Summe der Eingaben größer als der Aktivierungsschwellenwert (Aktivierungspotenzial) ist, erzeugt es eine binäre Ausgabe.

Die Ausgabe eines Neurons kann als die gewichtete Summe seiner Eingaben plus eines Bias betrachtet werden. Die mathematische Darstellung eines Neurons ist:

Hier,wjist das Gewicht,xjist die Eingabe, undBiasist der Bias-Term.

Ebene

Die Schichten zwischen der Eingabeschicht und der Ausgabeschicht werden als versteckte Schichten bezeichnet. Die Dichte und Art der Verbindungen zwischen den Schichten bilden die Netzwerkkonfiguration.

Ein neuronales Netzwerk besteht aus mehreren Schichten, darunter:

  • Eingabeschicht: Empfängt Roheingabedaten.
  • Verborgene Schicht: Verarbeitet die Eingabedaten; es kann mehrere verborgene Schichten geben.
  • Ausgabeschicht: Erzeugt das endgültige Ausgabeergebnis.

Typische Architektur eines neuronalen Netzes:

Demo-Diagramm:

Eingabeschicht Verborgene Schicht Ausgabeschicht Gewichtsverbindungen Aktivierungssignal

Feedforward-Neuronales Netz (FNN)

Das Feedforward-Neuronale Netz (FNN) ist eine Grundeinheit in der Familie der neuronalen Netze.

Das Merkmal eines Feedforward-Neuronalen Netzes ist, dass Daten von der Eingabeschicht durch eine oder mehrere verborgene Schichten fließen und schließlich die Ausgabeschicht erreichen, ohne Schleifen oder Rückkopplungen während des gesamten Prozesses.

Grundstruktur eines Feedforward-Neuronalen Netzes:

  • Eingabeschicht:Der Eintrittspunkt, an dem Daten in das Netz gelangen. Jeder Knoten in der Eingabeschicht repräsentiert ein Eingabemerkmal.

  • Verborgene Schicht:Eine oder mehrere Schichten, die verwendet werden, um nichtlineare Merkmale der Daten zu erfassen. Jede verborgene Schicht besteht aus mehreren Neuronen, und jedes Neuron erhöht die Nichtlinearität durch eine Aktivierungsfunktion.

  • Ausgabeschicht:Gibt das Vorhersageergebnis des Netzes aus. Die Anzahl der Knoten hängt vom Problemtyp ab; beispielsweise entspricht die Anzahl der Ausgabeknoten in einem Klassifikationsproblem der Anzahl der Klassen.

  • Verbindungsgewichte und Bias:Die Eingaben zu jedem Neuron werden gewichtet und summiert, dann wird ein Bias addiert, und das Ergebnis wird durch eine Aktivierungsfunktion geleitet.

Rekurrentes neuronales Netz (RNN)

Ein rekurrentes neuronales Netz (RNN) ist eine Art von neuronalem Netz, das speziell für die Verarbeitung von Sequenzdaten entwickelt wurde und Abhängigkeiten in zeitlichen oder sequenziellen Informationen innerhalb der Eingabedaten erfassen kann.

Das besondere Merkmal von RNNs ist ihre "Gedächtnisfähigkeit" – sie können Informationen aus vorherigen Zeitschritten im verborgenen Zustand des Netzwerks speichern.

Rekurrente neuronale Netze werden verwendet, um Datenmuster zu verarbeiten, die sich im Laufe der Zeit ändern.

Im RNN wird dieselbe Schicht verwendet, um Eingabeparameter zu empfangen und Ausgabeparameter im angegebenen neuronalen Netz anzuzeigen.

PyTorch bietet leistungsstarke Werkzeuge zum Erstellen und Trainieren neuronaler Netze.

Neuronale Netze in PyTorch werden mithilfe destorch.nnModuls implementiert.

torch.nnDas Modul bietet verschiedene Netzwerkschichten (wie vollständig verbundene Schichten, Faltungsschichten usw.), Verlustfunktionen und Optimierer, was das Erstellen und Trainieren neuronaler Netze bequemer macht.

In PyTorch erfordert das Erstellen eines neuronalen Netzes normalerweise das Erben von der Klasse nn.Module.

nn.Module ist die Basisklasse für alle neuronalen Netzwerkmodule. Sie müssen die folgenden zwei Teile definieren:

  • __init__(): Definieren Sie die Netzwerkschichten.
  • forward(): Definieren Sie den Vorwärtspropagationsprozess der Daten.

Einfaches vollständig verbundenes neuronales Netz:

Beispiel

import torch
import torch.nn as nn

# Definiere ein einfaches neuronales Netzmodell
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        # Definiere eine vollständig verbundene Schicht von der Eingabeschicht zur versteckten Schicht
        self.fc1 = nn.Linear(2, 2)  # 2 Eingabemerkmale, 2 Ausgabemerkmale
        # Definiere eine vollständig verbundene Schicht von der versteckten Schicht zur Ausgabeschicht
        self.fc2 = nn.Linear(2, 1)  # 2 Eingabemerkmale, 1 vorhergesagter Wert
   
    def forward(self, x):
        # Vorwärtspropagationsprozess
        x = torch.relu(self.fc1(x))  # ReLU-Aktivierungsfunktion verwenden
        x = self.fc2(x)  # Ausgabeschicht
        return x

# Modellinstanz erstellen
model = SimpleNN()

# Modell ausgeben
print(model)

Das Ausgabeergebnis ist wie folgt:

SimpleNN(
  (fc1): Linear(in_features=2, out_features=2, bias=True)
  (fc2): Linear(in_features=2, out_features=1, bias=True)
)

PyTorch bietet viele gängige Schichten für neuronale Netze. Hier sind einige gängige:

  • nn.Linear(in_features, out_features): Vollständig verbundene Schicht, Eingabein_featuresMerkmale, Ausgabeout_featuresMerkmale.
  • nn.Conv2d(in_channels, out_channels, kernel_size): 2D-Faltungsschicht, verwendet für die Bildverarbeitung.
  • nn.MaxPool2d(kernel_size): 2D-Max-Pooling-Schicht, verwendet zur Dimensionsreduktion.
  • nn.ReLU(): ReLU-Aktivierungsfunktion, häufig in verborgenen Schichten verwendet.
  • nn.Softmax(dim): Softmax-Aktivierungsfunktion, normalerweise in der Ausgabeschicht verwendet, geeignet für Multiklassen-Klassifikationsprobleme.

Aktivierungsfunktion

Aktivierungsfunktionen bestimmen, ob ein Neuron aktiviert werden soll. Sie sind nichtlineare Funktionen, die es neuronalen Netzwerken ermöglichen, zu lernen und komplexere Aufgaben auszuführen. Häufige Aktivierungsfunktionen sind:

  • Sigmoid: Wird für binäre Klassifikationsprobleme verwendet, mit Ausgabewerten zwischen 0 und 1.
  • Tanh: Ausgabewerte liegen zwischen -1 und 1, oft vor der Ausgabeschicht verwendet.
  • ReLU (Rectified Linear Unit): Eine der derzeit beliebtesten Aktivierungsfunktionen, definiert alsf(x) = max(0, x), was hilft, das Problem des verschwindenden Gradienten zu lösen.
  • Softmax: Wird oft in der Ausgabeschicht für Multiklassen-Klassifikationsprobleme verwendet; wandelt Ausgaben in eine Wahrscheinlichkeitsverteilung um.

Beispiel

import torch.nn.functional as F

# ReLU-Aktivierung
output = F.relu(input_tensor)

# Sigmoid-Aktivierung
output = torch.sigmoid(input_tensor)

# Tanh-Aktivierung
output = torch.tanh(input_tensor)

Verlustfunktion

Die Verlustfunktion wird verwendet, um die Differenz zwischen den vorhergesagten Werten des Modells und den wahren Werten zu messen.

Zu den üblichen Verlustfunktionen gehören:

  • Mittlerer quadratischer Fehler (MSELoss): Wird häufig für Regressionsprobleme verwendet; berechnet die quadrierte Differenz zwischen der Ausgabe und dem Zielwert.
  • Kreuzentropieverlust (CrossEntropyLoss): Wird häufig für Klassifikationsprobleme verwendet; berechnet die Kreuzentropie zwischen der Ausgabe und den wahren Labels.
  • BCEWithLogitsLoss: Für binäre Klassifikationsprobleme; kombiniert die Sigmoid-Aktivierung und den binären Kreuzentropieverlust.

Beispiel

# Verlust des mittleren quadratischen Fehlers
criterion = nn.MSELoss()

# Kreuzentropieverlust
criterion = nn.CrossEntropyLoss()

# Binärer Kreuzentropie-Verlust
criterion = nn.BCEWithLogitsLoss()

Optimierer

Der Optimierer ist dafür verantwortlich, die Gewichte und Bias-Werte des Netzwerks während des Trainingsprozesses zu aktualisieren.

Zu den gängigen Optimierern gehören:

  • SGD (Stochastic Gradient Descent)
  • Adam (Adaptive Moment Estimation)
  • RMSprop (Root Mean Square Propagation)

Beispiel

import torch.optim as optim

# SGD-Optimierer verwenden
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Adam-Optimierer verwenden
optimizer = optim.Adam(model.parameters(), lr=0.001)

Trainingsprozess

Das Training eines neuronalen Netzwerks umfasst die folgenden Schritte:

  1. Daten vorbereiten: durchDataLoaderdas Laden der Daten.
  2. Verlustfunktion und Optimierer definieren。
  3. Vorwärtspropagation: Berechne die Ausgabe des Modells.
  4. Berechne den Verlust: Vergleiche mit dem Zielwert, um den Verlustwert zu erhalten.
  5. Backpropagation: durchloss.backward()Berechnung der Gradienten.
  6. Parameter aktualisieren: durchoptimizer.step()Aktualisierung der Modellparameter.
  7. Wiederhole die obigen Schritte, bis die vorgegebene Anzahl an Trainingsepochen erreicht ist.

Beispiel

# Gehe davon aus, dass das Modell, die Verlustfunktion und der Optimierer bereits definiert wurden

# Beispiel-Trainingsdaten
X = torch.randn(10, 2)  # 10 Stichproben, jede mit 2 Merkmalen
Y = torch.randn(10, 1)  # 10 Ziel-Labels

# Trainingsprozess
for epoch in range(100):  # 100 Epochen trainieren
    model.train()  # Setze das Modell in den Trainingsmodus
    optimizer.zero_grad()  # Gradienten zurücksetzen
    output = model(X)  # Vorwärtspropagierung
    loss = criterion(output, Y)  # Verlust berechnen
    loss.backward()  # Backpropagation
    optimizer.step()  # Gewichte aktualisieren
   
    if (epoch + 1) % 10 == 0:  # Verlust alle 10 Epochen ausgeben
        print(f'Epoch [{epoch + 1}/100], Loss: {loss.item():.4f}')

Testen und Evaluierung

Nach Abschluss des Trainings muss das Modell getestet und evaluiert werden.

Übliche Schritte umfassen:

  • Verlust auf dem Testset berechnen: Leistung des Modells auf ungesehenen Daten bewerten.
  • Genauigkeit berechnen: Bei Klassifikationsproblemen den Anteil korrekter Vorhersagen berechnen.

Beispiel

# Angenommen, Sie haben Testsets X_test und Y_test
model.eval()  # Modell in den Evaluierungsmodus versetzen
with torch.no_grad():  # Gradientenberechnung während der Evaluierung deaktivieren
    output = model(X_test)
    loss = criterion(output, Y_test)
    print(f'Test Loss: {loss.item():.4f}')

Arten neuronaler Netze

  1. Feedforward-Neuronale Netze: Daten fließen in eine Richtung, von der Eingabeschicht zur Ausgabeschicht, ohne Rückkopplungsverbindungen.
  2. Faltungsnetzwerke (CNNs): geeignet für die Bildverarbeitung, wobei Faltungsschichten verwendet werden, um räumliche Merkmale zu extrahieren.
  3. Rekurrente Neuronale Netze (RNNs): geeignet für sequenzielle Daten, wie Zeitreihenanalyse und Verarbeitung natürlicher Sprache, wobei Informationsrückkopplungsschleifen möglich sind.
  4. Long Short-Term Memory (LSTM): eine spezielle Art von RNN, die langfristige Abhängigkeiten lernen kann.

torch.nn Referenz

Die folgenden sind die in PyTorch am häufigsten verwendetentorch.nnFunktionen und Klassen:

Grundlagen der Modelldefinition

Funktion Beschreibung Beispiel
nn.Module Basisklasse für alle neuronalen Netzwerkmodule class Net(nn.Module): ...
nn.Sequential Sequenzieller Container, der Ebenen in Reihenfolge ausführt nn.Sequential(conv, relu, pool)
nn.ModuleList Speichert Submodule in einer Liste self.layers = nn.ModuleList([...])
nn.Parameter Erzeugt einen lernbaren Parameter-Tensor self.w = nn.Parameter(torch.randn(n))

Faltungsschichten

Funktion Beschreibung Beispiel
nn.Conv1d 1D-Faltung (Text, Audio) nn.Conv1d(3, 64, 3)
nn.Conv2d 2D-Faltung (Bild) nn.Conv2d(3, 64, 3, padding=1)
nn.Conv3d 3D-Faltung (Video) nn.Conv3d(3, 64, 3)
nn.ConvTranspose2d Transponierte Faltung (Decoder, Upsampling) nn.ConvTranspose2d(64, 3, 2, stride=2)

Pooling-Schichten

Funktion Beschreibung Beispiel
nn.MaxPool2d 2D-Max-Pooling nn.MaxPool2d(2, 2)
nn.AvgPool2d 2D-Average-Pooling nn.AvgPool2d(2, 2)
nn.AdaptiveAvgPool2d Adaptives Average-Pooling (feste Ausgabegröße) nn.AdaptiveAvgPool2d((1, 1))
nn.AdaptiveMaxPool2d Adaptives Max-Pooling (feste Ausgabegröße) nn.AdaptiveMaxPool2d((1, 1))

Lineare Schichten

Funktion Beschreibung Beispiel
nn.Linear Vollständig verbundene Schicht (lineare Transformation) nn.Linear(128, 64)
nn.Bilinear Bilineare Schicht nn.Bilinear(128, 64, 32)
Funktion Beschreibung Beispiel
nn.ReLU ReLU-Aktivierungsfunktion, f(x) = max(0, x) nn.ReLU()
nn.GELU Gaussian Error Linear Unit (Standard in Transformer) nn.GELU()
nn.SiLU Swish-Aktivierungsfunktion nn.SiLU()
nn.Tanh Hyperbolischer Tangens nn.Tanh()
nn.Sigmoid Sigmoid-Aktivierungsfunktion nn.Sigmoid()
nn.Softmax Softmax-Aktivierungsfunktion nn.Softmax(dim=1)
nn.LogSoftmax Log-Softmax (numerisch stabil) nn.LogSoftmax(dim=1)
nn.LeakyReLU LeakyReLU, erlaubt kleine Gradienten für negative Werte nn.LeakyReLU(0.01)
nn.ELU Exponentielle lineare Einheit nn.ELU()

Normalisierungsschichten

Funktion Beschreibung Beispiel
nn.BatchNorm2d 2D-Batch-Normalisierung (häufig in Faltungsnetzwerken verwendet) nn.BatchNorm2d(64)
nn.LayerNorm Layer-Normalisierung (häufig in Transformers verwendet) nn.LayerNorm(512)
nn.GroupNorm Gruppen-Normalisierung (häufig in ResNet usw. verwendet) nn.GroupNorm(4, 64)
nn.InstanceNorm2d Instanz-Normalisierung (häufig bei der Stilübertragung verwendet) nn.InstanceNorm2d(64)

Rekurrente Schichten

Funktion Beschreibung Beispiel
nn.LSTM LSTM-(Long Short-Term Memory)-Schicht nn.LSTM(256, 512, 2)
nn.GRU GRU-(Gated Recurrent Unit)-Schicht nn.GRU(256, 512, 2)
nn.RNN Einfache RNN-Schicht nn.RNN(256, 512, 2)

Transformer-Schichten

Funktion Beschreibung Beispiel
nn.Transformer Vollständiges Transformer-Modell nn.Transformer(d_model=512, nhead=8)
nn.TransformerEncoder Transformer-Encoder nn.TransformerEncoder(layer, num_layers=6)
nn.TransformerDecoder Transformer-Decoder nn.TransformerDecoder(layer, num_layers=6)
nn.TransformerEncoderLayer Transformer-Encoder-Schicht nn.TransformerEncoderLayer(512, 8)
nn.MultiheadAttention Multi-Head-Attention-Mechanismus nn.MultiheadAttention(512, 8)

Embedding-Schichten

Funktion Beschreibung Beispiel
nn.Embedding Embedding-Schicht (bildet Vokabular auf Vektoren ab) nn.Embedding(10000, 256)
nn.EmbeddingBag Embedding-Bag (aggregiert mehrere Embeddings) nn.EmbeddingBag(10000, 256)

Dropout-Schichten

Funktion Beschreibung Beispiel
nn.Dropout Zufälliges Dropout (verhindert Overfitting) nn.Dropout(0.5)
nn.Dropout2d 2D-Dropout (verwirft gesamte Feature-Maps) nn.Dropout2d(0.5)

Verlustfunktionen

Funktion Beschreibung Beispiel
nn.CrossEntropyLoss Kreuzentropie-Verlust (Mehrklassenklassifikation) nn.CrossEntropyLoss()
nn.MSELoss Mittlerer quadratischer Fehler (Regression) nn.MSELoss()
nn.L1Loss L1-Verlust (MAE) nn.L1Loss()
nn.BCEWithLogitsLoss Binäre Kreuzentropie mit Sigmoid nn.BCEWithLogitsLoss()
nn.HuberLoss Huber-Verlust (robuste Regression) nn.HuberLoss()
nn.NLLLoss Negative Log-Likelihood-Verlust nn.NLLLoss()

Funktionale Funktionen (nn.functional)

Funktion Beschreibung Beispiel
F.relu ReLU-Aktivierung F.relu(x)
F.gelu GELU-Aktivierung F.gelu(x)
F.sigmoid Sigmoid-Aktivierung F.sigmoid(x)
F.softmax Softmax-Aktivierung F.softmax(x, dim=1)
F.dropout Dropout-Operation F.dropout(x, 0.5, training)
F.conv2d 2D-Faltung F.conv2d(x, weight, bias)
F.linear Lineare Transformation F.linear(x, weight, bias)
F.cross_entropy Cross-Entropy-Verlust F.cross_entropy(logits, targets)
F.mse_loss Verlust des mittleren quadratischen Fehlers F.mse_loss(pred, target)
F.interpolate Interpolation (Upsampling/Downsampling) F.interpolate(x, scale_factor=2)
F.embedding Embedding-Operation F.embedding(indices, weight)

Hilfsfunktionen (nn.init)

Funktion Beschreibung Beispiel
nn.init.xavier_uniform_ Xavier-Uniform-Initialisierung nn.init.xavier_uniform_(module.weight)
nn.init.xavier_normal_ Xavier-Normal-Initialisierung nn.init.xavier_normal_(module.weight)
nn.init.kaiming_uniform_ Kaiming-Uniform-Initialisierung (geeignet für ReLU) nn.init.kaiming_uniform_(module.weight)
nn.init.kaiming_normal_ Kaiming-Normal-Initialisierung (geeignet für ReLU) nn.init.kaiming_normal_(module.weight)
nn.init.zeros_ Nullinitialisierung nn.init.zeros_(module.bias)
nn.init.normal_ Normalinitialisierung nn.init.normal_(module.weight, 0, 0.01)

Hilfsfunktionen (nn.utils)

Funktion Beschreibung Beispiel
nn.utils.clip_grad_norm_ Gradienten-Norm-Clipping (verhindert Gradientenexplosion) nn.utils.clip_grad_norm_(model.parameters(), 1.0)
nn.utils.weight_norm Gewichtsnormalisierung nn.utils.weight_norm(module, 'weight')
nn.utils.spectral_norm Spektralnormalisierung (häufig in GANs verwendet) nn.utils.spectral_norm(module, 'weight')
nn.utils.rnn.pack_padded_sequence Sequenzen variabler Länge packen pack_padded_sequence(x, lengths)
nn.utils.rnn.pad_packed_sequence Sequenzen entpacken pad_packed_sequence(packed)
Andere Erweiterungen