in

Como prever preços de ações ou criptomoedas em 2024 com Python e PyTorch

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
.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

trust wallet

Guia para converter USDT TRC-20 em USDT BEP-20 na Trust Wallet

img 0003

Guia do contrato transitório de locação para estudantes