La formation et l'évaluation d'un réseau de neurones récurrents (RNN) basé sur LSTM pour la prédiction des prix des actions sont abordées. Le modèle apprend à prédire les prix futurs des actions à partir de données passées à travers un processus comprenant la définition de l'architecture, la configuration de la fonction de perte et de l'optimiseur, l'entraînement du modèle et l'évaluation de ses performances.

• Définition du modèle : le modèle LSTM est défini à l'aide de PyTorch, avec des composants clés tels que la taille de l'entrée, la taille de la couche cachée et le nombre de couches. Le modèle se compose d'une couche LSTM suivie d'une couche linéaire pour la prédiction de la sortie. Le modèle est conçu pour prendre les prix précédents des actions en entrée et prédire le prix à l'instant suivant ;

class LSTMModel(nn.Module):
def __init__(self, input_size=1, hidden_layer_size=50, num_layers=2, output_size=1):
super().__init__()
self.hidden_layer_size = hidden_layer_size
self.num_layers = num_layers
self.lstm = nn.LSTM(input_size, hidden_layer_size, num_layers, batch_first=True)
self.linear = nn.Linear(hidden_layer_size, output_size)

def forward(self, input_seq):
h0 = torch.zeros(self.num_layers, input_seq.size(0), self.hidden_layer_size).to(input_seq.device)
c0 = torch.zeros(self.num_layers, input_seq.size(0), self.hidden_layer_size).to(input_seq.device)
lstm_out, _ = self.lstm(input_seq, (h0.detach(), c0.detach()))
          last_time_step_out = lstm_out[:, -1, :]
predictions = self.linear(last_time_step_out)
return predictions

• Entraînement du modèle : à cette étape, le modèle est entraîné en utilisant la fonction de perte mean squared error (MSE) et l'optimiseur Adam. Le modèle est entraîné sur plusieurs époques, avec la perte calculée et mise à jour pour chaque lot de données d'entraînement. La boucle d'entraînement inclut la propagation avant et arrière, en optimisant les poids pour minimiser la perte. Pendant l'entraînement, la valeur de la perte est surveillée afin de s'assurer que le modèle apprend efficacement ;

criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

• Évaluation : après l'entraînement, le modèle est évalué sur le jeu de test. Les prédictions du modèle sont comparées aux prix réels des actions en utilisant l'erreur quadratique moyenne racine (RMSE) comme métrique d'évaluation. Cette métrique mesure la différence entre les valeurs prédites et réelles, une RMSE plus faible indiquant de meilleures performances. Le processus d'évaluation inclut également l'inversion de la transformation des prédictions normalisées pour obtenir les valeurs de prix réelles à des fins de comparaison ;

• Métrique de performance : la RMSE est utilisée pour évaluer la performance du modèle sur des données non vues. Une valeur de RMSE plus faible indique que les prédictions du modèle sont plus proches des valeurs réelles. La RMSE est calculée après comparaison des valeurs prédites avec les valeurs réelles non normalisées issues des données de test.

En résumé, ce chapitre décrit le processus d'entraînement et d'évaluation d'un modèle LSTM pour la prévision de séries temporelles, en mettant l'accent sur la prédiction des prix des actions. Les étapes clés incluent la définition du modèle, l'entraînement avec la fonction de perte MSE et l'optimiseur Adam, et l'évaluation du modèle à l'aide de la RMSE.