Implementierung eines Einfachen RNN

Implementierung eines einfachen RNN zur Demonstration der Verarbeitung sequentieller Daten und Vorhersageerstellung durch das Netzwerk. Verwendung eines kleinen Dummy-Datensatzes zur Veranschaulichung des Lernprozesses des RNN und der Anpassung seiner Gewichte an die Daten.

• Erstellung von Dummy-Daten: Zunächst wird ein kleiner Datensatz generiert, der aus einfachen Zahlenfolgen besteht. Diese Sequenzen werden verwendet, um das RNN auf das Erkennen von Mustern im Datensatz zu trainieren;

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

• Aufbau des RNN-Modells: Es wird eine einfache RNN-Architektur mit einer versteckten Schicht erstellt. Die Eingabeschicht nimmt die Daten auf, die versteckte Schicht verarbeitet sie und gibt das Ergebnis an den nächsten Schritt weiter. 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 Vorhersagefehler zu minimieren. Eine Loss-Funktion (wie z. B. mittlere quadratische Abweichung) wird verwendet, 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 wird die Fähigkeit des RNN getestet, zukünftige Datenpunkte auf Basis der aus den Dummy-Daten gelernten Muster 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 in die Anwendung von RNNs für Aufgaben der Sequenzvorhersage.