Implementiamo una RNN di base per dimostrare come la rete elabora dati sequenziali ed effettua previsioni. Viene utilizzato un piccolo set di dati fittizio per mostrare come la RNN apprende dai dati e adatta i suoi pesi.

• Creazione di dati fittizi: per prima cosa, generiamo un piccolo set di dati composto da semplici sequenze numeriche. Queste sequenze verranno utilizzate per addestrare la nostra RNN a riconoscere pattern nei dati;

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

• Costruzione del modello RNN: creiamo un'architettura RNN semplice con un solo strato nascosto. Lo strato di input riceve i dati, mentre lo strato nascosto li elabora e passa l'output allo step successivo. Lo strato finale fornisce la previsione;

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)

• Addestramento della RNN: durante l'addestramento, la RNN adatta i suoi pesi interni tramite la backpropagation per minimizzare gli errori di previsione. Utilizzeremo una funzione di perdita (come l'errore quadratico medio) per misurare le prestazioni del modello;

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

• Valutazione del modello: dopo l'addestramento, testiamo la capacità della RNN di prevedere punti dati futuri in base ai pattern appresi dai dati fittizi. Questo ci aiuta a vedere quanto bene il modello si è generalizzato;

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

• Esempio di codice: il codice utilizzato in questo capitolo può essere scaricato.

In sintesi, implementare una RNN di base comporta la preparazione dei dati, la definizione dell'architettura, l'addestramento del modello e la valutazione delle sue prestazioni. Questo approccio pratico offre una panoramica su come le RNN possano essere applicate a compiti di previsione di sequenze.