We implementeren een basis-RNN om te demonstreren hoe het netwerk sequentiële data verwerkt en voorspellingen maakt. Een klein, dummy dataset wordt gebruikt om te laten zien 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 leren;

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 creëren 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 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 heeft gegeneraliseerd;

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 basis-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 sequentievoorspellingsproblemen.