Wir implementieren ein einfaches RNN, um zu demonstrieren, wie das Netzwerk sequenzielle Daten verarbeitet und Vorhersagen trifft. Ein kleines, Dummy-Datenset wird verwendet, um zu zeigen, wie das RNN aus Daten lernt und seine Gewichte anpasst.

• Erstellen von Dummy-Daten: Zunächst generieren wir ein kleines Datenset, das aus einfachen numerischen Sequenzen besteht. Diese Sequenzen werden verwendet, um unser RNN darauf zu trainieren, Muster in den Daten zu erkennen;

sequences = np.random.rand(self.num_samples, self.seq_length, input_size).astype(np.float32)
labels = np.zeros(self.num_samples, dtype=np.int64)

• Erstellen des RNN-Modells: Wir erstellen eine einfache RNN-Architektur mit einer versteckten Schicht. Die Eingabeschicht erhält die Daten, während die versteckte Schicht diese verarbeitet und die Ausgabe an den nächsten Schritt weitergibt. Die letzte Schicht liefert die Vorhersage;

self.hidden_size = hidden_size
self.num_layers = num_layers
self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)

• Training des RNN: Während des Trainings passt das RNN seine internen Gewichte durch Backpropagation an, um die Vorhersagefehler zu minimieren. Wir verwenden eine Loss-Funktion (wie den mittleren quadratischen Fehler), um die Leistung des Modells zu messen;

for i, (sequences, labels) in enumerate(dataloader):
    # --- Forward pass ---
    outputs = model(sequences) # Get model predictions (logits)
    loss = criterion(outputs, labels) # Calculate the loss

    # --- Backward pass and optimization ---
    optimizer.zero_grad()   # Clear gradients from the previous iteration
    loss.backward()         # Compute gradients (Backpropagation Through Time happens here)
    optimizer.step()        # Update model parameters based on gradients

    # --- Track metrics ---
    total_loss += loss.item() # Accumulate the loss (loss.item() gets the scalar value)

    # Calculate accuracy for the batch
    _, predicted_classes = torch.max(outputs.data, 1) # Get the index (class) with the highest score
    total_samples += labels.size(0) # Add the number of samples in this batch
    correct_predictions += (predicted_classes == labels).sum().item()

• Modellbewertung: Nach dem Training testen wir die Fähigkeit des RNN, zukünftige Datenpunkte basierend auf den gelernten Mustern aus den Dummy-Daten vorherzusagen. Dies zeigt, wie gut das Modell generalisiert hat;

all_sequences, all_labels = dataset[:]
# Get model predictions for the entire dataset
outputs = model(all_sequences)

# Find the predicted class for each sample
_, predicted = torch.max(outputs.data, 1)

# Calculate total number of samples and correct predictions
total = all_labels.size(0)
correct = (predicted == all_labels).sum().item()

# Print the final accuracy
print(f'Accuracy of the model on the {total} training sequences: {100 * correct / total:.2f} %')

• Codebeispiel: Der in diesem Kapitel verwendete Code kann heruntergeladen werden.

Zusammenfassend umfasst die Implementierung eines einfachen RNN die Datenvorbereitung, die Definition der Architektur, das Training des Modells und die Bewertung der Leistung. Dieser praxisorientierte Ansatz vermittelt Einblicke, wie RNNs für Aufgaben der Sequenzvorhersage eingesetzt werden können.