Menu
in

Hoe u aandelen- of cryptocurrency-prijzen in 2024 kunt voorspellen met Python en PyTorch

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
.

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.

Leave a Reply