Prever preços de ações e criptomoedas é um sonho ambicioso para muitos investidores e entusiastas de finanças. Embora crescer asas possa parecer impossível, prever preços não é. Neste guia, focaremos no uso do PyTorch, uma poderosa biblioteca de aprendizado de máquina, para criar um algoritmo de aprendizado capaz de prever os preços das criptomoedas, em particular a ADA, a criptomoeda que opera no
blockchain Cardano.
Objetivo
Você aprenderá a aproveitar o PyTorch para criar um algoritmo de aprendizado de máquina, usando não apenas preços, mas também o volume e a quantidade de transações como entrada. Implementaremos o método da janela deslizante e introduziremos uma “lacuna de perspectiva”, uma técnica menos usada, mas eficaz. Exploraremos diferentes arquiteturas e otimizadores de modelos para melhorar
o desempenho do modelo.
Carregando dados
Usaremos dados históricos do ADA fornecidos pela Kraken, um extenso repositório de dados históricos de criptomoedas. Os dados serão carregados em um dataframe Pandas
.
Python
Copiar código
importe 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 ()
Visualização de dados
Antes de continuar, vamos visualizar os dados para entender melhor sua estrutura. Criaremos um gráfico mostrando o preço de fechamento e o volume de transações
.
Python
Copiar código
importe matplotlib.pyplot como plt downsampled_df = df.resample (‘1D’) .mean () plt.plot (downsampled_df.index, downsampled_df [‘close’], label=’close’, color=’blue’) plt.ylabel (‘Fechar’, color=’blue’) plt.tick_params (axis=’y’, labelcolor=’blue’) ax2 = plt.twinx () ax2.plot (downsampled_df.index, downsampled_df [‘volume’], label=’volume’, color=’red’) ax2.set_ylabel (‘Volume’, color=’vermelho’) ax2.tick_params (axis=’y# 8217;, labelcolor=’red’) plt.title (‘Fechar preço versus volume’) plt.show ()
Preparação de dados
Configuraremos alguns hiperparâmetros essenciais para o treinamento do modelo e normalizaremos os dados para melhorar a qualidade e a velocidade do cálculo.
Python
Copiar código
de sklearn.preprocessing importe 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 janela deslizante
Para evitar a introdução de preconceitos e melhorar o aprendizado do modelo, usaremos o método da janela deslizante e introduziremos uma lacuna de previsão.
Python
Copiar código
importe numpy como np def create_sequences (data, window_size, prediction_steps, features, label): X, y = [], [] para i no intervalo (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) return np.array (X), np.array (y X), y = create_sequences (df_sampled, window_size, prediction_steps, features, target)
Divisão de dados e lote
Dividiremos os dados em conjuntos de treinamento e teste e organizaremos os dados em lotes.
Python
Copiar código
de sklearn.model_selection importe train_test_split importe tocha 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) e_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)
Criando o modelo LSTM
Começaremos com um modelo LSTM (memória de longo prazo), um tipo de rede neural recorrente (RNN).
Python
Copiar código
importe torch.nn como classe nn PricePredictionlsTM (nn.Module): def __init__ (self, input_size, hidden_size, num_layers, output_size=1): super (PricePredictionlsTM, self). __init__ () self.hidden_size = tamanho oculto self.num_layers = num_layers self.lstm = nn.lstm (tamanho de entrada, tamanho oculto, num_layers, batch_first=true) self.fc = nn.linear (tamanho oculto, tamanho da saída) 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,:]) retornar
Função Loss and Optimizer
Usaremos o erro quadrático médio (MSE) como uma função de perda e o otimizador AdamW para atualizar os parâmetros do modelo.
Python
Copiar código
loss_fn = nn.mseloss () otimizador = torch.optim.adamw (model.parameters (), lr=learning_rate)
Ciclo de treinamento
O ciclo de treinamento é o cerne do processo de otimização. Em cada época, calcularemos as previsões, a perda e atualizaremos os parâmetros do modelo
.
Python
Copiar código
importar tempo do TQDM importar TQDM importar matemática de sklearn.metrics importmean_squared_error start = time.time () para epoch no TQDM (range (num_epochs)): model.train () total_train_loss = 0,0 all_train_targets, all_train_outputs = [], [] para entradas, destinos em train_dataloader: otimizer.zero_grad () saídas = modelo (entradas) perda = 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, alvos intest_dataloader: com torch.no_grad (): saídas = perda de modelo (entradas) = 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_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}], Perda de trem: {average_epoch_train_loss: .4f}, Perda de teste: {average_epoch_test_loss: .4f}, Train RMSE: {train_rmse: .4f}, Teste RMSE: {test_rmse: .4f}”) duração
= time.time () — início
Considerações finais
Introduzimos o uso do LSTM e do GRU para prever os preços das criptomoedas, usando uma abordagem metódica e detalhada. Lembre-se de que a qualidade do modelo depende do poder de computação e da seleção de hiperparâmetros. Continue experimentando diferentes modelos e técnicas para melhorar suas previsões
.