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
.