Het
voorspellen van aandelen- en cryptocurrency-prijzen is een ambitieuze droom voor veel investeerders en financiële enthousiastelingen. Hoewel het kweken van vleugels misschien onmogelijk lijkt, is het voorspellen van prijzen dat niet. In deze gids zullen we ons concentreren op het gebruik van PyTorch, een krachtige machine learning-bibliotheek, om een leeralgoritme te bouwen dat de prijzen van cryptocurrencies kan voorspellen, met name ADA, de cryptocurrency die werkt op de Cardano-blockchain
.
Indice dei contenuti:
Doelstelling
Je leert hoe je PyTorch kunt gebruiken om een machine learning-algoritme te bouwen, waarbij je niet alleen prijzen gebruikt, maar ook het volume en de hoeveelheden transacties als invoer. We zullen de schuifraammethode implementeren en een ‘outlook gap’ introduceren, een minder gebruikte maar effectieve techniek. We zullen verschillende modelarchitecturen en optimalisatoren onderzoeken om de modelprestaties te verbeteren
.
Gegevens laden
We zullen historische ADA-gegevens gebruiken die zijn aangeleverd door Kraken, een uitgebreide opslagplaats van historische cryptocurrency-gegevens.
De gegevens worden in een Pandas-dataframe geladen
.
Python
Code kopiëren
panda’s importeren als pd df = pd.read_csv („data/ADAEUR_60.csv”) df [‘date’] = pd.to_datetime (df [‘timestamp’], unit‹s’, errorscoerce’) df.set_index (‘date’, inPlace=true) df.head ()
Datavisualisatie
Laten we, voordat we verder gaan, de gegevens visualiseren om hun structuur beter te begrijpen. We maken een grafiek met de slotkoers en het aantal transacties
.
Python
Code kopiëren
importeer matplotlib.pyplot als plt downsampled_df = df.resample (‘1D’) .mean () plt.plot (downsampled_df.index, downsampled_df [‘close’], label’close’, colorblue’) plt.ylabel (‘Close’, color101.blue’) plt.tick_params (axis17′, labelcolor’, labelcolor’) ‘Blue’) ax2 = plt.twinx () ax2.plot (downsampled_df.index, downsampled_df [‘volume’], label’Volume’, color’red’) ax2.set_ylabel (‘Volume’, color.cred’) ax2.tick_params (axis⁄y# 8217;, labelcolorz, red) plt.title (‘Prijs sluiten versus volume’) ‘) plt.show ()
Voorbereiding van de gegevens
We zullen enkele essentiële hyperparameters instellen voor modeltraining en we zullen de gegevens normaliseren om de kwaliteit en snelheid van de berekening te verbeteren.
Python
Code kopiëren
van sklearn.preprocessing import StandardScaler hidden_units = 64 num_layers = 4learning_rate = 0,001 num_epochs = 100 batch_size = 32 window_size = 14prediction_steps = 7 dropout_rate = 0,2 features = [‘close’, ‘volume’, ‘trades’] target = ‘close’ df_sampled = df [features] .head (1000) .copy () scaler = StandardScaler () selected_features = df_sampled [features] .values.reshape (len -1, (features)) scaled_features = scaler.fit_transform (selected_features) df_sampled [features] = scaled_features
Methode met schuifraam
Om vooringenomenheid te voorkomen en het leren van modellen te verbeteren, zullen we de schuifvenstermethode gebruiken en een voorspellingskloof introduceren.
Python
Code kopiëren
numpy importeren als np def create_sequences (data, window_size, prediction_steps, features, label): X, y = [], [] voor i binnen bereik (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) geeft np.array (X), np.array (y X), y = create_sequences terug (df_sampled, window_size, prediction_steps, features, target)
Gegevensverdeling en batch
We verdelen de gegevens in trainings- en testsets en organiseren de gegevens in batches.
Python
Code kopiëren
van sklearn.model_selection importeer 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.ch.Tensor (y_train) x_test_tensor = Torch.tensor (x_test) y_test_tensor = Torch.tensor (x_test) y_test_tensor = Torch.tensor (x_test) en_test_tensor = Torch.tensor (y_test) train_dataset = TensorDataSet (X_Train_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)
Het LSTM-model maken
We beginnen met een LSTM-model (Long Short-Term Memory), een soort terugkerend neuraal netwerk (RNN).
Python
Code kopiëren
importeer torch.nn als nn class 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 = 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 (selx) f.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,
:]) return uit
Loss and Optimizer-functie
We gebruiken de Mean Squared Error (MSE) als verliesfunctie en de AdamW-optimizer om de modelparameters bij te werken.
Python
Code kopiëren
loss_fn = nn.mseloss () optimizer = torch.optim.adamw (model.parameters (), lr=learning_rate)
Trainingscyclus
De trainingscyclus vormt het hart van het optimalisatieproces. In elk tijdperk zullen we de voorspellingen en het verlies berekenen en de modelparameters bijwerken
.
Python
Code kopiëren
importtijd uit TQDM importeren TQDM importeren wiskunde uit sklearn.metrics importmean_squared_error start = time.time () voor tijdperk in TQDM (range (num_epochs)): model.train () total_train_loss = 0,0 all_train_targets, all_train_outputs = [], [] voor ingangen, doelen in train_dataloader: optimizer.zero_grad () outputs = model (inputs) loss = 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 = [], [] voor inputs, targets intest_dataloader: met torch.no_grad (): outputs = model (inputs) loss = loss_fn (outputs.squeeze (), targets) total_test_loss += loss.item () all_test_targets.extend (targets.numpy ()) all_test_outputs.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_outputs)) test_rmse = math.sqrt (mean_squared_error (all_ test_targets, all_test_ outputs)) print (f” Epoch [{epoch + 1}/{num_epochs}], treinverlies: {average_epoch_train_loss: .4f}, testverlies: {average_epoch_test_loss: .4f}, Train RMSE: {train_rmse: .4f}, RMSE-test: {test_rmse: .4f}: .4f}”) duur = time.time
() — start
Laatste gedachten
We introduceerden het gebruik van LSTM en GRU voor het voorspellen van cryptocurrency-prijzen, met behulp van een methodische en gedetailleerde aanpak. Onthoud dat de kwaliteit van het model afhangt van de rekenkracht en de selectie van hyperparameters. Blijf experimenteren met verschillende modellen en technieken om je voorspellingen te verbeteren.
