Vi implementerer et grundlæggende RNN for at demonstrere, hvordan netværket behandler sekventielle data og foretager forudsigelser. Et lille, dummy dataset bruges til at illustrere, hvordan RNN'en lærer fra data og justerer sine vægte.

• Oprettelse af dummy data: først genereres et lille datasæt, der består af simple numeriske sekvenser. Disse sekvenser bruges til at træne vores RNN til at lære mønstre i dataene;

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

• Opbygning af RNN-modellen: vi opretter en simpel RNN-arkitektur med ét skjult lag. Inputlaget modtager data, mens det skjulte lag behandler dem og sender outputtet videre til næste trin. Det sidste lag leverer forudsigelsen;

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)

• Træning af RNN: under træningen justerer RNN sine interne vægte gennem backpropagation for at minimere forudsigelsesfejl. Vi anvender en loss-funktion (såsom mean squared error) til at måle modellens præstation;

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

• Evaluering af modellen: efter træning testes RNN'ens evne til at forudsige fremtidige datapunkter baseret på de lærte mønstre fra dummy data. Dette hjælper med at vurdere, hvor godt modellen har generaliseret;

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

• Kodeeksempel: koden brugt i dette kapitel kan downloades.

Sammenfattende indebærer implementering af et grundlæggende RNN at forberede data, definere arkitekturen, træne modellen og evaluere dens præstation. Denne praktiske tilgang giver indsigt i, hvordan RNN'er kan anvendes til sekvensforudsigelsesopgaver.