Markowitz con ML para carteras de inversión: LSTM + CAPM + Optimización

Arquitectura del pipeline

• Obtención de datos: descarga de precios ajustados de cierre con yfinance para 10 acciones desde 2020 a la fecha actual.
• Predicción LSTM: entrenamiento de un modelo por acción con indicadores técnicos como features. Los últimos 30 días son el conjunto de prueba; el modelo predice los precios futuros que se usarán como rendimientos esperados.
• Selección CAPM: cálculo de betas con regresión lineal sobre el S&P 500, aplicación del CAPM y filtrado de acciones cuyo retorno esperado ajustado por riesgo supera el exceso de retorno de mercado.
• Optimización Markowitz: cálculo de la matriz de covarianza, trazado de la Frontera Eficiente y obtención de los pesos óptimos que minimizan la volatilidad del portafolio.

Stack tecnológico

• Python 3.10+ — lenguaje principal
• yfinance — descarga de datos históricos de Yahoo Finance
• TensorFlow / Keras — arquitectura LSTM con capas de Dropout y regularización L2
• scikit-learn — MinMaxScaler, StandardScaler, mean_squared_error
• scipy — optimización numérica con minimize (SLSQP) y regresión lineal (stats.linregress)
• pandas / numpy — manipulación de datos y álgebra matricial
• matplotlib — visualización de precios, curvas de pérdida y Frontera Eficiente

Instalación de dependencias

pip install yfinance tensorflow scikit-learn scipy pandas numpy matplotlib

Descarga de datos con yfinance

import yfinance as yf
import pandas as pd
from datetime import datetime

symbols      = ['AAPL','MSFT','GOOGL','AMZN','TSLA','META','NFLX','NVDA','JPM','JNJ']
fecha_inicial = '2020-01-01'
fecha_final   = datetime.today().strftime('%Y-%m-%d')

# Descargar datos históricos
main_data = yf.download(symbols, start=fecha_inicial, end=fecha_final)

# Extraer precios de cierre ajustados
closing_prices = main_data['Adj Close']

print(f"Período: {fecha_inicial} → {fecha_final}")
print(f"Shape: {closing_prices.shape}")
print(closing_prices.tail(3))

import matplotlib.pyplot as plt

closing_prices.plot(figsize=(12, 6))
plt.title('Precios de Cierre Ajustados — 10 Acciones (2020 a la fecha)')
plt.xlabel('Fecha')
plt.ylabel('Precio de Cierre Ajustado (USD)')
plt.legend(loc='upper left', fontsize=8)
plt.tight_layout()
plt.show()

División de datos e indicadores técnicos

Los datos de entrenamiento incluyen todos los registros excepto los últimos 30 días. Los últimos 30 días forman el conjunto de prueba. Sobre cada serie se calculan cuatro indicadores técnicos que enriquecen las features del modelo:

• SMA de 20 días — suaviza las fluctuaciones e identifica la tendencia general. Un valor alto o bajo puede indicar niveles de soporte o resistencia.
• Bandas de Bollinger (20 días, 2σ) — miden la volatilidad del mercado. Precios que tocan las bandas sugieren condiciones de sobrecompra o sobreventa.
• RSI de 14 días — oscila entre 0 y 100. RSI > 70 indica sobrecompra; RSI < 30 indica sobreventa. Útil para anticipar cambios de tendencia.
• Autocorrelación lag-1 — mide si el precio de hoy está correlacionado con el de ayer. Detecta patrones repetitivos y ciclos.

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler

def calculate_technical_indicators(data, stock_name):
    """Calcula SMA, Bandas de Bollinger, RSI y autocorrelación."""
    data = pd.DataFrame(data.copy())

    # SMA de 20 días
    data['SMA_20'] = data[stock_name].rolling(window=20).mean()

    # Bandas de Bollinger (20 días, desviación estándar de 2)
    rolling_mean = data[stock_name].rolling(window=20).mean()
    rolling_std  = data[stock_name].rolling(window=20).std()
    data['BB_upper'] = rolling_mean + 2 * rolling_std
    data['BB_lower'] = rolling_mean - 2 * rolling_std

    # RSI de 14 días
    delta = data[stock_name].diff()
    gain  = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss  = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    RS    = gain / loss
    data['RSI_14'] = 100 - (100 / (1 + RS))

    # Autocorrelación lag-1 (valor escalar — se usa como referencia)
    autocorr_value = data[stock_name].autocorr()

    return data.dropna()

def preprocess_data(data):
    """Elimina NaNs y normaliza con MinMaxScaler al rango [0, 1]."""
    data.dropna(inplace=True)
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(data)
    return scaled_data, scaler

Arquitectura de la red LSTM

La red usa un modelo secuencial de Keras con tres capas LSTM apiladas y capas de Dropout para reducir el sobreajuste. La capa densa de salida tiene regularización L2 para penalizar pesos grandes.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.regularizers import L2

def build_lstm_model(input_shape):
    model = Sequential([
        # Primera capa LSTM — devuelve secuencias para la siguiente capa
        LSTM(units=50, return_sequences=True, input_shape=input_shape),

        # Segunda capa LSTM con Dropout del 20%
        LSTM(units=50, return_sequences=True),
        Dropout(0.2),

        # Tercera capa LSTM — solo devuelve la última salida
        LSTM(units=50, return_sequences=False),
        Dropout(0.1),

        # Capa densa de salida con regularización L2
        Dense(units=1, kernel_regularizer=L2(0.01))
    ])
    model.compile(optimizer='adam', loss='mean_squared_error')
    return model

Hallazgos principales

Limitaciones y trabajo futuro

• El modelo LSTM predice solo precio, no distribución de probabilidad — una extensión con predicción de intervalo de confianza (Bayesian LSTM o Monte Carlo Dropout) cuantificaría la incertidumbre de los rendimientos esperados.
• El horizonte de predicción es fijo en 30 días. Una arquitectura multi-step (predicción de múltiples pasos futuros de forma directa) permitiría ajustar el horizonte del portafolio de manera más flexible.
• No se incorpora rebalanceo periódico del portafolio. En producción, el pipeline debería ejecutarse periódicamente (mensual o trimestralmente) para actualizar predicciones LSTM y pesos óptimos.
• El universo se limita a 10 acciones. Ampliar a un índice completo (S&P 500) requeriría técnicas de clustering para agrupar acciones y entrenar modelos por cluster, reduciendo el costo computacional.
• SHAP aplicado sobre el modelo LSTM permitiría explicar qué indicadores técnicos contribuyen más a cada predicción individual, mejorando la interpretabilidad para el analista.