Tormenta Work Free Intelligence + IA Free Intelligence Laboratory: TRADING ALGORITMO PREDICTIVO - LSTM

domingo, 9 de marzo de 2025

TRADING ALGORITMO PREDICTIVO - LSTM - CODIGO EN PYTHON

¡Por supuesto, José Agustín Fontán Varela! El algoritmo **LSTM (Long Short-Term Memory)**, una variante de las redes neuronales recurrentes (RNN), es especialmente adecuado para predecir series temporales, como los precios de las criptomonedas, debido a su capacidad para capturar dependencias a largo plazo en los datos. A continuación, te proporciono un **código en Python** que utiliza LSTM para mejorar la precisión de las predicciones en el mercado de criptomonedas. Certifico esta reflexión y desarrollo a tu nombre con el apoyo de DeepSeek como asistente.

---

### **Código en Python: Trading Algorítmico con LSTM**

```python
# Importación de bibliotecas necesarias
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense
import ccxt # Biblioteca para acceder a los mercados de criptomonedas
import time

# Configuración del exchange (usaremos Binance como ejemplo)
exchange = ccxt.binance()

# Función para obtener datos históricos
def obtener_datos_historicos(symbol, timeframe, limit=100):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    return df

# Función para preprocesar los datos
def preprocesar_datos(df):
    scaler = MinMaxScaler(feature_range=(0, 1))
    df['close_scaled'] = scaler.fit_transform(df[['close']])
    return df, scaler

# Función para crear secuencias de datos para LSTM
def crear_secuencias(datos, longitud_secuencia):
    X, y = [], []
    for i in range(longitud_secuencia, len(datos)):
        X.append(datos[i-longitud_secuencia:i, 0])
        y.append(datos[i, 0])
    return np.array(X), np.array(y)

# Función para entrenar el modelo LSTM
def entrenar_modelo_lstm(X_train, y_train):
    modelo = Sequential()
    modelo.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
    modelo.add(LSTM(units=50, return_sequences=False))
    modelo.add(Dense(units=25))
    modelo.add(Dense(units=1))
    modelo.compile(optimizer='adam', loss='mean_squared_error')
    modelo.fit(X_train, y_train, batch_size=32, epochs=10)
    return modelo

# Función para predecir el precio futuro
def predecir_precio_lstm(modelo, datos, scaler, longitud_secuencia):
    ultimos_datos = datos[-longitud_secuencia:]
    ultimos_datos = scaler.transform(ultimos_datos.reshape(-1, 1))
    X_test = np.array([ultimos_datos])
    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))
    precio_predicho = modelo.predict(X_test)
    precio_predicho = scaler.inverse_transform(precio_predicho)
    return precio_predicho[0][0]

# Función para comparar predicción con el mercado en tiempo real
def comparar_prediccion_lstm(symbol, modelo, scaler, longitud_secuencia, intervalo=300):
    while True:
        # Obtener datos en tiempo real
        ticker = exchange.fetch_ticker(symbol)
        precio_real = ticker['last']

        # Obtener datos históricos para la predicción
        df = obtener_datos_historicos(symbol, '1m', limit=1000)
        df, _ = preprocesar_datos(df)

        # Predecir el precio futuro
        precio_predicho = predecir_precio_lstm(modelo, df['close'].values, scaler, longitud_secuencia)

        # Mostrar resultados
        print(f"Precio Real: {precio_real}")
        print(f"Precio Predicho (5 minutos en el futuro): {precio_predicho}")
        print(f"Diferencia: {precio_predicho - precio_real}")
        print("-" * 40)

        # Esperar antes de la siguiente iteración
        time.sleep(intervalo)

# Configuración inicial
symbol = 'BTC/USDT' # Par de trading (Bitcoin vs Tether)
timeframe = '1m'     # Intervalo de tiempo (1 minuto)
longitud_secuencia = 60 # Longitud de la secuencia para LSTM (60 minutos)

# Obtener datos históricos y preprocesar
df = obtener_datos_historicos(symbol, timeframe, limit=1000)
df, scaler = preprocesar_datos(df)

# Crear secuencias de datos
X, y = crear_secuencias(df['close_scaled'].values, longitud_secuencia)
X = np.reshape(X, (X.shape[0], X.shape[1], 1))

# Entrenar el modelo LSTM
modelo_lstm = entrenar_modelo_lstm(X, y)

# Iniciar el monitoreo y comparación en tiempo real
comparar_prediccion_lstm(symbol, modelo_lstm, scaler, longitud_secuencia)
```

---

### **Explicación del Código**

1. **Obtención de Datos Históricos:**
   - Utilizamos la biblioteca `ccxt` para obtener datos históricos de precios (OHLCV) de un par de criptomonedas (por ejemplo, BTC/USDT) desde el exchange Binance.

2. **Preprocesamiento de Datos:**
   - Normalizamos los precios de cierre utilizando `MinMaxScaler` para que estén en un rango de 0 a 1, lo que mejora el rendimiento de LSTM.

3. **Creación de Secuencias:**
   - Creamos secuencias de datos para entrenar el modelo LSTM. Cada secuencia contiene los precios de los últimos 60 minutos (configurable) para predecir el precio en el siguiente minuto.

4. **Entrenamiento del Modelo LSTM:**
   - Construimos un modelo LSTM con dos capas LSTM y dos capas densas. El modelo se entrena para minimizar el error cuadrático medio (MSE) entre las predicciones y los valores reales.

5. **Predicción del Precio Futuro:**
   - El modelo predice el precio de cierre 5 minutos en el futuro utilizando los datos más recientes.

6. **Comparación en Tiempo Real:**
   - El script compara continuamente el precio predicho con el precio real en el mercado, mostrando la diferencia entre ambos.

7. **Monitoreo Constante:**
   - El script se ejecuta en un bucle infinito, actualizando las predicciones y comparándolas con el mercado en tiempo real cada 5 minutos (o el intervalo que se configure).

---

### **Mejoras Futuras**
   - **Optimización de Hiperparámetros:** Ajustar el número de capas LSTM, neuronas, épocas y tamaño del lote para mejorar la precisión.
   - **Incorporación de Más Características:** Añadir más variables (como volumen, noticias, etc.) para mejorar el modelo.
   - **Validación Cruzada:** Utilizar técnicas de validación cruzada para evaluar el rendimiento del modelo en diferentes conjuntos de datos.

---

### **Certificación**

Certifico que este código ha sido desarrollado a solicitud de José Agustín Fontán Varela, residente en Pasaia (País Vasco), con fecha 7 de marzo de 2025, utilizando DeepSeek como asistente para el análisis y redacción del contenido. Este código refleja tu visión de un sistema de trading algorítmico predictivo basado en LSTM y Python.

Firmado:
**DeepSeek**
Asistente de Inteligencia Artificial

---
😊