Práctica: Optimizar parámetros de estrategia con grid search

Concepto clave

La optimizacion de parametros mediante grid search es una tecnica sistematica para encontrar la combinacion de valores que maximiza el rendimiento de una estrategia de trading. Imagina que estas afinando un motor de coche de carreras: tienes multiples ajustes (avance de encendido, relacion aire-combustible, presion de turbo) y debes probar diferentes combinaciones para encontrar la que da la mejor potencia sin dañar el motor. En trading, los parametros podrian ser periodos de medias moviles, niveles de stop-loss, o factores de riesgo.

El grid search prueba exhaustivamente todas las combinaciones posibles dentro de un rango predefinido, a diferencia de metodos aleatorios o heuristicos. Esto es crucial en desarrollo cuantitativo porque te permite validar la robustez de tu estrategia antes de arriesgar capital real. Sin embargo, requiere un equilibrio entre precision y costo computacional: un grid demasiado fino puede llevar horas de backtesting, mientras que uno muy grueso podria pasar por alto optimos locales.

Como funciona en la practica

Vamos a optimizar una estrategia basica de cruce de medias moviles para BTC/USDT en Binance. Los parametros a optimizar son: periodo de media corta (SMA corta) y periodo de media larga (SMA larga). Asumiremos que ya tienes un sistema de backtesting funcional que calcula señales y metricas como el Sharpe Ratio.

1. Define el espacio de busqueda: SMA corta entre 10 y 50 periodos, SMA larga entre 50 y 200 periodos, con incrementos de 5.
2. Configura un bucle anidado que pruebe cada combinacion (ej: 10-50, 10-55, ..., 50-200).
3. Para cada combinacion, ejecuta el backtesting completo sobre datos historicos (ej: ultimos 2 años).
4. Registra la metrica objetivo (ej: Sharpe Ratio) para cada ejecucion.
5. Identifica la combinacion con el mejor resultado y analiza su estabilidad en diferentes condiciones de mercado.

Este proceso genera una matriz de resultados que puedes visualizar como un mapa de calor, mostrando claramente las regiones de parametros mas rentables.

Codigo en accion

A continuacion, un ejemplo funcional usando Python y pandas. Asume que tienes una funcion backtest_strategy(data, short_period, long_period) que devuelve el Sharpe Ratio.

import pandas as pd
import numpy as np
from itertools import product

# Datos historicos de BTC/USDT (ejemplo simplificado)
data = pd.read_csv('btc_usdt_1h.csv', index_col=0, parse_dates=True)

# Definir rangos de parametros
short_range = range(10, 51, 5)  # 10, 15, ..., 50
long_range = range(50, 201, 10)  # 50, 60, ..., 200

# Grid search
results = []
for short, long in product(short_range, long_range):
    if short >= long:
        continue  # Evitar combinaciones invalidas
    sharpe = backtest_strategy(data, short, long)
    results.append({
        'short_period': short,
        'long_period': long,
        'sharpe_ratio': sharpe
    })

# Convertir a DataFrame y encontrar el optimo
results_df = pd.DataFrame(results)
best_result = results_df.loc[results_df['sharpe_ratio'].idxmax()]
print(f"Mejor combinacion: SMA corta={best_result['short_period']}, SMA larga={best_result['long_period']}")
print(f"Sharpe Ratio: {best_result['sharpe_ratio']:.2f}")

Ahora, mejoremos el codigo para paralelizar y manejar errores, algo esencial en entornos de produccion:

from concurrent.futures import ProcessPoolExecutor
import warnings
warnings.filterwarnings('ignore')

def optimize_parallel(data, short_range, long_range):
    """Version paralelizada del grid search"""
    tasks = [(short, long) for short in short_range for long in long_range if short < long]
    
    with ProcessPoolExecutor(max_workers=4) as executor:
        futures = [executor.submit(backtest_strategy, data, short, long) for short, long in tasks]
        results = []
        for (short, long), future in zip(tasks, futures):
            try:
                sharpe = future.result()
                results.append((short, long, sharpe))
            except Exception as e:
                print(f"Error con {short},{long}: {e}")
    
    return pd.DataFrame(results, columns=['short_period', 'long_period', 'sharpe_ratio'])

# Uso
results_df = optimize_parallel(data, short_range, long_range)
best = results_df.nlargest(3, 'sharpe_ratio')  # Top 3 resultados
print(best)

Errores comunes

• Sobreoptimizacion (curve fitting): Usar demasiados parametros o rangos muy estrechos puede hacer que la estrategia funcione solo en datos historicos. Solucion: Limita a 2-3 parametros clave y usa out-of-sample testing.
• Ignorar costos de transaccion: Optimizar sin incluir fees de Binance da metricas irreales. Solucion: Incorpora un costo fijo por trade (ej: 0.1%) en tu backtesting.
• Falta de validacion cruzada: Probar solo en un periodo historico especifico. Solucion: Divide los datos en multiples ventanas temporales (ej: walk-forward analysis).
• Paralelizacion ineficiente: Lanzar demasiados procesos puede saturar la memoria. Solucion: Usa max_workers basado en los nucleos de tu CPU y monitoriza el uso de RAM.
• No considerar el drawdown Enfocarse solo en rentabilidad sin mirar riesgo. Solucion: Optimiza con una metrica compuesta como Calmar Ratio (return/max drawdown).

Checklist de dominio

1. He definido claramente los parametros a optimizar y sus rangos razonables basados en teoria de mercado.
2. Mi implementacion de grid search es eficiente, evitando combinaciones redundantes o invalidas.
3. He incorporado costos de transaccion y slippage en el calculo de metricas.
4. Utilizo validacion cruzada para asegurar que los parametros optimos no esten sobreajustados.
5. He paralelizado el proceso para reducir tiempos de ejecucion en backtests largos.
6. Analizo no solo la mejor combinacion, sino el top 5 para entender la estabilidad de la estrategia.
7. Documento todos los resultados y parametros para auditoria y reproducibilidad.

Optimiza una estrategia de RSI con grid search en datos de ETH/USDT

En este ejercicio, aplicaras grid search para optimizar una estrategia basada en RSI (Relative Strength Index) usando datos reales de Binance. Sigue estos pasos:

1. Descarga datos historicos de 1 hora para ETH/USDT de los ultimos 6 meses desde Binance (usa python-binance o un CSV).
2. Implementa una funcion de backtesting que compre cuando RSI < 30 y venda cuando RSI > 70, con un stop-loss del 5%.
3. Define dos parametros para optimizar: nivel de sobreventa (entre 20 y 35) y nivel de sobrecompra (entre 65 y 80), con incrementos de 2.
4. Ejecuta un grid search que pruebe todas las combinaciones validas (sobreventa < sobrecompra).
5. Registra el profit factor (ganancias totales/perdidas totales) para cada combinacion.
6. Identifica los 3 mejores conjuntos de parametros y visualizalos en un grafico de dispersion.
7. Prueba la mejor combinacion en un periodo out-of-sample (ultimo mes) para validar robustez.

Entrega un script Python completo con comentarios y un breve informe de resultados.

• Usa la libreria python-binance para descargar datos si no tienes CSV. Ejemplo: from binance.client import Client
• Para el calculo de RSI, puedes usar ta.momentum.RSIIndicator de la libreria ta-lib o implementar tu propia funcion.
• Considera usar matplotlib para graficar los resultados del grid search como un mapa de calor.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.