Die Prognose von Aktien- und Kryptowährungspreisen ist für viele Anleger und Finanzbegeisterte ein ehrgeiziger Traum. Flügel wachsen zu lassen, mag unmöglich erscheinen, Preise vorherzusagen aber nicht. In diesem Handbuch konzentrieren wir uns auf die Verwendung von PyTorch, einer leistungsstarken Bibliothek für maschinelles Lernen, um einen Lernalgorithmus zu entwickeln, der in der Lage ist, die Preise von Kryptowährungen vorherzusagen, insbesondere ADA, der Kryptowährung, die auf der Cardano-Blockchain arbeitet
.
Index du contenu:
Ziel
Sie lernen, wie Sie PyTorch nutzen können, um einen Algorithmus für maschinelles Lernen zu erstellen, der nicht nur Preise, sondern auch das Volumen und die Beträge der Transaktionen als Eingabe verwendet.
Wir werden die Sliding Window-Methode implementieren und eine „Outlook-Lücke“ einführen, eine weniger verbreitete, aber effektive Technik. Wir werden verschiedene Modellarchitekturen und Optimierer untersuchen
, um die Modellleistung zu verbessern.
Daten werden geladen
Wir werden historische ADA-Daten verwenden, die von Kraken bereitgestellt werden, einem umfangreichen Archiv historischer Kryptowährungsdaten. Die Daten werden in einen Pandas-Datenrahmen geladen
.
Python
Code kopieren
importiere Pandas als pd df = pd.read_csv („data/ADAEUR_60.csv“) df [‚date‘] = pd.to_datetime (df [‚timestamp‘], unit=’s‘, errors=’force‘) df.set_index (‚date‘, inplace=True) df.head ()
Datenvisualisierung
Bevor wir fortfahren, visualisieren wir die Daten, um ihre Struktur besser zu verstehen. Wir werden ein Diagramm erstellen, das den Schlusskurs und das Transaktionsvolumen
zeigt.
Python
Code kopieren
importiere matplotlib.pyplot als plt downsampled_df = df.resample (‚1D‘) .mean () plt.plot (downsampled_df.index, downsampled_df [‚close‘], label=’close‘, color=’blue‘) plt.ylabel (‚Schließen‘, color=’blau‘) plt.tick_params (axis=‘ ‚y‘, labelcolor=’blau‘) ax2 = plt.twinx () ax2.plot (downsampled_df.index, downsampled_df [‚volume‘], label=‘ volume ‚, color=’rot‘) ax2.set_ylabel (‚ Volume ‚, color=’rot‘) ax2.tick_params (axis=’y# 8217;, labelcolor‘) =’rot‘) plt.title (‚Schlusskurs versus Volumen‘) plt.show ()
Vorbereitung der Daten
Wir werden einige wichtige Hyperparameter für das Modelltraining einrichten und die Daten normalisieren, um die Qualität und Geschwindigkeit der Berechnung zu verbessern.
Python
Code kopieren
von 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 mit Schiebefenstern
Um Verzerrungen zu vermeiden und das Lernen von Modellen zu verbessern, verwenden wir die Methode des gleitenden Fensters und führen eine Prognoselücke ein.
Python
Code kopieren
importiere numpy als np def create_sequences (data, window_size, prediction_steps, features, label): X, y = [], [] for i in range (len (data) — window_size — prediction_steps + 1): sequence = data.iloc [i:i + window_size] [features] target = data.iloc [i + window_steps — 1] [Bezeichnung] x.append (sequence) y.append (target) gibt np.array (X), np.array (y X), y = create_sequences (df_sampled, window_size, prediction_steps, features, target) zurück
Datenteilung und Batch
Wir teilen die Daten in Trainings- und Testsätze auf und organisieren die Daten stapelweise.
Python
Code kopieren
von sklearn.model_selection importiere train_test_split importiere Torch von torch.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 (x_train) y_train_tensor (y_train) x_test_tensor = torch.Tensor (x_Test) y_test_tensor = torch.Tensor (x_Test) y_test_tensor = torch.Tensor (x_Test) und_test_tensor = torch.Tensor (y_test) train_dataset = TensorDatensatz (x_train_tensor, y_train_tensor) test_dataset = TensorDatensatz (x_train_tensor, y_train_tensor) Datensatz (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)
Das LSTM-Modell erstellen
Wir beginnen mit einem LSTM-Modell (Long Short-Term Memory), einer Art rekurrentem neuronalem Netzwerk (RNN).
Python
Code kopieren
importiere torch.nn als nn-Klasse 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.zer.os (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,:]) zurückkehren
Verlust- und Optimiererfunktion
Wir werden den Mean Squared Error (MSE) als Verlustfunktion und den AdamW-Optimierer verwenden, um die Modellparameter zu aktualisieren.
Python
Code kopieren
loss_fn = nn.mseloss () Optimierer = torch.optim.adamw (model.parameters (), lr=learning_rate)
Trainingszyklus
Der Trainingszyklus ist das Herzstück des Optimierungsprozesses. In jeder Epoche werden wir die Prognosen und den Verlust berechnen und die Modellparameter aktualisieren
.
Python
Code kopieren
Zeit aus TQDM importieren TQDM-Importmathematik aus sklearn.metrics importmean_squared_error start = time.time () für Epoche in TQDM (range (num_epochs)): model.train () total_train_loss = 0.0 all_train_targets, all_train_outputs = [], [] für Eingaben, Ziele in train_dataloader: optimizer.zero_grad () Ausgänge = Modell (Eingaben) Verlust = 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 = [], [] für Eingaben, Ziele intest_dataloader: mit 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.dets.extend () ach () .numpy ()) durchschnittliche_epoche_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 (alle_train_targets, alle_train_outputs)) test_rmse = math_math_math_.sqrt (mean_squared_error (all_) test_targets, all_test_ outputs)) print (f“ Epoch [{epoch + 1}/{num_epochs}], Zugverlust: {average_epoch_train_loss: .4f}, Testverlust: {average_epoch_test_loss: .4f}, Zug RMSE: {train_rmse: .4f}, RMSE-Test: {test_rmse: .4f}“) Dauer = time.time () — Start
Letzte Gedanken
Wir haben die Verwendung von LSTM und GRU zur Vorhersage von Kryptowährungspreisen eingeführt, wobei ein methodischer und detaillierter Ansatz verwendet wurde. Denken Sie daran, dass die Qualität des Modells von der Rechenleistung und der Auswahl der Hyperparameter abhängt. Experimentieren Sie weiter mit verschiedenen Modellen und Techniken, um Ihre Prognosen zu verbessern
.
