Proyecto Integrador Final: Sistema de Trading Autónomo con Actor-Critic

Objetivo del Proyecto

Desarrollar un sistema completo de trading algorítmico utilizando el algoritmo Actor-Critic (A2C) con datos del mercado bursátil. Este proyecto integrador aplica los conceptos de aprendizaje por refuerzo profundo para tomar decisiones de compra, venta o mantenimiento de activos financieros, optimizando una función de recompensa que considera tanto el retorno ajustado por riesgo como los costos de transacción.

Componentes Clave del Sistema

• Definición del Estado: Precios históricos (OHLCV), indicadores técnicos como SMA (Media Móvil Simple) y RSI (Índice de Fuerza Relativa).
• Acciones del Agente: Comprar (Buy), Vender (Sell), Mantener (Hold).
• Recompensa: Retorno ajustado por riesgo (Ratio de Sharpe) penalizado por costos de transacción.
• Arquitectura de Red: Actor (política) y Crítico (valor) con redes neuronales densas.

Implementación Paso a Paso

1. Entorno de Trading Personalizado

Se crea un entorno TradingEnv que simula el mercado bursátil. El estado incluye una ventana de 10 períodos de precios históricos y valores de SMA (20 días) y RSI (14 días). Las acciones se codifican como 0 (Hold), 1 (Buy), 2 (Sell).

class TradingEnv(gym.Env):
    def __init__(self, data, window_size=10, transaction_cost=0.001):
        super().__init__()
        self.data = data
        self.window_size = window_size
        self.transaction_cost = transaction_cost
        self.action_space = spaces.Discrete(3)
        self.observation_space = spaces.Box(low=-np.inf, high=np.inf, shape=(window_size + 2,))
        self.reset()

2. Algoritmo Actor-Critic (A2C)

Se implementa una red neuronal con dos cabezas: el Actor selecciona acciones y el Crítico estima el valor del estado. El entrenamiento usa el método de gradiente de política con ventaja.

class ActorCritic(torch.nn.Module):
    def __init__(self, n_features, n_actions, hidden_size=128):
        super().__init__()
        self.shared = torch.nn.Sequential(
            torch.nn.Linear(n_features, hidden_size),
            torch.nn.ReLU()
        )
        self.actor = torch.nn.Linear(hidden_size, n_actions)
        self.critic = torch.nn.Linear(hidden_size, 1)
    
    def forward(self, x):
        features = self.shared(x)
        probs = torch.softmax(self.actor(features), dim=-1)
        value = self.critic(features)
        return probs, value

3. Sintonización de Hiperparámetros con GridSearch

Se exploran combinaciones de tasa de aprendizaje, tamaño de lote, y factor de descuento (gamma) para optimizar el rendimiento. A continuación, un ejemplo de búsqueda en cuadrícula:

Entrenamiento y Validación

Se entrena el modelo con datos históricos del S&P 500 desde 2010 hasta 2020. El entrenamiento se realiza durante 1000 episodios, con evaluación periódica cada 100 episodios. Se utiliza un conjunto de validación fuera de muestra (2021-2022) para medir la capacidad de generalización.

Evaluación del Rendimiento

• Rendimiento Total: Retorno acumulado durante el período de prueba.
• Ratio de Sharpe: Medida de retorno ajustado por riesgo (debe superar 1.0 para ser aceptable).
• Drawdown Máximo: Máxima caída desde un pico histórico (se busca minimizar).
• Comparativa con Baseline: Se compara contra la estrategia Buy-and-Hold (comprar y mantener).

Visualización de Decisiones en Gráfico de Precios

Se genera un gráfico interactivo donde se superponen las señales de compra (triángulos verdes) y venta (triángulos rojos) sobre la curva de precios. A continuación, un ejemplo estático de cómo se vería (en la práctica se genera con Plotly o Matplotlib):

import matplotlib.pyplot as plt

plt.figure(figsize=(14,7))
plt.plot(data.index, data['Close'], label='Precio de Cierre', color='blue')
plt.scatter(buy_signals.index, buy_signals['Close'], marker='^', color='green', s=100, label='Señal de Compra')
plt.scatter(sell_signals.index, sell_signals['Close'], marker='v', color='red', s=100, label='Señal de Venta')
plt.title('Decisiones de Trading del Agente Actor-Critic')
plt.xlabel('Fecha')
plt.ylabel('Precio ($)')
plt.legend()
plt.grid(alpha=0.3)

Entrega: Pipeline Completo en Jupyter Notebook

El proyecto final se presenta en un notebook Jupyter que contiene:

• Celdas de código con la implementación completa del entorno y el agente.
• Documentación en celdas Markdown explicando cada paso.
• Gráficos de evolución del rendimiento durante el entrenamiento.
• Tabla resumen de métricas comparativas.
• Conclusiones y análisis crítico del desempeño.

Resultados Esperados

Al completar este proyecto, el estudiante habrá demostrado la capacidad de:

• Diseñar un entorno de aprendizaje por refuerzo para finanzas cuantitativas.
• Implementar correctamente el algoritmo Actor-Critic.
• Sintonizar hiperparámetros de manera sistemática.
• Evaluar el rendimiento de un agente de trading con métricas financieras estándar.
• Visualizar e interpretar las decisiones del modelo.