Vi implementerar en grundläggande RNN för att demonstrera hur nätverket bearbetar sekventiell data och gör förutsägelser. Ett litet, dummy dataset används för att visa hur RNN:en lär sig från data och justerar sina vikter.

• Skapa dummydata: först genererar vi ett litet dataset som består av enkla numeriska sekvenser. Dessa sekvenser används för att träna vår RNN att identifiera mönster i datan;

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

• Bygga RNN-modellen: vi skapar en enkel RNN-arkitektur med ett dolt lager. Indatalagret tar emot data, medan det dolda lagret bearbetar den och skickar utdata till nästa steg. Det sista lagret ger förutsägelsen;

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äna RNN: under träningen justerar RNN sina interna vikter genom backpropagation för att minimera förutsägelsefel. Vi använder en förlustfunktion (till exempel medelkvadratfel) för att mäta modellens prestanda;

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

• Utvärdera modellen: efter träningen testar vi RNN:ens förmåga att förutsäga framtida datapunkter baserat på de mönster som lärts in från dummydata. Detta hjälper oss att se hur väl modellen har generaliserat;

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

• Kodexempel: koden som används i detta kapitel kan laddas ner.

Sammanfattningsvis innebär implementering av en grundläggande RNN att förbereda data, definiera arkitekturen, träna modellen och utvärdera dess prestanda. Detta praktiska tillvägagångssätt ger insikt i hur RNN:er kan användas för sekvensförutsägelse.