---
id: "ESTRATEGIA-ICT-SMC"
title: "ICT y Smart Money Concepts"
type: "Documentation"
project: "trading-platform"
version: "1.0.0"
updated_date: "2026-01-04"
---

# Estrategias Complementarias: ICT y Smart Money Concepts

**Versi\u00f3n:** 1.0.0
**Fecha:** 2025-12-05
**M\u00f3dulo:** OQI-006-ml-signals
**Autor:** Trading Strategist - Trading Platform

---

## Tabla de Contenidos

1. [Introducci\u00f3n](#introducci\u00f3n)
2. [ICT Concepts (Inner Circle Trader)](#ict-concepts-inner-circle-trader)
3. [Smart Money Concepts (SMC)](#smart-money-concepts-smc)
4. [Estrategia de Confluence](#estrategia-de-confluence)
5. [Integraci\u00f3n AMD + ICT + SMC](#integraci\u00f3n-amd--ict--smc)
6. [Implementaci\u00f3n en ML](#implementaci\u00f3n-en-ml)
7. [Referencias](#referencias)

---

## Introducci\u00f3n

Las estrategias ICT (Inner Circle Trader) y Smart Money Concepts (SMC) son metodolog\u00edas complementarias a la estrategia AMD que se enfocan en comprender c\u00f3mo operan las instituciones financieras (market makers, bancos, hedge funds) en los mercados.

### Relaci\u00f3n con AMD

```
┌─────────────────────────────────────────────────────┐
│                  JERARQUÍA DE CONCEPTOS             │
├─────────────────────────────────────────────────────┤
│                                                     │
│  AMD (Marco General)                                │
│  └── Identifica FASES del mercado                  │
│                                                     │
│  ICT (Timing & Zones)                               │
│  └── Identifica CUÁNDO y DÓNDE entrar              │
│                                                     │
│  SMC (Structure & Flow)                             │
│  └── Identifica CÓMO se mueve el dinero            │
│                                                     │
└─────────────────────────────────────────────────────┘
```

### Principio Unificador

**"Follow the Smart Money"** - Todas estas metodolog\u00edas buscan identificar y seguir al dinero institucional, no oponerse a \u00e9l.

---

## ICT Concepts (Inner Circle Trader)

### Fundamentos ICT

ICT es una metodolog\u00eda desarrollada por Michael J. Huddleston que se enfoca en c\u00f3mo los market makers operan para proveer liquidez y generar ganancias.

### 1. Optimal Trade Entry (OTE)

**Definici\u00f3n:** Zona \u00f3ptima de entrada basada en retrocesos Fibonacci

#### Zonas OTE

```
┌─────────────────────────────────────────────────┐
│         FIBONACCI RETRACEMENT ZONES             │
├─────────────────────────────────────────────────┤
│                                                 │
│  100% ────────────────────────────────  High   │
│                                                 │
│   79% ─────────────┐  ┌─────────────           │
│                    │  │  OTE ZONE              │
│   62% ─────────────┘  └─────────────  Premium  │
│                                                 │
│   50% ───────────────────────────────  Equilibrium │
│                                                 │
│   38% ─────────────┐  ┌─────────────  Discount│
│                    │  │  Possible Entry        │
│   21% ─────────────┘  └─────────────           │
│                                                 │
│    0% ────────────────────────────────  Low    │
│                                                 │
└─────────────────────────────────────────────────┘
```

**Zonas Clave:**
- **Premium Zone** (62%-79%): Mejor zona para ventas
- **OTE Zone** (62%-79%): Zona \u00f3ptima de entrada
- **Discount Zone** (21%-38%): Mejor zona para compras

#### Implementaci\u00f3n

```python
def calculate_ote_zones(swing_high, swing_low):
    """
    Calcula zonas OTE para un swing
    """
    range_size = swing_high - swing_low

    zones = {
        # Fibonacci levels
        'fib_0': swing_low,
        'fib_21': swing_low + (range_size * 0.21),
        'fib_38': swing_low + (range_size * 0.38),
        'fib_50': swing_low + (range_size * 0.50),
        'fib_62': swing_low + (range_size * 0.62),
        'fib_79': swing_low + (range_size * 0.79),
        'fib_100': swing_high,

        # Named zones
        'discount_zone': (
            swing_low + (range_size * 0.21),
            swing_low + (range_size * 0.38)
        ),
        'equilibrium': swing_low + (range_size * 0.50),
        'premium_zone': (
            swing_low + (range_size * 0.62),
            swing_low + (range_size * 0.79)
        ),
        'ote_buy': (  # For bullish moves
            swing_low + (range_size * 0.62),
            swing_low + (range_size * 0.79)
        ),
        'ote_sell': (  # For bearish moves
            swing_high - (range_size * 0.79),
            swing_high - (range_size * 0.62)
        )
    }

    return zones
```

#### Estrategia OTE

```
BULLISH SETUP:
1. Identificar impulso alcista reciente
2. Esperar retroceso a zona 62%-79%
3. Buscar confirmaci\u00f3n (order block, FVG, etc.)
4. Entry en rechazo de OTE

BEARISH SETUP:
1. Identificar impulso bajista reciente
2. Esperar rally a zona 62%-79% desde el top
3. Buscar confirmaci\u00f3n bearish
4. Entry en rechazo de OTE
```

### 2. Killzones

**Definici\u00f3n:** Ventanas de tiempo donde la liquidez institucional es m\u00e1s activa

#### Horarios de Killzones (Hora EST)

| Killzone | Inicio (EST) | Fin (EST) | Duraci\u00f3n | Mercado | Caracter\u00edsticas |
|----------|--------------|-----------|----------|---------|---------------------|
| **Asian** | 20:00 | 00:00 | 4h | Tokyo | Rangos estrechos, low volatility |
| **London Open** | 02:00 | 05:00 | 3h | London | Alta volatilidad, tendencias fuertes |
| **New York AM** | 08:30 | 11:00 | 2.5h | NY | M\u00e1xima liquidez, reversiones comunes |
| **London Close** | 10:00 | 12:00 | 2h | London | Cierre de posiciones, volatilidad |
| **New York PM** | 13:30 | 16:00 | 2.5h | NY | Continuaci\u00f3n o reversi\u00f3n de trends |

#### Killzone Preferidas ICT

**London Open Killzone (02:00-05:00 EST):**
- Mayor probabilidad de trending moves
- Instituciones europeas activas
- Mejores setups para breakouts

**New York AM Killzone (08:30-11:00 EST):**
- M\u00e1xima liquidez global
- Overlap London/NY
- Reversiones comunes en 09:30-10:00

#### Implementaci\u00f3n

```python
from datetime import time

def identify_killzone(timestamp):
    """
    Identifica la killzone actual
    timestamp: pd.Timestamp con timezone UTC
    """
    # Convertir a EST
    est_time = timestamp.tz_convert('America/New_York').time()

    killzones = {
        'asian': (time(20, 0), time(0, 0)),
        'london_open': (time(2, 0), time(5, 0)),
        'ny_am': (time(8, 30), time(11, 0)),
        'london_close': (time(10, 0), time(12, 0)),
        'ny_pm': (time(13, 30), time(16, 0))
    }

    for name, (start, end) in killzones.items():
        if start <= est_time <= end:
            return name

    return 'outside_killzone'

def is_high_probability_killzone(killzone):
    """Killzones de alta probabilidad seg\u00fan ICT"""
    return killzone in ['london_open', 'ny_am']
```

#### Features ML para Killzones

```python
# Features derivados de killzones
killzone_features = {
    'is_london_open': 1 if killzone == 'london_open' else 0,
    'is_ny_am': 1 if killzone == 'ny_am' else 0,
    'is_asian': 1 if killzone == 'asian' else 0,
    'is_high_prob_kz': 1 if is_high_probability_killzone(killzone) else 0,
    'session_overlap': 1 if killzone in ['london_close', 'ny_am'] else 0,

    # Time encoding
    'hour_sin': np.sin(2 * np.pi * hour / 24),
    'hour_cos': np.cos(2 * np.pi * hour / 24),

    # Session strength (0-1)
    'session_strength': {
        'asian': 0.3,
        'london_open': 0.9,
        'ny_am': 1.0,
        'london_close': 0.7,
        'ny_pm': 0.6
    }.get(killzone, 0.1)
}
```

### 3. Weekly & Daily Ranges

#### Concepto de Ranges ICT

**Weekly Range:**
- Establecido en la primera semana del mes
- Market makers operan dentro de este rango
- Extensiones com\u00fanmente en +/- 20% del rango

**Daily Range:**
- Establecido en primeras horas (Asian-London)
- 80% de d\u00edas respetan este rango
- Breakouts falsos com\u00fanes al final del d\u00eda

#### C\u00e1lculo de Ranges

```python
def calculate_ict_ranges(df):
    """
    Calcula ranges ICT para an\u00e1lisis
    """
    ranges = {}

    # Weekly range (lunes a viernes)
    df['week'] = df.index.isocalendar().week
    weekly = df.groupby('week').agg({
        'high': 'max',
        'low': 'min',
        'close': 'last'
    })
    ranges['weekly_high'] = weekly['high'].iloc[-1]
    ranges['weekly_low'] = weekly['low'].iloc[-1]
    ranges['weekly_range'] = ranges['weekly_high'] - ranges['weekly_low']

    # Daily range (primeras 8 horas)
    today = df[df.index.date == df.index[-1].date()]
    if len(today) >= 96:  # 8 horas * 12 (5min candles)
        early_session = today.iloc[:96]
        ranges['daily_high'] = early_session['high'].max()
        ranges['daily_low'] = early_session['low'].min()
        ranges['daily_range'] = ranges['daily_high'] - ranges['daily_low']
    else:
        ranges['daily_high'] = today['high'].max()
        ranges['daily_low'] = today['low'].min()
        ranges['daily_range'] = ranges['daily_high'] - ranges['daily_low']

    # Current price position in ranges
    current_price = df['close'].iloc[-1]
    ranges['weekly_position'] = (
        (current_price - ranges['weekly_low']) / ranges['weekly_range']
        if ranges['weekly_range'] > 0 else 0.5
    )
    ranges['daily_position'] = (
        (current_price - ranges['daily_low']) / ranges['daily_range']
        if ranges['daily_range'] > 0 else 0.5
    )

    return ranges
```

#### Trading con Ranges

**Estrategia Inside Range:**
```
SETUP:
- Precio dentro del range establecido
- Buscar reversiones en extremos

LONG ENTRY:
- Precio cerca de low del range (20-30%)
- Confirmaci\u00f3n bullish (order block, FVG)
- Target: High del range

SHORT ENTRY:
- Precio cerca de high del range (70-80%)
- Confirmaci\u00f3n bearish
- Target: Low del range
```

**Estrategia Breakout:**
```
SETUP:
- Precio rompe range establecido
- Alto volumen en breakout

RETEST ENTRY:
- Esperar pullback al nivel de breakout
- Breakout level act\u00faa como soporte/resistencia
- Entry en rechazo del retest
```

### 4. Premium / Discount Pricing

**Concepto:** Market makers compran en "discount" y venden en "premium"

#### Zonas de Precio

```
PREMIUM ZONE (Expensive)
├── 100% ─────────────── High
├──  75% ───────────────
│         SELL ZONE
├──  50% ─────────────── Equilibrium
│         BUY ZONE
├──  25% ───────────────
└──   0% ─────────────── Low
DISCOUNT ZONE (Cheap)
```

**Reglas:**
- **Comprar** solo en Discount Zone (0-50%)
- **Vender** solo en Premium Zone (50-100%)
- **Evitar** entradas cerca de equilibrio (45-55%)

#### Implementaci\u00f3n

```python
def calculate_premium_discount(current_price, range_high, range_low):
    """
    Calcula si precio est\u00e1 en premium o discount
    """
    range_size = range_high - range_low
    if range_size == 0:
        return 0.5, 'equilibrium'

    # Position in range (0 = low, 1 = high)
    position = (current_price - range_low) / range_size

    if position >= 0.75:
        zone = 'extreme_premium'
    elif position >= 0.50:
        zone = 'premium'
    elif position >= 0.25:
        zone = 'discount'
    else:
        zone = 'extreme_discount'

    return position, zone

def get_trading_bias(zone):
    """Bias de trading seg\u00fan zona"""
    bias_map = {
        'extreme_premium': 'strong_sell',
        'premium': 'sell',
        'discount': 'buy',
        'extreme_discount': 'strong_buy'
    }
    return bias_map.get(zone, 'neutral')
```

### 5. Market Maker Models

#### MMSM (Market Maker Sell Model)

```
Fase 1: Distribution (Vendiendo a retail)
         │
         ▼
Fase 2: Inducement (Falsa continuación alcista)
         │
         ▼
Fase 3: Sell Setup (Market makers venden)
         │
         ▼
Fase 4: Manipulation (Stop hunt de largos)
         │
         ▼
Fase 5: Distribution (Caída real)
```

**Caracter\u00edsticas:**
1. Highs consecutivos en zona premium
2. Falso breakout final (inducement)
3. Sweep de liquidity (BSL hunt)
4. Reversi\u00f3n bajista violenta

#### MMBM (Market Maker Buy Model)

```
Fase 1: Accumulation (Comprando de retail)
         │
         ▼
Fase 2: Inducement (Falsa continuaci\u00f3n bajista)
         │
         ▼
Fase 3: Buy Setup (Market makers compran)
         │
         ▼
Fase 4: Manipulation (Stop hunt de cortos)
         │
         ▼
Fase 5: Accumulation (Subida real)
```

**Caracter\u00edsticas:**
1. Lows consecutivos en zona discount
2. Falso breakdown final (inducement)
3. Sweep de liquidity (SSL hunt)
4. Reversi\u00f3n alcista violenta

#### Detecci\u00f3n de MM Models

```python
def detect_market_maker_model(df, lookback=50):
    """
    Detecta patrones de Market Maker
    """
    recent = df.tail(lookback)

    # Calculate range
    range_high = recent['high'].max()
    range_low = recent['low'].min()
    current_price = df['close'].iloc[-1]

    # Check for MMSM (sell model)
    higher_highs = (recent['high'] > recent['high'].shift(1)).sum()
    in_premium = current_price > (range_low + (range_high - range_low) * 0.70)
    liquidity_sweep = detect_bsl_sweep(df.tail(20))

    if higher_highs >= 3 and in_premium and liquidity_sweep:
        return {
            'model': 'MMSM',
            'confidence': 0.8,
            'expected_move': 'bearish',
            'entry_zone': 'wait_for_reversal'
        }

    # Check for MMBM (buy model)
    lower_lows = (recent['low'] < recent['low'].shift(1)).sum()
    in_discount = current_price < (range_low + (range_high - range_low) * 0.30)
    liquidity_sweep = detect_ssl_sweep(df.tail(20))

    if lower_lows >= 3 and in_discount and liquidity_sweep:
        return {
            'model': 'MMBM',
            'confidence': 0.8,
            'expected_move': 'bullish',
            'entry_zone': 'wait_for_reversal'
        }

    return {
        'model': 'none',
        'confidence': 0,
        'expected_move': 'neutral'
    }
```

### 6. Power of 3 (PO3)

**Concepto:** Cada sesi\u00f3n de trading tiene 3 fases

```
┌─────────────────────────────────────────┐
│           POWER OF 3 PHASES             │
├─────────────────────────────────────────┤
│                                         │
│  1. ACCUMULATION/DISTRIBUTION           │
│     │ Inicio de sesi\u00f3n               │
│     │ Rangos estrechos                  │
│     │ Low volume                        │
│     ▼                                   │
│                                         │
│  2. MANIPULATION                        │
│     │ Caza de liquidez                  │
│     │ False breakouts                   │
│     │ Spikes de volumen                 │
│     ▼                                   │
│                                         │
│  3. DISTRIBUTION/ACCUMULATION           │
│     │ Movimiento real                   │
│     │ Trending price action             │
│     │ Objetivo alcanzado                │
│     ▼                                   │
│                                         │
└─────────────────────────────────────────┘
```

**Aplicaci\u00f3n:**
- Fase 1 (Primeras 2 horas): Observar, no operar
- Fase 2 (Horas 3-4): Identificar manipulaci\u00f3n
- Fase 3 (Horas 5+): Operar el movimiento real

---

## Smart Money Concepts (SMC)

### Fundamentos SMC

SMC es una metodolog\u00eda que se enfoca en la estructura del mercado y c\u00f3mo el dinero institucional crea setups de trading.

### 1. Change of Character (CHOCH)

**Definici\u00f3n:** Cambio en la estructura del mercado que indica posible reversi\u00f3n

#### CHOCH Bullish

```
ESTRUCTURA BAJISTA → CHOCH → ESTRUCTURA ALCISTA

Lower High    Lower High
    \            /
     \          /
      \        /        Higher High
       \      /            /\
        \    /            /  \
         \  /     CHOCH  /    \
    Lower Low          /      \
              \       /        \
               \     /          \
                \   /    Higher Low
                 \ /
            Lower Low
```

**Criterios:**
1. Mercado en tendencia bajista (lower highs, lower lows)
2. Precio rompe \u00faltimo lower high
3. Formaci\u00f3n de higher low
4. **CHOCH confirmado** cuando precio supera previous high

#### CHOCH Bearish

```
ESTRUCTURA ALCISTA → CHOCH → ESTRUCTURA BAJISTA

Higher Low   Higher Low
    /            \
   /              \
  /                \        Lower Low
 /                  \          /
/              CHOCH \        /
    Higher High       \      /
                       \    /
                        \  /    Lower High
                         \/
                   Higher High
```

#### Implementaci\u00f3n

```python
def detect_choch(df, window=20):
    """
    Detecta Change of Character
    """
    choch_signals = []

    for i in range(window * 2, len(df)):
        # Identify recent swings
        recent = df.iloc[i-window:i]

        # Swing highs/lows
        swing_highs = recent[recent['high'] == recent['high'].rolling(5, center=True).max()]
        swing_lows = recent[recent['low'] == recent['low'].rolling(5, center=True).min()]

        if len(swing_highs) >= 2 and len(swing_lows) >= 2:
            # Check for bullish CHOCH
            # Previous structure: lower lows
            prev_lows = swing_lows['low'].values[-2:]
            if prev_lows[1] < prev_lows[0]:
                # Break of previous high
                prev_high = swing_highs['high'].values[-2]
                if df['close'].iloc[i] > prev_high:
                    choch_signals.append({
                        'type': 'bullish_choch',
                        'index': i,
                        'price': df['close'].iloc[i],
                        'broken_level': prev_high
                    })

            # Check for bearish CHOCH
            # Previous structure: higher highs
            prev_highs = swing_highs['high'].values[-2:]
            if prev_highs[1] > prev_highs[0]:
                # Break of previous low
                prev_low = swing_lows['low'].values[-2]
                if df['close'].iloc[i] < prev_low:
                    choch_signals.append({
                        'type': 'bearish_choch',
                        'index': i,
                        'price': df['close'].iloc[i],
                        'broken_level': prev_low
                    })

    return choch_signals
```

### 2. Break of Structure (BOS)

**Definici\u00f3n:** Continuaci\u00f3n de la estructura existente, confirmando la tendencia

#### BOS Bullish (Continuaci\u00f3n alcista)

```
Higher High #2
      /\
     /  \
    /    \
   /      \      Higher High #1
  /        \        /\
 /          \      /  \
/     BOS    \    /    \
      →       \  /      \
               \/        \
         Higher Low       \
                           \
                    Higher Low
```

**Criterios:**
1. Tendencia alcista establecida
2. Precio rompe previous higher high
3. **BOS confirmado**
4. Esperar pullback para entrada

#### BOS Bearish (Continuaci\u00f3n bajista)

```
Lower Low #1
    \
     \        Lower Low #2
      \          /
       \        /
        \      /
         \    /      BOS
          \  /        ←
           \/
     Lower High
              \
               \
          Lower High
```

#### Diferencia BOS vs CHOCH

| Aspecto | BOS | CHOCH |
|---------|-----|-------|
| **Direcci\u00f3n** | Continuaci\u00f3n | Reversi\u00f3n |
| **Estructura** | Confirma tendencia | Rompe tendencia |
| **Trading** | Entrar en direcci\u00f3n del BOS | Entrar contra tendencia previa |
| **Riesgo** | Menor (con tendencia) | Mayor (contra tendencia) |

#### Implementaci\u00f3n

```python
def detect_bos(df, window=20):
    """
    Detecta Break of Structure
    """
    bos_signals = []

    for i in range(window * 2, len(df)):
        recent = df.iloc[i-window:i]

        # Swing points
        swing_highs = recent[recent['high'] == recent['high'].rolling(5, center=True).max()]
        swing_lows = recent[recent['low'] == recent['low'].rolling(5, center=True).min()]

        if len(swing_highs) >= 2 and len(swing_lows) >= 2:
            # Bullish BOS (uptrend continuation)
            prev_highs = swing_highs['high'].values[-2:]
            prev_lows = swing_lows['low'].values[-2:]

            # Check for higher highs and higher lows
            if prev_highs[1] > prev_highs[0] and prev_lows[1] > prev_lows[0]:
                # Current price breaks recent high
                if df['close'].iloc[i] > prev_highs[1]:
                    bos_signals.append({
                        'type': 'bullish_bos',
                        'index': i,
                        'price': df['close'].iloc[i],
                        'broken_level': prev_highs[1],
                        'trend': 'uptrend'
                    })

            # Bearish BOS (downtrend continuation)
            if prev_highs[1] < prev_highs[0] and prev_lows[1] < prev_lows[0]:
                # Current price breaks recent low
                if df['close'].iloc[i] < prev_lows[1]:
                    bos_signals.append({
                        'type': 'bearish_bos',
                        'index': i,
                        'price': df['close'].iloc[i],
                        'broken_level': prev_lows[1],
                        'trend': 'downtrend'
                    })

    return bos_signals
```

### 3. Inducement

**Definici\u00f3n:** Movimiento falso dise\u00f1ado para atraer traders retail antes de la reversi\u00f3n real

#### Tipos de Inducement

**Bullish Inducement (antes de subida):**
```
                    ┌─── Real Move (Up)
                    │
                   /
                  /
    ────────────/────────── Resistance
               /
              /
    ─────────┼────────────── Support
             │\
             │ \
             │  └─ Inducement (falso break down)
             │     [Trap para cortos]
             ▼
      [Stop Loss Hunt]
```

**Bearish Inducement (antes de caída):**
```
      [Stop Loss Hunt]
             ▲
             │
             │  ┌─ Inducement (falso break up)
             │ /   [Trap para largos]
             │/
    ─────────┼────────────── Resistance
              \
               \
    ────────────\────────── Support
                 \
                  \
                   └─── Real Move (Down)
```

#### Caracter\u00edsticas

1. **Falso breakout** de nivel clave
2. **R\u00e1pida reversi\u00f3n** (1-3 candles)
3. **Caza de stops** de traders retail
4. **Precede** al movimiento real

#### Detecci\u00f3n

```python
def detect_inducement(df, key_levels, window=5):
    """
    Detecta movimientos de inducement
    """
    inducements = []

    for i in range(window, len(df)):
        # Check for false breakouts of key levels
        for level in key_levels:
            # Bullish inducement (false breakdown)
            if df['low'].iloc[i] < level['price'] * 0.998:
                # Rapid reversal
                if df['close'].iloc[i] > level['price']:
                    # Confirm reversal continues
                    if i < len(df) - 2:
                        next_closes = df['close'].iloc[i+1:i+3]
                        if (next_closes > level['price']).all():
                            inducements.append({
                                'type': 'bullish_inducement',
                                'index': i,
                                'level': level['price'],
                                'low': df['low'].iloc[i],
                                'close': df['close'].iloc[i],
                                'expected_move': 'up'
                            })

            # Bearish inducement (false breakout)
            elif df['high'].iloc[i] > level['price'] * 1.002:
                # Rapid reversal
                if df['close'].iloc[i] < level['price']:
                    # Confirm reversal continues
                    if i < len(df) - 2:
                        next_closes = df['close'].iloc[i+1:i+3]
                        if (next_closes < level['price']).all():
                            inducements.append({
                                'type': 'bearish_inducement',
                                'index': i,
                                'level': level['price'],
                                'high': df['high'].iloc[i],
                                'close': df['close'].iloc[i],
                                'expected_move': 'down'
                            })

    return inducements
```

### 4. Displacement

**Definici\u00f3n:** Movimiento r\u00e1pido y fuerte que indica entrada de dinero institucional

#### Caracter\u00edsticas de Displacement

```
Displacement Bullish:
                          ┌── Strong momentum
                         /│
                        / │
                       /  │   Large candles
                      /   │
                     /    │   High volume
    ────────────────/─────┴────────
                   /
                  │  Displacement
                  │  (3-5 candles up)
                  │
           [Institutional Entry]
```

**Criterios:**
1. **3-5 candles** consecutivos en misma direcci\u00f3n
2. **Cuerpos grandes** (> 70% del rango)
3. **Volumen alto** (> 1.5x promedio)
4. **Movimiento > 1.5 * ATR**
5. **Sin retrocesos** significativos

#### Implementaci\u00f3n

```python
def detect_displacement(df, min_candles=3, min_atr_multiple=1.5):
    """
    Detecta movimientos de displacement
    """
    atr = calculate_atr(df, 14)
    displacements = []

    for i in range(min_candles, len(df)):
        # Check last N candles
        recent = df.iloc[i-min_candles:i+1]

        # Bullish displacement
        all_bullish = (recent['close'] > recent['open']).all()
        large_bodies = ((recent['close'] - recent['open']).abs() / (recent['high'] - recent['low']) > 0.7).all()
        high_volume = (recent['volume'] > recent['volume'].rolling(20).mean() * 1.5).any()
        strong_move = (recent['close'].iloc[-1] - recent['close'].iloc[0]) > (atr.iloc[i] * min_atr_multiple)

        if all_bullish and large_bodies and high_volume and strong_move:
            displacements.append({
                'type': 'bullish_displacement',
                'index': i,
                'start_price': recent['close'].iloc[0],
                'end_price': recent['close'].iloc[-1],
                'move_size': recent['close'].iloc[-1] - recent['close'].iloc[0],
                'candles': min_candles,
                'strength': (recent['close'].iloc[-1] - recent['close'].iloc[0]) / atr.iloc[i]
            })

        # Bearish displacement
        all_bearish = (recent['close'] < recent['open']).all()
        strong_move_down = (recent['close'].iloc[0] - recent['close'].iloc[-1]) > (atr.iloc[i] * min_atr_multiple)

        if all_bearish and large_bodies and high_volume and strong_move_down:
            displacements.append({
                'type': 'bearish_displacement',
                'index': i,
                'start_price': recent['close'].iloc[0],
                'end_price': recent['close'].iloc[-1],
                'move_size': recent['close'].iloc[0] - recent['close'].iloc[-1],
                'candles': min_candles,
                'strength': (recent['close'].iloc[0] - recent['close'].iloc[-1]) / atr.iloc[i]
            })

    return displacements
```

### 5. Liquidity Voids

**Definici\u00f3n:** Zonas con muy poco volumen donde precio se movi\u00f3 r\u00e1pido (similar a FVG pero con enfoque en volumen)

```
High Volume Node
    │
    ▼
────────────────
               │
               │ Liquidity Void
               │ (low volume area)
               │
    ┌──────────┘
    │
────┴────────────
    │
Low Volume Node
```

**Uso:**
- Voids act\u00faan como im\u00e1n para el precio
- Alta probabilidad de que precio vuelva a rellenar
- Zonas de entrada de bajo riesgo

---

## Estrategia de Confluence

### Concepto de Confluence

**Confluence = Confluencia de m\u00faltiples factores alcistas/bajistas**

Cuantos m\u00e1s factores apunten en la misma direcci\u00f3n, mayor probabilidad de \u00e9xito.

### Sistema de Scoring

#### Factores Alcistas (Bullish Confluence)

| Factor | Peso | Criterio |
|--------|------|----------|
| **AMD Phase** | 25% | Accumulation confirmada |
| **ICT OTE** | 20% | Precio en discount zone (21-38%) |
| **ICT Killzone** | 15% | London Open o NY AM |
| **SMC CHOCH** | 15% | Bullish CHOCH reciente |
| **Order Block** | 10% | Bullish OB cerca |
| **FVG** | 5% | Bullish FVG sin rellenar |
| **Liquidity** | 5% | SSL sweep reciente |
| **Displacement** | 5% | Bullish displacement |

#### C\u00e1lculo de Confluence Score

```python
def calculate_confluence_score(signals):
    """
    Calcula score de confluence (0-1)
    """
    weights = {
        'amd_accumulation': 0.25,
        'ict_ote_discount': 0.20,
        'ict_killzone_high': 0.15,
        'smc_bullish_choch': 0.15,
        'order_block_bullish': 0.10,
        'fvg_bullish': 0.05,
        'ssl_sweep': 0.05,
        'displacement_bullish': 0.05
    }

    score = 0.0
    active_signals = []

    for signal, weight in weights.items():
        if signals.get(signal, False):
            score += weight
            active_signals.append(signal)

    return {
        'score': score,
        'active_signals': active_signals,
        'num_confirmations': len(active_signals),
        'bias': 'bullish' if score >= 0.6 else 'neutral'
    }
```

### Niveles de Confluence

| Score | Nivel | Acci\u00f3n |
|-------|-------|---------|
| **0.80-1.00** | Excelente | Tama\u00f1o de posici\u00f3n completo |
| **0.60-0.79** | Buena | Tama\u00f1o de posici\u00f3n reducido (70%) |
| **0.40-0.59** | Media | Solo operar con confirmaci\u00f3n adicional |
| **0.00-0.39** | Baja | Evitar entrada |

### Ejemplo de Setup de Alta Confluence

```
BTCUSDT - 2024-12-05 09:30 EST

FACTORES ALCISTAS ACTIVOS:
✓ AMD Phase: Accumulation (confidence: 0.78)
✓ ICT OTE: Precio en 32% del rango (discount)
✓ ICT Killzone: NY AM (09:30)
✓ SMC CHOCH: Bullish CHOCH hace 15 min
✓ Order Block: Bullish OB a $89,200
✓ SSL Sweep: Sweep de low hace 30 min

CONFLUENCE SCORE: 0.85 (Excelente)

SETUP:
Entry: $89,350
Stop Loss: $89,150 (below SSL sweep)
Take Profit: $90,100 (weekly high)
R:R: 3.75:1

RESULTADO:
TP alcanzado en 2.5 horas
+$750 (+0.84%)
```

---

## Integraci\u00f3n AMD + ICT + SMC

### Framework Unificado

```
┌─────────────────────────────────────────────────────┐
│              ANÁLISIS MULTI-LAYER                   │
├─────────────────────────────────────────────────────┤
│                                                     │
│  LAYER 1: AMD (Fase del Mercado)                   │
│  ├─ Accumulation / Manipulation / Distribution     │
│  └─ Determina DIRECCI\u00d3N general                   │
│                                                     │
│  LAYER 2: ICT (Timing & Zonas)                     │
│  ├─ Killzones (CU\u00c1NDO operar)                     │
│  ├─ OTE Zones (D\u00d3NDE entrar)                       │
│  └─ Premium/Discount (PRECIO)                      │
│                                                     │
│  LAYER 3: SMC (Estructura & Confirmaci\u00f3n)         │
│  ├─ BOS/CHOCH (Estructura)                         │
│  ├─ Inducement (Trampas)                           │
│  └─ Displacement (Fuerza)                          │
│                                                     │
│  LAYER 4: ML Models (Predicci\u00f3n)                  │
│  ├─ RangePredictor (Delta High/Low)                │
│  ├─ TPSLClassifier (Probabilidad TP)               │
│  └─ SignalGenerator (Se\u00f1al final)                 │
│                                                     │
└─────────────────────────────────────────────────────┘
```

### Decision Tree

```python
def unified_trading_decision(market_data, models):
    """
    Framework unificado de decisi\u00f3n
    """
    decision = {
        'action': 'hold',
        'confidence': 0.0,
        'reasoning': []
    }

    # LAYER 1: AMD Phase
    amd_phase = models['amd_detector'].detect_phase(market_data)
    if amd_phase['phase'] == 'accumulation' and amd_phase['confidence'] > 0.7:
        decision['reasoning'].append('AMD: Strong accumulation phase')
        decision['confidence'] += 0.25
        decision['bias'] = 'bullish'
    elif amd_phase['phase'] == 'distribution' and amd_phase['confidence'] > 0.7:
        decision['reasoning'].append('AMD: Strong distribution phase')
        decision['confidence'] += 0.25
        decision['bias'] = 'bearish'
    else:
        decision['reasoning'].append(f'AMD: {amd_phase["phase"]} (low conviction)')
        return decision  # Exit early if no clear phase

    # LAYER 2: ICT
    killzone = identify_killzone(market_data['timestamp'].iloc[-1])
    if is_high_probability_killzone(killzone):
        decision['reasoning'].append(f'ICT: High probability killzone ({killzone})')
        decision['confidence'] += 0.15

    ote_zones = calculate_ote_zones(
        market_data['high'].tail(50).max(),
        market_data['low'].tail(50).min()
    )
    current_price = market_data['close'].iloc[-1]
    position, zone = calculate_premium_discount(
        current_price,
        ote_zones['fib_100'],
        ote_zones['fib_0']
    )

    if decision['bias'] == 'bullish' and zone in ['discount', 'extreme_discount']:
        decision['reasoning'].append(f'ICT: Price in {zone} zone (good buy area)')
        decision['confidence'] += 0.20
    elif decision['bias'] == 'bearish' and zone in ['premium', 'extreme_premium']:
        decision['reasoning'].append(f'ICT: Price in {zone} zone (good sell area)')
        decision['confidence'] += 0.20

    # LAYER 3: SMC
    choch_signals = detect_choch(market_data)
    bos_signals = detect_bos(market_data)

    if decision['bias'] == 'bullish':
        bullish_choch = [s for s in choch_signals if s['type'] == 'bullish_choch']
        if bullish_choch and len(bullish_choch) > 0:
            decision['reasoning'].append('SMC: Recent bullish CHOCH')
            decision['confidence'] += 0.15

        bullish_bos = [s for s in bos_signals if s['type'] == 'bullish_bos']
        if bullish_bos:
            decision['reasoning'].append('SMC: Bullish BOS confirms uptrend')
            decision['confidence'] += 0.10

    # LAYER 4: ML Predictions
    range_pred = models['range_predictor'].predict(market_data)
    tpsl_pred = models['tpsl_classifier'].predict(market_data, current_price)

    if decision['bias'] == 'bullish':
        if range_pred['delta_high'] > range_pred['delta_low'] * 2:
            decision['reasoning'].append('ML: Range predictor favors upside')
            decision['confidence'] += 0.15

        relevant_tpsl = [p for p in tpsl_pred if p.recommended_action == 'long']
        if relevant_tpsl and relevant_tpsl[0].prob_tp_first > 0.65:
            decision['reasoning'].append(f'ML: High TP probability ({relevant_tpsl[0].prob_tp_first:.2%})')
            decision['confidence'] += 0.15

    # Final decision
    if decision['confidence'] >= 0.70:
        decision['action'] = 'long' if decision['bias'] == 'bullish' else 'short'
    elif decision['confidence'] >= 0.50:
        decision['action'] = 'wait_confirmation'
    else:
        decision['action'] = 'hold'

    return decision
```

---

## Implementaci\u00f3n en ML

### Features Derivados de ICT/SMC

```python
# Features ICT
ict_features = {
    # OTE
    'ote_position': position_in_range,  # 0-1
    'in_discount_zone': 1 if position < 0.38 else 0,
    'in_premium_zone': 1 if position > 0.62 else 0,
    'in_ote_buy_zone': 1 if 0.62 <= position <= 0.79 else 0,
    'in_ote_sell_zone': 1 if 0.21 <= position <= 0.38 else 0,

    # Killzones
    'is_london_kz': 1 if killzone == 'london_open' else 0,
    'is_ny_kz': 1 if killzone == 'ny_am' else 0,
    'killzone_strength': session_strength,

    # Ranges
    'weekly_range_position': weekly_position,
    'daily_range_position': daily_position,
    'range_expansion': current_range / average_range,

    # Market Maker Models
    'mmsm_detected': 1 if mm_model == 'MMSM' else 0,
    'mmbm_detected': 1 if mm_model == 'MMBM' else 0,
}

# Features SMC
smc_features = {
    # Structure
    'choch_bullish_recent': count_recent_bullish_choch(),
    'choch_bearish_recent': count_recent_bearish_choch(),
    'bos_bullish_recent': count_recent_bullish_bos(),
    'bos_bearish_recent': count_recent_bearish_bos(),

    # Inducement
    'inducement_detected': 1 if inducement_count > 0 else 0,
    'inducement_type': encode_inducement_type(),

    # Displacement
    'displacement_strength': displacement_atr_multiple,
    'displacement_direction': 1 if displacement == 'bullish' else -1 if displacement == 'bearish' else 0,

    # Liquidity
    'liquidity_void_proximity': distance_to_nearest_void,
    'void_fill_probability': calculate_void_fill_prob(),
}

# Combined feature vector
all_features = {
    **base_technical_features,
    **amd_features,
    **ict_features,
    **smc_features
}
```

### Target Engineering

```python
def label_with_confluence(df, i, forward_window=18):
    """
    Etiqueta considerando confluence de se\u00f1ales
    """
    future = df.iloc[i:i+forward_window]

    # Calculate confluence at time i
    confluence = calculate_confluence_score({
        'amd_accumulation': check_amd_accumulation(df, i),
        'ict_ote_discount': check_ote_discount(df, i),
        'ict_killzone_high': check_high_prob_killzone(df, i),
        'smc_bullish_choch': check_bullish_choch(df, i),
        # ... otros
    })

    # Success criteria based on confluence
    if confluence['score'] >= 0.7:
        # High confluence → higher target
        target_move = future['high'].max() / df['close'].iloc[i] - 1
        if target_move >= 0.015:  # 1.5% move
            return 1  # Strong buy
        elif target_move >= 0.008:  # 0.8% move
            return 0.5  # Weak buy
    elif confluence['score'] >= 0.5:
        # Medium confluence → normal target
        target_move = future['high'].max() / df['close'].iloc[i] - 1
        if target_move >= 0.01:  # 1% move
            return 1

    return 0  # No signal
```

---

## Referencias

### ICT Resources

1. **Inner Circle Trader YouTube** - Free educational series
2. **ICT Mentorship 2022** - Comprehensive course
3. **The Forex Mindset** - ICT concepts breakdown

### SMC Resources

4. **The Trading Channel** - SMC tutorials
5. **Stacey Burke Trading** - SMC + price action
6. **GCT (Global Capital Trading)** - SMC framework

### Combined Methodologies

7. **Trading Rush** - AMD + ICT integration
8. **Forex Mastery** - Multi-concept confluence
9. **The Secret Mindset** - Institutional trading logic

### Academic Background

10. Harris, L. (2003). "Trading and Exchanges" - Market microstructure
11. Aldridge, I. (2013). "High-Frequency Trading" - Institutional behavior
12. Narang, R. (2013). "Inside the Black Box" - Quant strategies

---

**Documento Generado:** 2025-12-05
**Pr\u00f3xima Revisi\u00f3n:** 2025-Q1
**Contacto:** trading-strategist@trading.ai
