in

Comment prévoir les cours des actions ou des crypto-monnaies en 2024 avec Python et PyTorch

La prévision des cours des actions et des cryptomonnaies est un rêve ambitieux pour de nombreux investisseurs et passionnés de finance. Bien qu’il puisse sembler impossible de faire pousser des ailes, il n’en est pas de même pour prévoir les prix. Dans ce guide, nous nous concentrerons sur l’utilisation de PyTorch, une puissante bibliothèque d’apprentissage automatique, pour créer un algorithme d’apprentissage capable de prédire les prix des crypto-monnaies, en particulier ADA, la crypto-monnaie qui fonctionne sur la blockchain Cardano
.

Objectif

Vous apprendrez à tirer parti de PyTorch pour créer un algorithme d’apprentissage automatique, en utilisant non seulement les prix, mais également le volume et le montant des transactions comme entrée. Nous allons implémenter la méthode de la fenêtre coulissante et introduire un « écart de perspectives », une technique moins utilisée mais efficace. Nous explorerons différentes architectures et optimiseurs de modèles afin d’améliorer les performances des modèles.

Chargement des données

Nous utiliserons les données historiques ADA fournies par Kraken, un vaste référentiel de données historiques sur les crypto-monnaies. Les données seront chargées dans un dataframe Pandas
.

Python
Copier le code

importez des pandas au format pdf df = pd.read_csv (« data/ADAEUR_60.csv ») df [‘date’] = pd.to_datetime (df [‘timestamp’], unit=’s’, errors=’coerce’) df.set_index (‘date’, inplace=True) df.head ()

Visualisation des données

Avant de poursuivre, visualisons les données pour mieux comprendre leur structure. Nous allons créer un graphique indiquant le cours de clôture et le volume des transactions
.

Python
Copier le code

importez matplotlib.pyplot sous la forme plt downsampled_df = df.resample (‘1D’) .mean () plt.plot (downsampled_df.index, downsampled_df [‘close’], label=’close’, color=’blue’) plt.ylabel (‘Fermer’, color=’blue’) plt.tick_params (axis=’y’, label=’y’, color=’blue’) ax2 = plt.twinx () ax2.plot (downsampled_df.index, downsampled_df [‘volume’], label=’Volume’, color=’red’) ax2.set_ylabel (‘Volume’, color=’red’) ax2.tick_params (axis=’y# 8217 ;, labelcolor=’red’) plt.title (‘Clôture du prix contre Volume’) plt.show ()

Préparation des données

Nous mettrons en place certains hyperparamètres essentiels pour l’entraînement des modèles et nous normaliserons les données afin d’améliorer la qualité et la rapidité des calculs.

Python
Copier le code

depuis sklearn.preprocessing import StandardScaler hidden_units = 64 num_layers = 4learning_rate = 0,001 num_epochs = 100 batch_size = 32 window_size = 14prediction_steps = 7 taux d’abandon = 0,2 features = [‘close’, ‘volume’, ‘trades’] target = « close » df_sampled = df [features] .head (1000) .copy () scaler = StandardScaler () selected_features = df_sampled [fonctionnalités] .values.reshape (len -1, (fonctionnalités)) scaled_features = scaler.fit_transform (selected_features) df_sampled [fonctionnalités] = scaled_features

Méthode de fenêtre coulissante

Pour éviter d’introduire des biais et améliorer l’apprentissage des modèles, nous utiliserons la méthode de la fenêtre glissante et introduirons un écart de prédiction.

Python
Copier le code

import numpy en tant que np def create_sequences (data, window_size, prediction_steps, features, label) : X, y = [], [] pour i in range (len (data) — window_size — prediction_steps + 1) : sequence = data.iloc [i:i + window_size] [features] target = data.iloc [i + window_size + prediction_steps — 1] [label] x.append (sequence) y.append (target) renvoie np.array (X), np.array (y X), y = create_sequences (df_sampled, window_size, prediction_steps, features, target)

Division des données et lots

Nous allons diviser les données en ensembles d’entraînement et de test, et organiser les données par lots.

Python
Copier le code

depuis sklearn.model_selection import train_test_split import torch fromtorch.utils.data import TensorDataset, DataLoader x_train, X_test, y_train, y_test = train_test_split (X, y, test_size=0.2, shuffle=false) X_train_tensor = torch.Tensor (X_train) y_train_tensor = TORCH.Tensor (y_train) X_test_Tensor = TORCH.Tensor (X_test) y_test_tensor = torch.Tensor (X_test) y_test_tensor = torch.Tensor (X_test) and_test_tensor = torch.Tensor (y_test) train_dataset = TensorDataset (X_train_Ten_Tensor Tensor, y_train_tensor) test_dataset = TensorDataset (X_Test_Tensor, y_test_tensor) train_dataloader = DataLoader (train_dataset, batch_size=batch_size, shuffle=False) test_dataloader = DataLoader (test_dataset, batch_size=batch_size, shuffle=False
)

Création du modèle LSTM

Nous allons commencer par un modèle LSTM (Long Short-Term Memory), un type de réseau neuronal récurrent (RNN).

Python
Copier le code

import torch.nn en tant que classe nn PricePredictionLSTM (nn.Module) : def __init__ (self, input_size, hidden_size, num_layers, output_size=1) : super (PricePredictionLSTM, self). __init__ () self.hidden_size = hidden_size self.num_layers = num_layers self.lstm = nn.lstm (input_size, hidden_size, num_layers, batch_first=True) self.fc = nn.Linear (hidden_size, output_size) def forward (self, x) : h0 = torch.zeros (self.num_layers, x.size (0), self.hidden_size) .to (x.device) c0 = torch.zeros eros (self.num_layers, x.size (0), self.hidden_size) .to (x.device) out, _ = self.lstm (x, (h0, c0)) out = self.fc (out [:
, -1,:]) retourner

Fonction de perte et d’optimisation

Nous utiliserons l’erreur quadratique moyenne (MSE) comme fonction de perte et l’optimiseur AdamW pour mettre à jour les paramètres du modèle.

Python
Copier le code

loss_fn = optimiseur nn.mseloss () = torch.optim.adamw (model.parameters (), lr=learning_rate)

Cycle de formation

Le cycle de formation est au cœur du processus d’optimisation. À chaque époque, nous calculerons les prévisions, les pertes et mettrons à jour les paramètres du modèle
.

Python
Copier le code

heure d’importation depuis TQDM import TQDM import math depuis sklearn.metrics importmean_squared_error start = time.time () pour l’époque dans TQDM (range (num_epochs)) : model.train () total_train_loss = 0.0 all_train_targets, all_train_outputs = [], [] pour les entrées, les cibles dans train_dataloader : optimizer.zero_grad () sorties = perte du modèle (entrées) = loss_fn (outputs.squeeze (), targets) .backward () optimizer.step) total_train_loss += loss.item () all_train_targets.extend (targets.numpy ()) all_train_outputs.extend (outputs.detach () .numpy ()) model.eval () total_test_loss = 0,0 all_test_ targets, all_test_outputs = [], [] pour les entrées, cibles intest_dataloader : avec torch.no_grad () : sorties = perte du modèle (entrées) = loss_fn (outputs.squeeze (), cibles) total_test_loss += loss.item () all_test_targets.extend (targets.numpy ()) all_test_outputer ts.extend (outputs.detach () .numpy ()) average_epoch_train_loss = total_train_loss/len (train_dataloader)) average_epoch_test_loss = total_test_loss/len (test_dataloader) train_rmse = math.sqrt (mean_squared_error (all_train_targets, all_train_targets, all_train_target) sorties) test_rmse = math.sqrt (mean_squared_error (all_ test_targets, all_test_ outputs)) print (f » Epoch [{epoch + 1}/{num_epochs}], Perte de train : {average_epoch_train_loss : .4f}, Perte de test : {average_epoch_test_loss : .4f}, RMSE de train : {train_rmse : .4f}, RMSE Test : {test_rmse : .4f} ») durée = time.time
() — début

Réflexions finales

Nous avons introduit l’utilisation du LSTM et du GRU pour prédire les prix des cryptomonnaies, en utilisant une approche méthodique et détaillée. N’oubliez pas que la qualité du modèle dépend de la puissance de calcul et de la sélection des hyperparamètres. Continuez à expérimenter différents modèles et techniques pour améliorer vos prévisions
.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

trust wallet

Guide pour convertir l’USDT TRC-20 en USDT BEP-20 sur Trust Wallet

img 0003

Guide du contrat de location transitoire pour les étudiants