Predecir los precios de las acciones y las criptomonedas es un sueño ambicioso para muchos inversores y entusiastas de las finanzas. Si bien hacer crecer las alas puede parecer imposible, predecir los precios no lo es. En esta guía, nos centraremos en el uso de PyTorch, una potente biblioteca de aprendizaje automático, para crear un algoritmo de aprendizaje capaz de predecir los precios de las criptomonedas, en particular de ADA, la criptomoneda que opera en la cadena
de bloques de Cardano.
Índice de contenido:
Objetivo
Aprenderá a aprovechar PyTorch para crear un algoritmo de aprendizaje automático, utilizando no solo los precios, sino también el volumen y los montos de las transacciones como entrada. Implementaremos el método de ventana deslizante e introduciremos una «brecha de perspectiva», una técnica menos utilizada pero efectiva.
Exploraremos diferentes arquitecturas de modelos y optimizadores
para mejorar el rendimiento de los modelos.
Cargando datos
Utilizaremos los datos históricos de la ADA proporcionados por Kraken, un extenso repositorio de datos históricos sobre criptomonedas. Los datos se cargarán en un marco de datos de Pandas
.
Python
Copiar código
importa pandas como pd 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 ()
Visualización de datos
Antes de continuar, visualicemos los datos para entender mejor su estructura.
Crearemos un gráfico que muestre el precio de cierre y el volumen de las transacciones
.
Python
Copiar código
importar matplotlib.pyplot como plt downsampled_df = df.resample (‘1D’) .mean () plt.plot (downsampled_df.index, downsampled_df [‘close’], label=’ close ‘, color=’blue’) plt.ylabel (‘ Close ‘, color=’blue’) plt.tick_params (axis=’blue’)’, labelcolor=’blue’) ax2 = plt.twinx () ax2.plot (downsampled_df.index, downsampled_df [‘volumen’], label=’ Volumen ‘, color=’ rojo’) ax2.set_ylabel (‘Volumen’, color=’ rojo ‘) ax2.tick_params (axis=’y# 8217;, label’ color=’red’) plt.title (‘Precio de cierre frente a volumen’) plt.show ()
Preparación de datos
Estableceremos algunos hiperparámetros esenciales para el entrenamiento de modelos y normalizaremos los datos para mejorar la calidad y la velocidad del cálculo.
Python
Copiar código
from 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
Método de ventana corredera
Para evitar la introducción de sesgos y mejorar el aprendizaje de los modelos, utilizaremos el método de ventana deslizante e introduciremos una brecha de predicción.
Python
Copiar código
importar numpy como np def create_sequence (data, window_size, prediction_steps, features, label): X, y = [], [] para i en el rango (len (data) — window_size — prediction_steps + 1): sequence = data.iloc [i:i + window_size] [features] target = data.iloc [i + window_size + prediction_size] steps — 1] [label] x.append (secuencia) y.append (target) devuelve np.array (X), np.array (y X), y = create_sequence (df_sampled, window_size, prediction_steps, features, target)
División de datos y lotes
Dividiremos los datos en conjuntos de entrenamiento y pruebas, y organizaremos los datos en lotes.
Python
Copiar código
desde sklearn.model_selection importar train_test_split importar antorch fromtorch.utils.data importar 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 = .Tensor (y_train) x_test_tensor = torch.Tensor (x_test) y_test_tensor = torch.Tensor (x_test) y_test_tensor = torch.Tensor (x_test) y_test_tensor = torch.Tensor (y_test) train_dataset = TensorDataset (x_train_tensor, y_train_tensor, y_train_tensor (_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)
Creando el modelo LSTM
Empezaremos con un modelo LSTM (memoria a largo plazo), un tipo de red neuronal recurrente (RNN).
Python
Copiar código
importe torch.nn como clase 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,:]) volver
Función de pérdida y optimización
Usaremos el error cuadrático medio (MSE) como función de pérdida y el optimizador AdamW para actualizar los parámetros del modelo.
Python
Copiar código
loss_fn = nn.mseloss () optimizer = torch.optim.adamw (model.parameters (), lr=learning_rate)
Ciclo formativo
El ciclo de formación es el corazón del proceso de optimización. En cada época, calcularemos las previsiones, la pérdida y actualizaremos los parámetros del modelo
.
Python
Copiar código
importar tiempo desde TQDM importar TQDM importar matemáticas desde sklearn.metrics importmean_squared_error start = time.time () for epoch in TQDM (range (num_epochs)): model.train () total_train_loss = 0.0 all_train_targets, all_train_outputs = [], [] para entradas, objetivos en 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 = [], [] para entradas, destinos intest_dataloader: con 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 (todos_ test_targets, all_test_ outputs) print (f» Epoch [{epoch + 1}/{num_epochs}], Pérdida de tren: {average_epoch_train_loss: .4f}, Pérdida de prueba: {average_epoch_test_loss: .4f}, Tren RMSE: {train_rmse: .4f}, Prueba RMSE: {test_rmse: .4f}») duración = time.time () — inicio
Reflexiones finales
Introdujimos el uso de LSTM y GRU para predecir los precios de las criptomonedas, utilizando un enfoque metódico y detallado. Recuerde que la calidad del modelo depende de la potencia de cálculo y de la selección de los hiperparámetros. Siga experimentando con diferentes modelos y técnicas para mejorar sus
pronósticos.
