Das Sequential-Modell ist eine einfache Möglichkeit, sequenzielle Modelle in PyTorch zu definieren. Es erlaubt uns, eine sequentielle Kette von Schichten zu erstellen, in der die Ausgabe einer Schicht als Eingabe für die nächste Schicht verwendet wird.

import torch
import torch.nn as nn
 
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10),
    nn.Softmax(dim=1)
)

In diesem Beispiel wird ein Sequential-Modell mit zwei linearen Schichten, einer ReLU-Aktivierungsfunktion und einer Softmax-Aktivierungsfunktion erstellt. Die Eingabe des Modells hat eine Größe von 784, und die Ausgabe hat eine Größe von 10.

Das Module-Modell ist eine flexiblere Art, Modelle in PyTorch zu definieren. Es ermöglicht uns, eigene Schichten und komplexe Modelle zu erstellen, indem wir die nn.Module-Klasse erweitern.

import torch
import torch.nn as nn
 
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(784, 256)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(256, 10)
        self.softmax = nn.Softmax(dim=1)
 
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x
 
model = MyModel()

In diesem Beispiel wird ein Module-Modell erstellt, das den gleichen Aufbau wie das Sequential-Modell hat. Die Schichten werden jedoch als Attribute der Modellklasse definiert, und die Vorwärtsfunktion wird durch die Methode forward festgelegt. Dadurch haben wir mehr Flexibilität bei der Gestaltung und Steuerung des Modells.

Das Functional-Modell ist eine weitere Möglichkeit, Modelle in PyTorch zu definieren. Es basiert auf der Verwendung von Funktionen aus dem torch.nn.functional-Modul, anstatt Schichtenobjekte zu erstellen.

import torch
import torch.nn.functional as F
 
def my_model(x):
    x = F.linear(x, 784, 256)
    x = F.relu(x)
    x = F.linear(x, 256, 10)
    x = F.softmax(x, dim=1)
    return x
 
input = torch.randn(1, 784)
output = my_model(input)

In diesem Beispiel wird das Modell als eine Funktion definiert, die die Funktionen aus dem torch.nn.functional-Modul verwendet. Das Functional-Modell ist nützlich, wenn Sie ein einfaches Modell ohne interne Zustände oder trainierbare Parameter erstellen möchten.

Convolutional Neural Networks sind besonders gut geeignet für die Verarbeitung von Bildern. Sie verwenden spezielle Schichten wie Convolutional Layers und Pooling Layers, um die räumliche Struktur der Eingabedaten zu berücksichtigen.

import torch
import torch.nn as nn
 
class MyCNN(nn.Module):
    def __init__(self):
        super(MyCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc = nn.Linear(16 * 14 * 14, 10)
 
    def forward(self, x):
        x = self.conv1(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(-1, 16 * 14 * 14)
        x = self.fc(x)
        return x
 
model = MyCNN()

In diesem Beispiel wird ein CNN-Modell erstellt, das eine Convolutional Layer, eine ReLU-Aktivierungsfunktion, eine Max-Pooling-Layer und eine Fully Connected Layer enthält. Das Modell wird für die Klassifikation von Bildern verwendet.

Recurrent Neural Networks sind gut geeignet für die Verarbeitung von sequenziellen Daten wie Texten oder Zeitreihen. Sie haben die Fähigkeit, Informationen über vergangene Zustände beizubehalten.

import torch
import torch.nn as nn
 
class MyRNN(nn.Module):
    def __init__(self):
        super(MyRNN, self).__init__()
        self.rnn = nn.RNN(input_size=100, hidden_size=128, num_layers=2, batch_first=True)
        self.fc = nn.Linear(128, 10)
 
    def forward(self, x):
        _, h = self.rnn(x)
        x = self.fc(h[-1])
        return x
 
model = MyRNN()

In diesem Beispiel wird ein RNN-Modell erstellt, das aus einer RNN-Schicht und einer Fully Connected Layer besteht. Das Modell nimmt Eingaben mit einer Sequenzlänge von 100 und gibt eine Ausgabe der Größe 10 zurück.

Transformer-Modelle haben in den letzten Jahren an Beliebtheit gewonnen und sind besonders gut für die Verarbeitung von natürlicher Sprache geeignet. Sie verwenden Aufmerksamkeitsmechanismen, um die Beziehungen zwischen den Elementen einer Sequenz zu modellieren.

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import TransformerEncoder, TransformerEncoderLayer
 
class MyTransformer(nn.Module):
    def __init__(self):
        super(MyTransformer, self).__init__()
        self.embedding = nn.Embedding(10000, 256)
        self.transformer_layer = TransformerEncoderLayer(256, 8)
        self.transformer = TransformerEncoder(self.transformer_layer, num_layers=4)
        self.fc = nn.Linear(256, 10)
 
    def forward(self, x):
        x = self.embedding(x)
        x = x.permute(1, 0, 2)
        x = self.transformer(x)
        x = x.mean(dim=0)
        x = self.fc(x)
        return x
 
model = MyTransformer()

In diesem Beispiel wird ein Transformer-Modell erstellt, das eine Embedding-Schicht, einen TransformerEncoder und eine Fully Connected Layer enthält. Das Modell nimmt Sequenzeingaben, z.B. Token-IDs, und gibt eine Ausgabe der Größe 10 zurück.

# Pattern Recognition
 
import torch
import torch.nn as nn
import torch.optim as optim
 
# Daten vorbereiten (Beispiel)
sequences = [
    [1,0,1,1,0],
    [0,1,1,0,0],
    [0,1,0,0,0],
    [1,0,1,0,1],
    [1,0,0,0,1],
    [0,1,0,1,0],
    [1,1,0,1,1],
    [0,0,1,0,0]
]
labels = [1,1,0,1,0,0,0,1]  # Beispieldaten fur die Musterklassifizierung
 
# Hyperparameter
input_size = 1
hidden_size = 5*5
output_size = 2
num_layers = 3
num_epochs = 100
learning_rate = 0.1
 
# Daten in Tensoren umwandeln
input_sequences = torch.tensor(sequences, dtype=torch.float32).unsqueeze(-1)
target_labels = torch.tensor(labels, dtype=torch.long)
 
# Modell definieren
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(RNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
 
    def forward(self, x):
        h0 = torch.zeros(num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.rnn(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out
 
model = RNN(input_size, hidden_size, output_size, num_layers)
 
# Verlustfunktion und Optimierungsalgorithmus definieren
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
# Modell trainieren
for epoch in range(num_epochs):
    optimizer.zero_grad()
    outputs = model(input_sequences)
    loss = criterion(outputs, target_labels)
    loss.backward()
    optimizer.step()
    print(f'Epoch: {epoch+1}/{num_epochs}, Loss: {loss.item()}')
 
# Modell evaluieren
with torch.no_grad():
    test_input = torch.tensor([[1,0,0,1,1]], dtype=torch.float32).unsqueeze(-1)
    predicted = model(test_input)
    _, predicted_labels = torch.max(predicted.data, 1)
    print(f'Predicted Label: {predicted_labels.item()} {predicted.data}')
 
 
'''
torch.save(model.state_dict(), "test.pt")
model.load_state_dict(torch.load("test.pt"))
'''