¿Cómo detectar patrones de candelas con TA-Lib y fórmulas en Python?

Los patrones de candelas desempeñan un papel fundamental en el análisis técnico, ofreciendo información sobre posibles movimientos del mercado basados en datos históricos de precios. Los traders y analistas suelen confiar en estos patrones para tomar decisiones informadas, ya sea para comprar, vender o mantener activos. Pero ¿cómo se pueden identificar estos patrones de manera programática, especialmente utilizando Python?

En este artículo, nos adentraremos en el fascinante mundo de los patrones de candelas y exploraremos dos formas diferentes de identificarlos en Python. Primero, aprovecharemos el poder de la biblioteca Ta-Lib, una herramienta popular entre los analistas financieros. Luego, daremos un paso más allá al definir manualmente fórmulas para detectar estos patrones por nuestra cuenta.

Pero antes de sumergirnos en el código, repasemos rápidamente algunos de los patrones clave de velas en los que nos centraremos:

• Doji: Este patrón se forma cuando los precios de apertura y cierre de un valor son prácticamente iguales, creando una forma de cruz o signo de más. Indica indecisión en el mercado y a menudo precede a una reversión del precio.
• Harami: Un patrón de dos velas en el que una vela de cuerpo pequeño está completamente contenida dentro del cuerpo grande de la vela anterior. Este patrón sugiere una posible reversión, y su dirección depende de si aparece en una tendencia alcista o bajista.
• Envolvente: Este patrón ocurre cuando una candela más grande “engulle” completamente el cuerpo de la vela anterior. Un envolvente alcista sugiere una posible reversión al alza, mientras que un envolvente bajista indica una posible reversión a la baja.
• Morning Star (Estrella del Amanecer): Un patrón de tres candelas que señala el final de una tendencia bajista y el inicio de una tendencia alcista. Comienza con una vela bajista grande, seguida de una vela de cuerpo pequeño (que puede ser alcista o bajista) y termina con una vela alcista grande.
• Hammer (Martillo): Un patrón de una sola vela que tiene un cuerpo pequeño con una sombra inferior larga. Suele aparecer en el fondo de una tendencia bajista y sugiere una posible reversión al alza.

Uso de Ta-Lib para Identificar Patrones de Velas

Ahora que tenemos un conocimiento básico de estos patrones, adentrémonos en cómo podemos usar la biblioteca Ta-Lib en Python para identificarlos.

Primero, necesitaremos importar las bibliotecas necesarias y descargar datos históricos para el índice S&P500. Ta-Lib facilita enormemente el reconocimiento de patrones al proporcionar funciones predefinidas para cada uno de ellos.

import pandas as pd
import yfinance as yf
import talib

sp500_ticker = "^GSPC"

df = yf.download(sp500_ticker, start="2025-01-10", end="2025-02-14", interval='5m')

Estamos utilizando la biblioteca yfinance para descargar datos históricos del mercado para el índice S&P 500, representado por el ticker ^GSPC. Específicamente, estamos obteniendo datos desde el 10 de enero de 2025 hasta el 14 de febrero de 2025, donde cada punto de datos representa un intervalo de 5 minutos.

op = df['Open'].astype(float)
hi = df['High'].astype(float)
lo = df['Low'].astype(float)
cl = df['Close'].astype(float)

op, hi, lo, cl: Estas variables almacenan los precios de ‘Apertura’ (Open), ‘Máximo’ (High), ‘Mínimo’ (Low) y ‘Cierre’ (Close) del dataframe. Convertimos estos valores a tipo float para garantizar la compatibilidad con las funciones de Ta-Lib, ya que Ta-Lib requiere entradas numéricas para realizar sus cálculos.

df['DOJI'] = talib.CDLDOJI(op, hi, lo, cl)
df['Engulfing'] = talib.CDLENGULFING(op, hi, lo, cl)
df['HAMMER'] = talib.CDLHAMMER(op, hi, lo, cl)
df['HANGINGMAN'] = talib.CDLHANGINGMAN(op, hi, lo, cl)
df['HARAMI'] = talib.CDLHARAMI(op, hi, lo, cl)
df['MORNINGSTAR'] = talib.CDLMORNINGSTAR(op, hi, lo, cl)

Cada una de estas funciones (por ejemplo, CDLDOJI, CDLENGULFING, etc.) es parte de Ta-Lib y está diseñada para detectar patrones específicos de velas. Cuando se identifica un patrón en un día (o período) determinado, la función devuelve un valor distinto de cero para esa fila específica en el dataframe.

Por ejemplo, CDLDOJI(op, hi, lo, cl) devolverá 100, -100 o 0 dependiendo de si se identifica un patrón Doji. Los valores positivos suelen indicar un patrón alcista, mientras que los valores negativos indican un patrón bajista.

# Conteo de ocurrencias para cada patrón
pattern_counts = df[['DOJI', 'Engulfing', 'HAMMER', 'HANGINGMAN',
                    'HARAMI',
                    'MORNINGSTAR']].apply(lambda x: x[x != 0].count())

print("Patrones de Velas Identificados Durante el Período Dado:")
print(pattern_counts)

apply(lambda x: x[x != 0].count()): La función lambda recorre cada columna correspondiente a un patrón de candelas y cuenta el número de entradas distintas de cero. Un valor distinto de cero en estas columnas indica que se ha identificado el patrón correspondiente en esa fila específica (marca de tiempo).

Gráfico de Velas del S&P 500 Resaltando Patrones Detectados con Ta-Lib: Doji, Engulfing, Harami — Visualización del Reconocimiento de Patrones con Horas No Comerciales Omitidas

Identificación de Patrones de Candelas mediante Fórmulas

En la primera parte de nuestro análisis, exploramos cómo identificar patrones clave de velas utilizando la biblioteca Ta-Lib en Python. Ahora, vamos a cambiar de enfoque y adentrarnos en la identificación de estos patrones de manera manual, implementando las fórmulas subyacentes directamente en nuestro código. Este método nos brinda mayor control y flexibilidad sobre el proceso de detección de patrones, permitiendo ajustes personalizados y una comprensión más profunda de cómo se forman estos patrones.

Desglosemos el proceso de identificación de varios patrones de velas utilizando fórmulas personalizadas y la biblioteca numpy.

Cálculo de Métricas Adicionales: AVGH10, AVGL10, MINL10 y STOC1

Para identificar patrones como el Doji, Engulfing, Morning Star, Harami y Hammer, primero necesitamos calcular varias métricas que se utilizarán en nuestras fórmulas de reconocimiento de patrones:

AVGH10 = df[‘High’].rolling(window=10).mean()

AVGL10 = df[‘Low’].rolling(window=10).mean()

MINL10 = df[‘Low’].rolling(window=10).min()

STOC1 = 100 * (df[‘Close’] – MINL10) / (AVGH10 – MINL10)

• AVGH10: Esta es la media móvil de 10 períodos de los precios máximos. Nos proporciona el promedio de los máximos durante las últimas 10 velas.
• AVGL10: De manera similar, esta es la media móvil de 10 períodos de los precios mínimos.
• MINL10: Esta métrica representa el precio mínimo más bajo durante los últimos 10 períodos.
• STOC1: El oscilador estocástico es un indicador de momentum que compara el precio de cierre con el rango de precios durante un período determinado. Aquí, lo calculamos utilizando la fórmula para %K: STOC1 = 100 * (df[‘Close’] – MINL10) / (AVGH10 – MINL10).

Identificación del patrón Doji

df['DOJI'] = np.where(
   (20 * abs(df['Open'] - df['Close']) <= df['High'] - df['Low']) &
   (~df[['High', 'Low', 'Open', 'Close']].isna().any(axis=1)),
   1,
   0
) 

Identificación del Doji: Un patrón doji (dо̄ji) es el nombre que se le da a una sesión de trading en la que un valor tiene niveles de apertura y cierre prácticamente iguales, representados por una forma de cruz en un gráfico. En nuestra fórmula:

20 * abs(df[‘Open’] – df[‘Close’]) <= df[‘High’] – df[‘Low’]: Esto verifica si la diferencia entre los precios de apertura y cierre es pequeña en relación con el rango de la vela (Máximo – Mínimo). Multiplicar por 20 enfatiza el requisito de que el cuerpo de la vela sea pequeño.

La función np.where se utiliza para asignar un valor de 1 donde se identifica el patrón Doji y 0 en caso contrario.

Identificación del Patrón Engulfing Alcista

O1 = df['Open'].shift(1)
C1 = df['Close'].shift(1)

df['Engulfing'] = np.where(
   (O1 > C1) &
   (10 * (df['Close'] - df['Open']) >= 7 * (df['High'] - df['Low'])) &
   (df['Close'] > O1) &
   (C1 > df['Open']) &
   (10 * (df['High'] - df['Low']) >= 12 * (AVGH10 - AVGL10)) &
   (~np.isnan(AVGH10) & ~np.isnan(AVGL10)),
   1,
   0
)

Identificación del Patrón Engulfing: El patrón Engulfing generalmente implica una vela grande que “engulle” la vela más pequeña anterior.

• (O1 > C1): Esto verifica que la vela anterior fue bajista (Apertura > Cierre).
• 10 * (df[‘Close’] – df[‘Open’]) >= 7 * (df[‘High’] – df[‘Low’]): Esto asegura que la vela actual sea significativamente más grande que la anterior.

Identificación del patrón Morning Star

O2 = df['Open'].shift(2)
C2 = df['Close'].shift(2)
H2 = df['High'].shift(2)
L2 = df['Low'].shift(2)

df['MorningStar'] = np.where(
   (O2 > C2) &
   (5 * (O2 - C2) > 3 * (H2 - L2)) &
   (C2 > O1) &
   (2 * abs(O1 - C1) < abs(O2 - C2)) & (H1 - L1 > 3 * (C1 - O1)) &
   (df['Close'] > df['Open']) &
   (df['Open'] > O1) &
   (df['Open'] > C1) &
   ((~np.isnan(O2) & ~np.isnan(C2) & ~np.isnan(O1) & ~np.isnan(H1))),
   1,
   0
)

Identificación del patrón Estrella del Amanecer (Morning Star): La formación Morning Star es un patrón de tres candelas que señala una posible reversión de una tendencia bajista a una alcista.

• (O2 > C2): La primera candela es bajista.
• (5 * (O2 – C2) > 3 * (H2 – L2)): El cuerpo de la primera vela debe ser relativamente grande.
• (C2 > O1): La segunda candela (de cuerpo pequeño o un Doji) muestra indecisión.
• (df[‘Close’] > df[‘Open’]): La tercera candela es alcista, confirmando la reversión.

Identificación del patrón Harami

AVGH10_1 = df['High'].shift(1).rolling(window=10).mean()
AVGL10_1 = df['Low'].shift(1).rolling(window=10).mean()

df['Harami'] = np.where(
   (10 * (O1 - C1) >= 7 * (H1 - L1)) &
   (H1 - L1 >= AVGH10_1 - AVGL10_1) &
   (df['Close'] > df['Open']) &
   (df['Open'] > C1) &
   (O1 > df['Close']) &
   (6 * (O1 - C1) >= 10 * (df['Close'] - df['Open'])),
   1,
   0
)

Identificación del Patrón Harami: El patrón Harami se caracteriza por una vela más pequeña que encaja completamente dentro del cuerpo de la vela anterior más grande.

• La fórmula verifica que la candela anterior sea relativamente grande (O1 – C1 >= 7 * (H1 – L1)).
• La candela actual es más pequeña (6 * (O1 – C1) >= 10 * (df[‘Close’] – df[‘Open’])).

Resumen de los Patrones Identificados

Detectamos varios patrones clave de velas utilizando fórmulas personalizadas. El patrón DOJI apareció 100 veces, lo que indica indecisión en el mercado. El patrón Engulfing se encontró 30 veces, sugiriendo posibles reversiones. También identificamos el patrón Hammer 3 veces, el Harami 23 veces y la Estrella del Amanecer (Morning Star) 4 veces, cada uno señalando posibles cambios de tendencia.

Conclusión

En este blog, exploramos dos métodos para identificar patrones de velas en Python: utilizando la biblioteca Ta-Lib y fórmulas personalizadas. Ambos enfoques identificaron con éxito patrones clave como el Doji, Engulfing, Hammer, Harami y la Estrella del Amanecer (Morning Star), aunque la frecuencia de detección varió.

Las diferencias en los conteos de patrones resaltan la importancia de comprender los algoritmos y condiciones subyacentes en el reconocimiento de patrones. Mientras que Ta-Lib ofrece una solución rápida y completa, las fórmulas personalizadas brindan un enfoque más ajustado, proporcionando una comprensión más profunda del comportamiento del mercado.

Cada método tiene sus ventajas, dependiendo de si necesitas una implementación rápida o un análisis más granular y personalizado. En cualquier caso, la identificación programática de patrones de velas puede mejorar significativamente tus estrategias de trading y análisis de mercado.