Quiz: Evaluación de estrategias cuantitativas

Concepto clave

La evaluación de estrategias cuantitativas es el proceso sistemático de medir el rendimiento de un algoritmo de trading mediante métricas estadísticas y financieras. Imagina que eres un ingeniero probando un nuevo motor: no solo verificas si funciona, sino que mides su eficiencia, consumo y durabilidad bajo diferentes condiciones. En trading algorítmico, esto se traduce en analizar no solo las ganancias, sino el riesgo, la consistencia y la adaptabilidad del modelo a distintos escenarios de mercado.

El backtesting es la piedra angular de esta evaluación, donde simulamos la estrategia con datos históricos. Sin embargo, un error común es confundir un buen backtest con una estrategia rentable en tiempo real. La clave está en entender que los datos históricos tienen sesgos como el look-ahead bias (usar información futura) y el overfitting (ajustar demasiado el modelo a datos pasados). Una evaluación robusta requiere validación cruzada, pruebas de estrés y métricas como el Sharpe Ratio y el Maximum Drawdown.

Cómo funciona en la práctica

Vamos a evaluar una estrategia simple de cruce de medias móviles para BTC/USDT en Binance. Paso a paso:

1. Definir la estrategia: Comprar cuando la media móvil de 50 periodos cruza por encima de la de 200, vender cuando cruza por debajo.
2. Recopilar datos: Obtener datos históricos de velas de 1 hora para los últimos 2 años usando la Binance API.
3. Simular operaciones: Aplicar la lógica de la estrategia a los datos, registrando cada entrada y salida con precios y timestamps.
4. Calcular métricas: Usar Python para calcular retorno total, Sharpe Ratio, máxima pérdida consecutiva (Max Drawdown), y ratio de operaciones ganadoras.
5. Validar: Dividir los datos en conjunto de entrenamiento y prueba, y probar la estrategia en períodos de alta volatilidad para ver su resiliencia.

Código en acción

Antes: Un código básico que solo calcula el retorno total sin considerar riesgos.

import pandas as pd
import numpy as np

# Datos de ejemplo (simplificado)
data = pd.read_csv('btc_data.csv')
data['MA50'] = data['close'].rolling(window=50).mean()
data['MA200'] = data['close'].rolling(window=200).mean()

data['signal'] = np.where(data['MA50'] > data['MA200'], 1, -1)
data['returns'] = data['signal'].shift(1) * data['close'].pct_change()
total_return = data['returns'].sum()
print(f"Retorno total: {total_return:.2%}")

Después: Un código mejorado que incluye métricas clave y evita look-ahead bias.

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Cargar datos con timestamps reales
data = pd.read_csv('btc_hourly.csv', parse_dates=['timestamp'])
data.set_index('timestamp', inplace=True)

# Calcular medias móviles sin usar datos futuros
data['MA50'] = data['close'].rolling(window=50, min_periods=50).mean()
data['MA200'] = data['close'].rolling(window=200, min_periods=200).mean()

# Generar señales con shift para evitar bias
data['signal'] = 0
data.loc[data['MA50'] > data['MA200'], 'signal'] = 1
data.loc[data['MA50'] <= data['MA200'], 'signal'] = -1
data['position'] = data['signal'].shift(1)  # Operar al siguiente periodo

# Calcular retornos y métricas
data['returns'] = data['position'] * data['close'].pct_change()
total_return = data['returns'].sum()
sharpe_ratio = data['returns'].mean() / data['returns'].std() * np.sqrt(365*24)  # Anualizado
max_drawdown = (data['close'].cummax() - data['close']).max() / data['close'].cummax().max()

print(f"Retorno total: {total_return:.2%}")
print(f"Sharpe Ratio: {sharpe_ratio:.2f}")
print(f"Máximo Drawdown: {max_drawdown:.2%}")

Errores comunes

• Overfitting: Ajustar parámetros para maximizar el backtest sin validar en datos nuevos. Solución: Usar train-test split y validación cruzada temporal.
• Ignorar costos de transacción: No incluir comisiones de Binance en la simulación. Solución: Restar un porcentaje fijo (ej. 0.1%) por cada operación.
• Look-ahead bias: Usar datos futuros para tomar decisiones, como calcular medias con ventanas que incluyen precios posteriores. Solución: Asegurar que cada cálculo solo use datos disponibles hasta ese momento.
• No probar en diferentes condiciones de mercado: Evaluar solo en tendencias alcistas. Solución: Incluir períodos de alta volatilidad y crisis en el backtest.
• Confiar en métricas aisladas: Basarse solo en el retorno total sin considerar riesgo. Solución: Usar múltiples métricas como Sharpe, Calmar Ratio y win rate.

Checklist de dominio

1. Puedo implementar un backtesting desde cero usando datos reales de Binance API.
2. Sé calcular al menos 5 métricas de rendimiento y riesgo (ej. Sharpe, Max Drawdown, Sortino Ratio).
3. He validado una estrategia con train-test split y pruebas de estrés.
4. Puedo identificar y corregir look-ahead bias en mi código.
5. He optimizado parámetros sin caer en overfitting usando técnicas como walk-forward analysis.
6. Sé integrar costos de transacción y slippage en mis simulaciones.
7. Puedo documentar los resultados de evaluación en un reporte ejecutivo.

Evaluación de una estrategia de momentum con Binance API

Implementa y evalúa una estrategia de trading cuantitativa basada en momentum para el par ETH/USDT usando datos reales de Binance. Sigue estos pasos:

1. Obtén datos: Usa la Binance API para descargar velas de 4 horas (intervalo '4h') de ETH/USDT de los últimos 6 meses. Guarda los datos en un DataFrame de pandas con columnas: timestamp, open, high, low, close, volume.
2. Define la estrategia: Compra cuando el precio de cierre actual esté al menos un 5% por encima del cierre de hace 10 períodos (40 horas). Vende cuando caiga por debajo de ese umbral. Usa un stop-loss del 2% desde el precio de entrada.
3. Simula operaciones: Implementa la lógica en Python, registrando cada operación con timestamp, precio de entrada, precio de salida, y resultado. Asegúrate de evitar look-ahead bias usando .shift() apropiadamente.
4. Calcula métricas: Determina el retorno total, Sharpe Ratio anualizado, máximo drawdown, y win rate (porcentaje de operaciones ganadoras). Incluye una comisión del 0.1% por operación simulando los costos de Binance.
5. Analiza resultados: Genera un gráfico de equity curve (valor de la cuenta en el tiempo) y un reporte breve con conclusiones sobre la viabilidad de la estrategia.

• Usa la librería python-binance para facilitar la descarga de datos. Recuerda manejar los timestamps correctamente para evitar gaps.
• Para el stop-loss, puedes implementarlo verificando si el precio mínimo durante la posición cae un 2% desde la entrada. Considera usar un bucle o vectorización con .rolling().
• Al calcular el Sharpe Ratio, anualiza considerando que hay 6 velas de 4h por día (24/4). La fórmula es: (retorno medio / desviación estándar) * sqrt(número de períodos por año).

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.