trading-platform/orchestration/tareas/TASK-2026-01-25-ML-TRAINING-ENHANCEMENT/02-ANALISIS.md

02-ANÁLISIS: Mejora Integral de Modelos ML para Trading

Task ID: TASK-2026-01-25-ML-TRAINING-ENHANCEMENT Fase: A - Análisis Estado: Completada Fecha: 2026-01-25

---

1. COMPORTAMIENTO DESEADO (Perspectiva de Negocio)

1.1 Visión del Sistema

┌─────────────────────────────────────────────────────────────────────────────────┐
│                        SISTEMA ML DE TRADING OBJETIVO                           │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  [Datos de Mercado] → [5 Estrategias ML] → [Metamodelo Ensemble] → [LLM Agent] │
│                              ↓                       ↓                           │
│                      [Atención sobre            [Decisión                       │
│                       Variación Precio]          de Trading]                    │
│                                                      ↓                           │
│                                              [Ejecución MT4]                    │
│                                                      ↓                           │
│                                            [80%+ Efectividad]                   │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

1.2 Comportamientos Esperados

ID	Comportamiento	Descripción
B1	Predicción Multi-Estrategia	El sistema genera predicciones desde 5 estrategias independientes
B2	Atención Dinámica	El modelo aprende a enfocarse en patrones de variación de precio relevantes
B3	Especialización por Activo	Cada activo tiene su propio modelo entrenado
B4	Síntesis Ensemble	Un metamodelo combina las predicciones de todas las estrategias
B5	Decisión LLM Informada	El LLM recibe señales procesadas para tomar decisiones
B6	Agnóstico Temporal	Las predicciones no dependen del horario específico
B7	Efectividad Verificable	Cada operación se puede rastrear a la predicción que la generó

---

2. ANÁLISIS DE ARQUITECTURAS EXISTENTES

2.1 Proyecto Antiguo (WorkspaceOld/trading)

Fortalezas

• Ensemble XGBoost + GRU: Combina gradiente boosting con redes recurrentes
• 22 indicadores técnicos bien calibrados
• Horizontes múltiples (0, 1, 2, 4 períodos)
• Predicción triple (high, close, low)
• Datos históricos extensos (10+ años)

Debilidades

• Sin mecanismos de atención explícitos
• Modelos no especializados por activo
• Sin integración LLM
• Arquitectura monolítica

Conocimiento a Migrar

indicadores_tecnicos:
  momentum:
    - MACD (12/26/9)
    - RSI (periodo 14)
    - ROC (Rate of Change)
  volatilidad:
    - ATR (periodo 10)
    - Bollinger Bands
  volumen:
    - OBV (On-Balance Volume)
    - MFI (Money Flow Index, periodo 14)
    - CMF (Chaikin Money Flow, periodo 20)
    - volume_z (Z-score, rolling 20)
    - volume_anomaly (binario)
  estructura:
    - SAR (Parabolic SAR)
    - Fractal_Alcista (5-bar)
    - Fractal_Bajista (5-bar)
    - AD (Accumulation/Distribution)
  medias:
    - SMA_10, SMA_20

ventanas_rodantes:
  - 15m (3 velas de 5min)
  - 60m (12 velas de 5min)
  - 120m (24 velas de 5min)

targets:
  - target_pct_hour: (close_hour_final - close) / close

2.2 Proyecto Actual (trading-platform)

Fortalezas

• Arquitectura jerárquica (Level 0/1/2)
• Mecanismos de atención implementados (Level 0)
• 15 modelos especializados
• Integración LLM existente
• Backtesting engine funcional
• Walk-forward validation

Debilidades

• Solo 1 año de datos (469K bars)
• Level 2 (AssetMetamodel) incompleto
• Accuracy actual ~65-70%
• Estrategia única (no diversificada)

Modelos Existentes a Mejorar

level_0_attention:
  - AttentionScoreModel (flujo de mercado)
  - 12 modelos entrenados por símbolo+timeframe

level_1_prediction:
  - AMDDetector (fases Smart Money)
  - RangePredictor v1/v2 (high/low)
  - SignalGenerator (señales trading)
  - EnhancedRangePredictor
  - TPSLClassifier

level_2_synthesis:
  - AssetMetamodel (PENDIENTE)
  - DualHorizonEnsemble
  - StrategyEnsemble
  - NeuralGatingMetamodel

---

3. DISEÑO DE 5 ESTRATEGIAS DE MODELOS

3.1 Estrategia 1: PRICE-VARIATION-ATTENTION (PVA)

Enfoque: Atención sobre variación de precio pura, agnóstica al tiempo y activo.

nombre: "Price Variation Attention"
codigo: "PVA"

arquitectura:
  tipo: "Transformer Encoder + XGBoost Head"
  attention_mechanism: "Self-Attention sobre secuencias de retornos"

features:
  primarios:
    - returns_1: (close[t] - close[t-1]) / close[t-1]
    - returns_5: (close[t] - close[t-5]) / close[t-5]
    - returns_10: (close[t] - close[t-10]) / close[t-10]
    - returns_20: (close[t] - close[t-20]) / close[t-20]
  derivados:
    - acceleration: returns_1[t] - returns_1[t-1]
    - volatility_returns: std(returns_5, window=20)
    - skewness_returns: skew(returns_10, window=50)
    - kurtosis_returns: kurt(returns_10, window=50)
  attention_scores:
    - attention_weight_1 a attention_weight_seq_len (aprendidos)

targets:
  - future_return_1h: (close[t+12] - close[t]) / close[t]  # 12 velas de 5min = 1h
  - future_volatility: std(returns próximos 12 períodos)
  - direction_confidence: softmax([-1, 0, +1])

entrenamiento:
  sequence_length: 100  # velas de contexto
  batch_size: 256
  learning_rate: 0.0001
  epochs: 100
  early_stopping: 10

modelo_por_activo: true
ignorar_horario: true  # No usar features de sesión

3.2 Estrategia 2: MOMENTUM-REGIME-DETECTION (MRD)

Enfoque: Detectar régimen de mercado (tendencia/rango) y predecir continuación.

nombre: "Momentum Regime Detection"
codigo: "MRD"

arquitectura:
  tipo: "Hidden Markov Model + LSTM + XGBoost"
  hmm_states: 3  # Trend Up, Range, Trend Down

features:
  momentum:
    - rsi_14, rsi_28
    - macd, macd_signal, macd_histogram
    - roc_5, roc_10, roc_20
    - adx, +di, -di
  tendencia:
    - ema_crossover_9_21: sign(ema_9 - ema_21)
    - ema_crossover_21_50: sign(ema_21 - ema_50)
    - price_vs_ema_200: (close - ema_200) / ema_200
  regimen:
    - hmm_state: [0, 1, 2]  # Detectado por HMM
    - regime_probability: softmax de HMM
    - regime_duration: velas desde último cambio

targets:
  - next_regime: estado HMM en t+12
  - regime_duration_prediction: cuántas velas durará el régimen
  - momentum_continuation: bool (momentum sigue en misma dirección)

entrenamiento:
  hmm_iterations: 100
  lstm_units: 128
  dropout: 0.3

modelo_por_activo: true
incluir_sesion: false  # Régimen es agnóstico

3.3 Estrategia 3: VOLATILITY-BREAKOUT-PREDICTOR (VBP)

Enfoque: Predecir breakouts basados en compresión de volatilidad.

nombre: "Volatility Breakout Predictor"
codigo: "VBP"

arquitectura:
  tipo: "CNN 1D + Attention + XGBoost"
  cnn_filters: [32, 64, 128]
  kernel_sizes: [3, 5, 7]

features:
  volatilidad:
    - atr_5, atr_10, atr_20, atr_50
    - bb_width: (bb_upper - bb_lower) / bb_middle
    - bb_squeeze: bool(bb_width < bb_width.rolling(50).quantile(0.2))
    - keltner_squeeze: bb dentro de keltner channels
    - historical_volatility: std(returns, window=20) * sqrt(252)
  rango:
    - hl_range: (high - low) / close
    - hl_range_vs_atr: hl_range / atr_10
    - compression_score: min(hl_range últimas 10 velas) / max(hl_range últimas 50)
  expansion:
    - expansion_imminent: compression_score < 0.3
    - breakout_direction_bias: sign(close - open de la compresión)

targets:
  - breakout_next_12: bool(max(high[t:t+12]) - min(low[t:t+12]) > 2*atr)
  - breakout_direction: [-1, 0, +1] (down, no breakout, up)
  - breakout_magnitude: (high_max - low_min) / close si breakout

entrenamiento:
  imbalanced_sampling: true  # Breakouts son raros
  oversample_breakouts: 3x

modelo_por_activo: true

3.4 Estrategia 4: MARKET-STRUCTURE-ANALYSIS (MSA)

Enfoque: Análisis de estructura de mercado (ICT/SMC concepts).

nombre: "Market Structure Analysis"
codigo: "MSA"

arquitectura:
  tipo: "Graph Neural Network + XGBoost"
  gnn_layers: 4
  node_features: swing_points

features:
  estructura:
    - swing_high: high mayor que 2 altos anteriores y posteriores
    - swing_low: low menor que 2 bajos anteriores y posteriores
    - higher_high: swing_high > swing_high anterior
    - lower_low: swing_low < swing_low anterior
    - bos_up: Break of Structure alcista
    - bos_down: Break of Structure bajista
    - choch: Change of Character (cambio de tendencia)
  zonas:
    - order_block_bullish: última vela bajista antes de BOS alcista
    - order_block_bearish: última vela alcista antes de BOS bajista
    - fvg_bullish: Fair Value Gap alcista
    - fvg_bearish: Fair Value Gap bajista
    - liquidity_sweep: barrido de liquidez
  posicion:
    - price_vs_poi: distancia a Point of Interest más cercano
    - poi_type: [order_block, fvg, swing, none]
    - premium_discount: precio en zona premium (>50%) o discount (<50%)

targets:
  - next_bos_direction: [-1, +1] próximo BOS
  - poi_reaction: bool (precio reacciona al POI)
  - structure_continuation: bool (estructura continúa)

entrenamiento:
  graph_attention: true
  node_aggregation: "mean"

modelo_por_activo: true

3.5 Estrategia 5: MULTI-TIMEFRAME-SYNTHESIS (MTS)

Enfoque: Síntesis de señales de múltiples timeframes con ponderación dinámica.

nombre: "Multi-Timeframe Synthesis"
codigo: "MTS"

arquitectura:
  tipo: "Hierarchical Attention Network"
  timeframes: [5m, 15m, 1h, 4h]
  attention_per_tf: true

features_por_timeframe:
  5m:
    - all_base_features (momentum, volatility, volume)
    - micro_structure (last 50 bars)
  15m:
    - aggregated_features
    - trend_alignment_5m
  1h:
    - session_context
    - intraday_trend
  4h:
    - swing_structure
    - major_trend

synthesis:
  - tf_alignment_score: concordancia entre timeframes
  - dominant_tf: timeframe con señal más fuerte
  - conflict_score: nivel de conflicto entre TFs

targets:
  - unified_direction: [-1, 0, +1] consenso de TFs
  - confidence_by_alignment: 0-1 basado en concordancia
  - optimal_entry_tf: cuál TF da mejor entry

entrenamiento:
  hierarchical_loss: true
  tf_weights: learnable

modelo_por_activo: true

---

4. ARQUITECTURA DE ATENCIÓN PROPUESTA

4.1 Price-Focused Attention Mechanism

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    PRICE-FOCUSED ATTENTION ARCHITECTURE                          │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  Input: Secuencia de Retornos [r_1, r_2, ..., r_T]                             │
│                          ↓                                                       │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Positional Encoding (Learnable)                       │   │
│  │                    SIN usar información temporal real                    │   │
│  │                    Solo posición relativa en secuencia                   │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                          ↓                                                       │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Self-Attention Layer x 4                               │   │
│  │                                                                           │   │
│  │    Q = W_q * X    K = W_k * X    V = W_v * X                            │   │
│  │                                                                           │   │
│  │    Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) * V                   │   │
│  │                                                                           │   │
│  │    Multi-Head: 8 heads, d_model=256, d_k=32                             │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                          ↓                                                       │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Feed-Forward Network                                   │   │
│  │                    FFN(x) = ReLU(xW_1 + b_1)W_2 + b_2                    │   │
│  │                    d_ff = 1024                                            │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                          ↓                                                       │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Attention Score Extraction                             │   │
│  │                    scores = mean(attention_weights, dim=heads)           │   │
│  │                    top_k_positions = argsort(scores)[-k:]                │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                          ↓                                                       │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    XGBoost Prediction Head                                │   │
│  │                    Input: [attended_features, attention_scores, raw]     │   │
│  │                    Output: [direction, magnitude, confidence]            │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

4.2 Características Clave

1. Sin Información Temporal Explícita: No usa features de hora/día/sesión
2. Solo Variación de Precio: Features basados únicamente en retornos y derivados
3. Atención Aprendida: El modelo aprende qué variaciones son relevantes
4. Agnóstico al Activo: Arquitectura idéntica para todos los activos (pesos diferentes)

---

5. ARQUITECTURA DE METAMODELO ENSEMBLE

5.1 Neural Gating Metamodel

┌─────────────────────────────────────────────────────────────────────────────────┐
│                        NEURAL GATING METAMODEL                                   │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  Inputs:                                                                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐              │
│  │   PVA    │ │   MRD    │ │   VBP    │ │   MSA    │ │   MTS    │              │
│  │ pred,conf│ │ pred,conf│ │ pred,conf│ │ pred,conf│ │ pred,conf│              │
│  └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘ └────┬─────┘              │
│       │            │            │            │            │                      │
│       └────────────┴────────────┴────────────┴────────────┘                      │
│                                  ↓                                                │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Gating Network                                         │   │
│  │                    Input: [all_predictions, all_confidences, market_ctx] │   │
│  │                    Output: weights = softmax(gate_logits)                │   │
│  │                    Architecture: 3-layer MLP (256, 128, 5)               │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                  ↓                                                │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Weighted Ensemble                                      │   │
│  │                    final_pred = sum(weights * predictions)               │   │
│  │                    final_conf = weighted_confidence(weights, confs)      │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                  ↓                                                │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │                    Output                                                 │   │
│  │                    - direction: [-1, 0, +1]                              │   │
│  │                    - magnitude: expected % move                          │   │
│  │                    - confidence: 0-1                                     │   │
│  │                    - strategy_attribution: which strategy dominated      │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

5.2 Lógica de Gating

class NeuralGatingMetamodel:
    def forward(self, strategy_outputs, market_context):
        # Concatenar outputs de todas las estrategias
        features = torch.cat([
            strategy_outputs['PVA'],  # [pred, conf]
            strategy_outputs['MRD'],
            strategy_outputs['VBP'],
            strategy_outputs['MSA'],
            strategy_outputs['MTS'],
            market_context,  # volatility, regime, etc.
        ], dim=-1)

        # Gating network decide pesos
        gate_logits = self.gate_network(features)
        weights = F.softmax(gate_logits, dim=-1)

        # Ensemble ponderado
        predictions = torch.stack([
            strategy_outputs[s]['prediction'] for s in STRATEGIES
        ], dim=-1)

        final_prediction = (weights * predictions).sum(dim=-1)

        return {
            'prediction': final_prediction,
            'weights': weights,
            'confidence': self.confidence_head(features),
        }

---

6. INTEGRACIÓN LLM PROPUESTA

6.1 Flujo de Decisión

┌─────────────────────────────────────────────────────────────────────────────────┐
│                        LLM DECISION INTEGRATION                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                  │
│  1. ML Engine genera predicciones                                                │
│     ↓                                                                            │
│  2. Metamodel sintetiza señal final                                              │
│     ↓                                                                            │
│  3. Signal Formatter prepara prompt para LLM                                     │
│     ↓                                                                            │
│  4. LLM analiza contexto + predicciones                                          │
│     ↓                                                                            │
│  5. LLM decide: TRADE / NO_TRADE / WAIT                                         │
│     ↓                                                                            │
│  6. Si TRADE: LLM define entry, SL, TP                                          │
│     ↓                                                                            │
│  7. Trading Agent ejecuta                                                        │
│     ↓                                                                            │
│  8. Signal Logger registra resultado                                             │
│     ↓                                                                            │
│  9. Fine-tuning loop (feedback)                                                  │
│                                                                                  │
└─────────────────────────────────────────────────────────────────────────────────┘

6.2 Prompt Structure para LLM

TRADING_DECISION_PROMPT = """
## Market Analysis for {symbol}

### ML Predictions (Ensemble)
- Direction: {direction} (confidence: {confidence}%)
- Predicted Move: {magnitude}%
- Dominant Strategy: {dominant_strategy}
- Strategy Agreement: {agreement_score}/5

### Individual Strategy Signals
| Strategy | Direction | Confidence | Weight |
|----------|-----------|------------|--------|
{strategy_table}

### Current Market Context
- Volatility Regime: {volatility_regime}
- Market Structure: {market_structure}
- Key Levels: {key_levels}

### Risk Parameters
- Account Balance: {balance}
- Max Risk per Trade: {max_risk}%
- Current Open Positions: {open_positions}

### Task
Analyze the above information and decide:
1. Should we take this trade? (YES/NO/WAIT)
2. If YES, provide:
   - Entry price (or MARKET)
   - Stop Loss level
   - Take Profit level(s)
   - Position size (% of balance)
3. Reasoning (brief)

Response Format:
DECISION: [YES|NO|WAIT]
ENTRY: [price]
STOP_LOSS: [price]
TAKE_PROFIT: [price1, price2]
POSITION_SIZE: [%]
REASONING: [text]
"""

---

7. OBJETOS IMPACTADOS

7.1 Base de Datos (PostgreSQL)

Schema	Tabla	Cambio
ml	model_registry	Agregar campos para 5 estrategias
ml	predictions	Agregar columnas por estrategia
ml	strategy_weights	NUEVA - pesos del gating
ml	training_runs	Agregar metadata de estrategia
ml	backtest_results	Agregar resultados por estrategia
ml	attention_weights	NUEVA - scores de atención guardados

7.2 Backend (ml-engine)

Archivo/Directorio	Cambio
src/models/	Agregar 5 nuevos modelos de estrategia
src/models/attention/	Implementar Price-Focused Attention
src/models/metamodel/	Implementar Neural Gating Metamodel
src/training/	Agregar trainers por estrategia
src/pipelines/	Nuevo pipeline multi-estrategia
src/api/	Nuevos endpoints para predicciones ensemble
config/	Configuración por estrategia

7.3 Documentación

Archivo	Cambio
docs/02-definicion-modulos/OQI-006-ml-signals/_MAP.md	Actualizar con nuevas estrategias
docs/02-definicion-modulos/OQI-006-ml-signals/README.md	Documentar arquitectura ensemble
docs/02-definicion-modulos/OQI-006-ml-signals/especificaciones/	Nuevas specs técnicas
orchestration/inventarios/ML_INVENTORY.yml	NUEVO - inventario de modelos

---

8. DEPENDENCIAS IDENTIFICADAS

8.1 Dependencias Técnicas

dependencias_tecnicas:
  python:
    - torch>=2.0.0  # Para Transformers
    - xgboost>=2.0.0  # Gradient Boosting
    - hmmlearn>=0.3.0  # Hidden Markov Models
    - torch-geometric>=2.4.0  # Graph Neural Networks (opcional)
    - einops>=0.7.0  # Tensor operations

  datos:
    - Migración de datos históricos de WorkspaceOld (5.6 GB)
    - Al menos 5 años de datos para entrenamiento robusto

  infraestructura:
    - GPU con 16GB+ VRAM (disponible)
    - PostgreSQL con espacio para modelos serializados

8.2 Dependencias de Tareas

orden_ejecucion:
  fase_1_infraestructura:
    - TASK-ML-DATA-PIPELINE  # Migrar datos históricos
    - TASK-ML-ATTENTION-ARCHITECTURE  # Implementar attention base

  fase_2_estrategias:  # Pueden ejecutarse en paralelo
    - TASK-ML-STRATEGY-1-PVA
    - TASK-ML-STRATEGY-2-MRD
    - TASK-ML-STRATEGY-3-VBP
    - TASK-ML-STRATEGY-4-MSA
    - TASK-ML-STRATEGY-5-MTS

  fase_3_integracion:
    - TASK-ML-METAMODEL-ENSEMBLE  # Requiere fase 2 completa
    - TASK-ML-LLM-INTEGRATION  # Requiere metamodel

  fase_4_validacion:
    - TASK-ML-BACKTESTING-VALIDATION  # Requiere todo lo anterior

---

9. RIESGOS IDENTIFICADOS

ID	Riesgo	Probabilidad	Impacto	Mitigación
R1	Overfitting en modelos complejos	Alta	Alto	Walk-forward validation, regularization
R2	Datos insuficientes para 5 estrategias	Media	Alto	Migrar datos históricos, data augmentation
R3	Latencia excesiva en inference	Media	Medio	Batch prediction, model optimization
R4	Conflicto entre estrategias	Alta	Medio	Gating network aprende a ponderar
R5	LLM toma decisiones incorrectas	Media	Alto	Fine-tuning con feedback, safety limits
R6	Régimen de mercado no visto	Baja	Alto	Ensemble diversificado, fallback rules

---

10. ESTIMACIÓN DE RECURSOS

10.1 Cómputo

Componente	GPU Hours	RAM	Storage
Data Pipeline	0	32GB	10GB
PVA Training	100h	16GB	2GB
MRD Training	50h	16GB	2GB
VBP Training	30h	16GB	1GB
MSA Training	80h	16GB	2GB
MTS Training	120h	16GB	3GB
Metamodel	20h	16GB	1GB
Backtesting	10h	32GB	5GB
TOTAL	410h	32GB	26GB

10.2 Desarrollo (Story Points)

Subtarea	SP
Data Pipeline	8
Attention Architecture	13
Strategy 1-5 (cada una)	8 × 5 = 40
Metamodel Ensemble	13
LLM Integration	8
Backtesting Validation	8
TOTAL	90 SP

---

Siguiente Fase: 03-PLANEACION.md