Nous implémentons un RNN basique pour démontrer comment le réseau traite des données séquentielles et effectue des prédictions. Un petit jeu de données factice est utilisé pour illustrer comment le RNN apprend à partir des données et ajuste ses poids.

• Création de données factices : tout d'abord, nous générons un petit jeu de données composé de séquences numériques simples. Ces séquences seront utilisées pour entraîner notre RNN à apprendre les motifs présents dans les données ;

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

• Construction du modèle RNN : nous créons une architecture RNN simple avec une couche cachée. La couche d'entrée reçoit les données, tandis que la couche cachée les traite et transmet la sortie à l'étape suivante. La couche finale fournit la prédiction ;

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)

• Entraînement du RNN : pendant l'entraînement, le RNN ajuste ses poids internes via la rétropropagation afin de minimiser les erreurs de prédiction. Nous utiliserons une fonction de perte (telle que l'erreur quadratique moyenne) pour mesurer la performance du modèle ;

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

• Évaluation du modèle : après l'entraînement, nous testons la capacité du RNN à prédire de nouveaux points de données à partir des motifs appris sur les données factices. Cela nous permet d'observer la capacité de généralisation du modèle ;

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

• Exemple de code : le code utilisé dans ce chapitre peut être téléchargé.

En résumé, l'implémentation d'un RNN basique implique la préparation des données, la définition de l'architecture, l'entraînement du modèle et l'évaluation de ses performances. Cette approche pratique permet de mieux comprendre comment les RNN peuvent être appliqués à des tâches de prédiction de séquences.