simple_btc_preditor.py

# rodar: python3 main.py
# esse código usa o modelo LSTM para prever o preço do Bitcoin
# épocas: 50, janela: 60, batch_size: 32, units: 50, dropout: 0.2
# o modelo foi treinado com dados históricos do Bitcoin de 2012-10-10 até 2021-10-10

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
import yfinance as yf
import matplotlib.pyplot as plt

def obter_dados_bitcoin(inicio='2020-01-01'):
    """
    Obtém dados históricos do Bitcoin usando yfinance
    """
    btc = yf.download('BTC-USD', start=inicio)
    return btc[['Close']]

def preparar_dados(df, janela=60):
    """
    Prepara os dados para o modelo LSTM
    """
    # Normalização dos dados
    scaler = MinMaxScaler()
    dados_scaled = scaler.fit_transform(df)
    
    X, y = [], []
    for i in range(janela, len(dados_scaled)):
        X.append(dados_scaled[i-janela:i, 0])
        y.append(dados_scaled[i, 0])
    
    X, y = np.array(X), np.array(y)
    X = np.reshape(X, (X.shape[0], X.shape[1], 1))
    
    return X, y, scaler

def criar_modelo(janela):
    """
    Cria um modelo LSTM
    """
    modelo = Sequential([
        LSTM(units=50, return_sequences=True, input_shape=(janela, 1)),
        Dropout(0.2),
        LSTM(units=50),
        Dropout(0.2),
        Dense(1)
    ])
    
    modelo.compile(optimizer='adam', loss='mse')
    return modelo

def treinar_preditor_bitcoin():
    """
    Função principal para treinar o preditor
    """
    # Obtém dados históricos
    df = obter_dados_bitcoin('2012-10-10')
    
    # Prepara os dados
    X, y, scaler = preparar_dados(df)
    
    # Divide em treino e teste
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # Cria e treina o modelo
    modelo = criar_modelo(janela=60)
    historico = modelo.fit(
        X_train, y_train,
        epochs=50,
        batch_size=32,
        validation_split=0.1,
        verbose=1
    )
    
    # Faz previsões
    previsoes = modelo.predict(X_test)
    
    # Desnormaliza as previsões
    previsoes = scaler.inverse_transform(previsoes)
    y_test_real = scaler.inverse_transform([y_test])
    
    # Calcula métricas
    mse = mean_squared_error(y_test_real.T, previsoes)
    mae = mean_absolute_error(y_test_real.T, previsoes)
    
    return modelo, historico, mse, mae, scaler

def fazer_previsao(modelo, dados_recentes, scaler):
    """
    Faz previsão para o próximo preço
    """
    dados_scaled = scaler.transform(dados_recentes)
    X = np.reshape(dados_scaled, (1, dados_scaled.shape[0], 1))
    previsao = modelo.predict(X)
    return scaler.inverse_transform(previsao)[0][0]

# Treina o modelo
modelo, historico, mse, mae, scaler = treinar_preditor_bitcoin()

# Obtém dados recentes para fazer uma previsão
dados_recentes = obter_dados_bitcoin().tail(60) # tail(60) pega os últimos 60 dias de dados históricos do Bitcoin (ou seja, os últimos 60 preços de fechamento)
proxima_previsao = fazer_previsao(modelo, dados_recentes, scaler)
print(f"Previsão do próximo preço: ${proxima_previsao:.2f}")

#plota histórico de preços e previsões
X = np.array(dados_recentes)
y_test = np.array([proxima_previsao])
previsoes = modelo.predict(X)
previsoes = scaler.inverse_transform(previsoes)
y_test_real = scaler.inverse_transform([y_test])

plt.figure(figsize=(14, 7))
plt.plot(y_test_real.T, label='Preço Real')
plt.plot(previsoes, label='Previsão')
plt.legend()
plt.show()