Calculadora de equity Monte Carlo para póker en Python

Una calculadora de equity Monte Carlo es una de las primeras mejoras matemáticas que cambia de verdad las decisiones de un bot de póker. En lugar de pensar «tengo un proyecto, quizá deba pagar», el bot puede estimar con qué frecuencia gana, comparar ese porcentaje con las pot odds y evitar conjeturas costosas.

Parte de: La guía completa para crear un bot de póker con IA en 2026, la guía principal sobre frameworks, lógica de decisión, equity, pruebas y dónde competir.

Conclusiones clave

• Las simulaciones Monte Carlo estiman la equity al muestrear las cartas desconocidas de los rivales y las futuras cartas comunitarias.
• Open Poker entrega al bot el bote y el importe exacto del call en your_turn, de modo que la equity se puede comparar directamente con las pot odds.
• Empieza con 2000 a 5000 simulaciones por decisión. Aumentar la muestra mejora la precisión, pero también incrementa la latencia.

¿Qué resuelve la equity de Monte Carlo?

La equity Monte Carlo cubre la distancia entre unas reglas aproximadas y todas las combinaciones posibles de cartas futuras. En Open Poker, el bot dispone de 120 segundos para actuar y recibe el bote, las cartas comunitarias, las acciones válidas y el token del turno en cada mensaje your_turn (documentación de acciones de Open Poker). Con esos datos puede estimar si un call es rentable antes de enviar la acción.

La calculadora responde a una pregunta: si repartimos muchas veces las cartas desconocidas, ¿con qué frecuencia gana mi mano o divide el bote? Ese porcentaje es la equity.

Si el bote es de 300 y el call cuesta 100, las pot odds son:

100 / (300 + 100) = 25%

Si la equity estimada es del 36 %, pagar resulta rentable sin considerar las apuestas posteriores. Si es del 18 %, retirarse ahorra fichas. La cifra no será perfecta, pero es mucho mejor que codificar una regla como «pagar con cualquier proyecto de color».

¿Qué datos necesitas de Open Poker?

Necesitas cuatro datos: las cartas privadas del jugador, las cartas comunitarias, el tamaño del bote y el importe del call. Open Poker envía las cartas comunitarias y el bote en your_turn; el bot debe guardar las cartas privadas que recibe en el mensaje hole_cards. El protocolo WebSocket usa JSON y se puede implementar en cualquier lenguaje (documentación de WebSocket).

def call_amount(valid_actions):
    for action in valid_actions:
        if action["action"] == "call":
            return action["amount"]
    return 0
 
 
def pot_odds(pot, call):
    if call <= 0:
        return 0
    return call / (pot + call)

No calcules el bote por tu cuenta si el servidor ya lo proporciona. Al reconstruir el estado a partir de eventos player_action, es fácil omitir una reconexión, una acción rechazada o algún ajuste secundario. Deja que el servidor mantenga el estado y que el bot se concentre en decidir.

¿Cómo se comparan las manos finales?

Usa StandardHighHand.from_game() de PokerKit para comparar las manos finales de Hold'em. PokerKit admite la evaluación de manos altas estándar y operadores de comparación normales, con ejemplos en sus documentos de evaluación de manos (Evaluación de manos de PokerKit).

from pokerkit import StandardHighHand
 
RANKS = "23456789TJQKA"
SUITS = "cdhs"
DECK = [r + s for r in RANKS for s in SUITS]
 
 
def compact(cards):
    return "".join(cards)
 
 
def best_hand(hole, board):
    return StandardHighHand.from_game(compact(hole), compact(board))

Este pequeño wrapper mantiene legible el resto de la calculadora. Open Poker ya representa las cartas como As, Td y 7c, así que no necesitas un conversor propio salvo que el bot las almacene en otro formato.

Si el rendimiento se convierte en un problema, guarda en caché las cartas ya procesadas. La documentación de PokerKit advierte que analizar cadenas una y otra vez tiene un coste. Para un primer bot, trabajar directamente con ellas está bien. Si ejecutas 10 000 simulaciones por acción en varios bots alojados, conviene medir el rendimiento con un profiler.

¿Cómo se estima la equidad frente a un oponente?

Muestrea las cartas comunitarias que faltan y la mano de un rival, y después compara las manos finales. Con 5000 simulaciones, una calculadora sencilla en Python suele ser lo bastante estable para decidir en una partida de Open Poker. El benchmark de PokerKit supera el millón de evaluaciones estándar de manos altas por segundo en la CPU de un portátil, así que el evaluador no suele ser el primer cuello de botella (documentación de PokerKit).

from random import sample
 
 
def estimate_equity(hero, board=None, opponents=1, trials=5000):
    board = board or []
    known = set(hero + board)
    missing_board = 5 - len(board)
    equity = 0.0
 
    for _ in range(trials):
        deck = [card for card in DECK if card not in known]
        draw_count = opponents * 2 + missing_board
        draw = sample(deck, draw_count)
 
        opp_holes = [
            draw[i * 2 : i * 2 + 2]
            for i in range(opponents)
        ]
        runout = board + draw[opponents * 2 :]
 
        hero_hand = best_hand(hero, runout)
        all_hands = [hero_hand] + [
            best_hand(opp, runout)
            for opp in opp_holes
        ]
 
        winning_hand = max(all_hands)
        winners = [hand for hand in all_hands if hand == winning_hand]
 
        if hero_hand == winning_hand:
            equity += 1 / len(winners)
 
    return equity / trials

La función reparte la equity de los botes divididos. Si tu mano empata con la de un rival, suma media victoria; si hay tres ganadores, suma un tercio. Este detalle aparece más de lo que parece en boards emparejados o con escalera en mesa.

¿Cómo se convierte la equidad en acción?

Compara la equity con las pot odds y añade un pequeño margen de seguridad. Las partidas de Open Poker son 6-max, con ciegas fijas de 10/20 y buy-ins de 1000 a 5000 fichas (documentación de temporadas), por lo que una mala decisión puede costar una parte importante del stack.

def equity_decision(msg, hole_cards, opponents=1):
    actions = {a["action"]: a for a in msg["valid_actions"]}
 
    if "check" in actions:
        return {"action": "check"}
 
    if "call" not in actions:
        return {"action": "fold"}
 
    call = actions["call"]["amount"]
    pot = msg["pot"]
    board = msg.get("community_cards", [])
 
    equity = estimate_equity(
        hero=hole_cards,
        board=board,
        opponents=opponents,
        trials=3000,
    )
 
    required = pot_odds(pot, call)
    margin = 0.03
 
    if equity > required + margin:
        return {"action": "call"}
    return {"action": "fold"}

Esta política sigue siendo pasiva. Hace calls rentables, pero no sube por valor ni lanza semifaroles con proyectos fuertes. Cuando la calculadora funcione, combínala con una estrategia de apuestas para bots de póker.

¿Cuántas pruebas debe ejecutar un bot en vivo?

Empieza con 3000 simulaciones en el flop y el turn, y reduce la cifra si la latencia pesa demasiado. Open Poker permite 20 mensajes WebSocket por segundo y conexión, además de 120 segundos por acción, pero aun así conviene que el bot responda rápido. Un bot lento pierde ventaja si bloquea el bucle de eventos.

Usa diferentes recuentos de pruebas por calle:

La equity preflop contra manos aleatorias no basta por sí sola. También necesitas rangos por posición, porque los rivales no juegan cartas al azar. Usa rangos por posición para bots de póker para limitar las manos que abre el bot antes del flop.

¿Cuáles son las trampas?

El mayor error es interpretar «equity ahora» como «beneficio asegurado». La equity no contempla las apuestas futuras. Un proyecto de color puede tener un 35 % de equity en el flop, pero, si el turn no ayuda y el rival apuesta fuerte, quizá debas retirarte antes de materializarla.

El segundo error es contar mal a los rivales. La equity contra una mano aleatoria no equivale a la equity contra cinco jugadores activos. Los botes multiway perjudican mucho a los proyectos débiles, porque aumenta la probabilidad de que alguien complete una mano mejor. Sube el valor del argumento opponents cuando queden más jugadores en la mano.

El tercer error es ignorar la textura del board y los rangos rivales. Contra oponentes muy loose, asumir manos aleatorias puede aproximarse a la realidad. Contra bots tight, el rango de call será más fuerte que uno aleatorio y la equity estimada resultará demasiado optimista. Ahí empieza a compensar el modelado de oponentes.

¿Cómo mantienes rápida la calculadora?

Para mantener la velocidad, evita trabajo innecesario antes del river. Un bot en vivo no necesita precisión de laboratorio en cada call marginal: necesita acertar con suficiente frecuencia y responder sin bloquear el bucle WebSocket. Para ello sirven la caché, un número de simulaciones distinto por calle y las salidas anticipadas.

Usa tres reglas simples:

equity_cache = {}
 
 
def cached_equity(hero, board, opponents, trials):
    key = (tuple(sorted(hero)), tuple(board), opponents, trials)
    if key not in equity_cache:
        equity_cache[key] = estimate_equity(hero, board, opponents, trials)
    return equity_cache[key]

La caché no tiene que durar para siempre. Límpiala entre manos o limítala a unos cientos de entradas. El objetivo es evitar cálculos repetidos por accidente, no crear una base de datos con todos los estados posibles de Hold'em.

Si el bot usa un LLM para decidir, calcula primero la equity y añade el porcentaje al prompt. Los números reducen la ambigüedad de las decisiones de póker del LLM.

Preguntas frecuentes

¿Es exacta la equity Monte Carlo?

No. Es una estimación basada en muestras. En muchas situaciones se pueden enumerar todas las combinaciones, pero Monte Carlo es más fácil de integrar en un bot en vivo y suficientemente rápido para el límite de 120 segundos por acción de Open Poker.

¿Mi bot debería calcular la equity preflop?

Solo como señal secundaria. Las decisiones preflop deben partir de rangos por posición, porque A9o en el botón no equivale a A9o en UTG. La equity contra cartas aleatorias pasa por alto ese contexto.

¿Puedo usarlo sin PokerKit?

Sí, pero necesitarás otro evaluador de manos. PokerKit ahorra tiempo porque permite construir y comparar manos de Hold'em directamente. Escribir tu propio evaluador puede ser entretenido, pero no suele ser una buena primera decisión para producción.

¿Cómo compruebo si mejora mi bot?

Ejecuta dos versiones durante varios cientos de manos como mínimo: una con la lógica anterior de call y otra con decisiones basadas en equity. Compara las fichas netas, las manos jugadas y las sesiones fallidas mediante las estadísticas y la clasificación de la temporada de Open Poker.