Vi implementerer en grunnleggende RNN for å demonstrere hvordan nettverket prosesserer sekvensielle data og gjør prediksjoner. Et lite, dummy dataset brukes for å vise hvordan RNN lærer fra data og justerer vektene sine.

• Opprette dummy-data: først genererer vi et lite datasett som består av enkle numeriske sekvenser. Disse sekvensene brukes til å trene vår RNN til å 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)

• Bygge RNN-modellen: vi lager en enkel RNN-arkitektur med ett skjult lag. Inndata-laget mottar data, mens det skjulte laget prosesserer det og sender utdata til neste steg. Det siste laget gir prediksjonen;

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)

• Trene RNN: under treningen justerer RNN sine interne vekter gjennom backpropagation for å minimere prediksjonsfeil. Vi bruker en tap-funksjon (for eksempel mean squared error) for å måle modellens ytelse;

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

• Evaluere modellen: etter trening tester vi RNNs evne til å predikere fremtidige datapunkter basert på de lærte mønstrene fra dummy-dataene. Dette hjelper oss å se hvor godt modellen har generalisert;

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 som brukes i dette kapittelet kan lastes ned.

Oppsummert innebærer implementering av en grunnleggende RNN å forberede data, definere arkitekturen, trene modellen og evaluere ytelsen. Denne praktiske tilnærmingen gir innsikt i hvordan RNN-er kan brukes til sekvensprediksjonsoppgaver.