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 historiques via 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 d'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é à l'aide de la fonction de perte mean squared error (MSE) et de l'optimiseur Adam. Le modèle est entraîné sur plusieurs époques, la perte étant 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 l'ensemble de test. Les prédictions du modèle sont comparées aux prix réels des actions à l'aide de 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 réelles des prix à 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 se concentrant sur la prédiction des prix des actions. Les étapes clés incluent la définition du modèle, l'entraînement à l'aide de la fonction de perte MSE et de l'optimiseur Adam, et l'évaluation du modèle à l'aide de la RMSE.