We implementeren een eenvoudige RNN om te laten zien hoe het netwerk sequentiële data verwerkt en voorspellingen maakt. Er wordt gebruikgemaakt van een klein, dummy dataset om te demonstreren hoe de RNN leert van data en zijn gewichten aanpast.

• Aanmaken van dummy data: eerst genereren we een kleine dataset die bestaat uit eenvoudige numerieke reeksen. Deze reeksen worden gebruikt om onze RNN te trainen om patronen in de data te herkennen;

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

• Opbouwen van het RNN-model: we maken een eenvoudige RNN-architectuur met één verborgen laag. De inputlaag ontvangt data, terwijl de verborgen laag deze verwerkt en de output doorgeeft aan de volgende stap. De uiteindelijke laag levert de voorspelling;

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)

• Trainingsproces van de RNN: tijdens het trainen past de RNN zijn interne gewichten aan via backpropagation om de voorspellingsfouten te minimaliseren. We gebruiken een verliesfunctie (zoals mean squared error) om de prestaties van het model te meten;

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()

• Evaluatie van het model: na het trainen testen we het vermogen van de RNN om toekomstige datapunten te voorspellen op basis van de geleerde patronen uit de dummy data. Dit laat zien hoe goed het model generaliseert;

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} %')

• Codevoorbeeld: de code die in dit hoofdstuk wordt gebruikt, kan worden gedownload.

Samengevat omvat het implementeren van een eenvoudige RNN het voorbereiden van data, het definiëren van de architectuur, het trainen van het model en het evalueren van de prestaties. Deze praktische aanpak geeft inzicht in hoe RNN's kunnen worden toegepast op sequentievoorspellingstaken.