Calculadora de equidade de pôquer com Monte Carlo em Python

Uma calculadora de equidade por Monte Carlo é o primeiro recurso matemático capaz de melhorar decisões reais no pôquer. Em vez de pensar “tenho um draw, talvez seja melhor dar call”, seu bot estima com que frequência vence, compara essa probabilidade com as pot odds e evita calls caros.

Parte de: O guia completo para construir um bot de IA para poker em 2026 - o pilar completo que cobre estruturas, lógica de decisão, equidade, testes e onde competir.

Principais conclusões

• A equidade por Monte Carlo estima a probabilidade de vitória amostrando as cartas desconhecidas dos oponentes e as futuras cartas do board.
• Open Poker informa ao bot o valor exato do pote e do call em your_turn, permitindo usar a equidade diretamente nas decisões baseadas em pot odds.
• Comece com 2.000 a 5.000 simulações por decisão. Uma amostra maior reduz o ruído, mas também aumenta a latência.

O que a equidade por Monte Carlo resolve

A equidade por Monte Carlo preenche a lacuna entre categorias definidas à mão e as cartas que ainda podem sair. No Open Poker, o bot tem 120 segundos para agir e recebe o pote, o board, as ações válidas e o token do turno em cada mensagem your_turn (documentação de ações do Open Poker). Essas informações bastam para estimar se um call é lucrativo antes de enviar a ação.

A calculadora responde à seguinte pergunta: se distribuirmos as cartas desconhecidas milhares de vezes, com que frequência minha mão vence ou divide o pote? Essa frequência é a equidade.

Se o pote for 300 e o call for 100, suas pot odds serão:

100 / (300 + 100) = 25%

Se a equidade estimada for de 36%, o call é lucrativo antes de considerar as apostas futuras. Se for de 18%, o fold economiza fichas. A estimativa não será perfeita, mas é muito melhor do que codificar a regra “dar call com qualquer flush draw”.

Quais informações você precisa do Open Poker

Você precisa de quatro valores: suas hole cards, as cartas comunitárias, o tamanho do pote e o valor do call. Open Poker envia as cartas comunitárias e o pote em your_turn; o bot deve guardar as hole cards recebidas na mensagem privada hole_cards. O protocolo WebSocket usa JSON e pode ser implementado em qualquer linguagem (documentação do 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)

Não recalcule o pote se o servidor já informa esse valor. Ao reconstruir o estado com eventos player_action anteriores, o bot pode ignorar uma reconexão, uma ação rejeitada ou algum detalhe de um side pot. O servidor deve ser a fonte de verdade do estado; o bot deve se concentrar nas decisões.

Como você compara as mãos finais

Use StandardHighHand.from_game() do PokerKit para comparar as mãos finais de Hold'em. A biblioteca oferece avaliação padrão de high hand e operadores comuns de comparação, com exemplos em sua documentação (avaliação de mãos no 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))

Essa pequena função auxiliar mantém o restante da calculadora legível. As cartas do Open Poker já chegam como As, Td e 7c, portanto você só precisará de um conversor se o bot as armazenar em outro formato.

Se o desempenho se tornar um problema, armazene as cartas já processadas em cache. A documentação do PokerKit alerta que analisar strings repetidamente é caro. Para o primeiro bot, usar as strings diretamente é suficiente. Se você executar 10.000 simulações por ação em vários bots hospedados, vale a pena medir o desempenho com um profiler.

Como você estima a equidade contra um oponente

Amostre as cartas que faltam no board e uma mão para o oponente, depois compare as mãos finais. Com 5.000 simulações, uma calculadora simples em Python costuma produzir resultados estáveis o bastante para decisões ao vivo no Open Poker. O benchmark do próprio PokerKit registra mais de um milhão de avaliações padrão por segundo em uma CPU de notebook, portanto o avaliador provavelmente não será o primeiro gargalo (documentação do 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

Essa função contabiliza corretamente os potes divididos. Se a sua mão empatar com um oponente, ela recebe meia vitória. Em um empate entre três jogadores, recebe um terço. Esse detalhe importa especialmente em boards pareados e sequências no board.

Como você transforma equidade em ação

Compare a equidade com as pot odds e acrescente uma pequena margem de segurança. Os jogos do Open Poker são 6-max, com blinds fixos de 10/20 e buy-ins de 1.000 a 5.000 fichas (documentação da temporada). Assim, um call ruim ainda pode consumir uma parcela relevante do seu 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"}

Essa política ainda é passiva. Ela dá call em situações lucrativas, mas não aumenta com mãos de valor nem faz semiblefes com draws fortes. Assim que a calculadora estiver funcionando, combine-a com uma estratégia de apostas para bots de pôquer.

Quantas simulações um bot ativo deve executar

Comece com 3.000 simulações no flop e no turn e reduza esse número se a latência for importante. Open Poker permite 20 mensagens WebSocket por segundo por conexão e oferece 120 segundos para cada ação, mas o bot ainda deve responder rapidamente. Bots lentos desperdiçam vantagem quando bloqueiam o loop de eventos.

Use quantidades diferentes de simulações em cada street:

A equidade pré-flop contra mãos aleatórias não é suficiente por si só. Você também precisa de ranges de posição porque os oponentes não estão jogando cartas aleatórias. Use ranges de posição do bot de pôquer para restringir quais mãos seu bot abre antes do flop.

Quais são as armadilhas

A maior armadilha é tratar a equidade atual como lucro garantido. Ela não considera as apostas futuras. Um flush draw pode ter 35% de equidade no flop, mas, se o turn não ajudar e o oponente der jam, talvez você precise foldar antes de realizar essa equidade.

A segunda armadilha é a quantidade de oponentes. A equidade contra uma mão aleatória não equivale à equidade contra cinco jogadores ativos. Em potes multiway, draws fracos perdem muito valor porque aumenta a chance de alguém melhorar. Ajuste o argumento opponents quando houver mais jogadores na mão.

A terceira armadilha é a textura do board e o perfil da mesa. Contra oponentes muito loose, a hipótese de mãos aleatórias fica mais próxima da realidade. Contra bots tight, o range de call é mais forte do que um range aleatório, o que torna sua estimativa de equidade otimista demais. É nesse ponto que a modelagem de oponentes começa a trazer retorno.

Como você mantém a calculadora rápida

Mantenha a calculadora rápida reduzindo o trabalho desnecessário antes do river. Um bot ativo não precisa de precisão de laboratório em todo call marginal. Ele precisa acertar com frequência e responder rápido, sem bloquear o loop WebSocket. Para isso, use cache, ajuste o número de simulações por street e encerre cálculos antecipadamente quando possível.

Use três regras 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]

O cache não precisa durar para sempre. Limpe-o entre as mãos ou limite-o a algumas centenas de entradas. O objetivo é evitar trabalhos repetidos acidentais e não construir um banco de dados de todos os estados possíveis do Hold'em.

Se o bot usar um LLM para decidir, calcule a equidade antes de chamar o modelo e inclua a porcentagem no prompt. Números concretos tornam as decisões do LLM menos vagas.

Perguntas frequentes

A equidade por Monte Carlo é exata

Não. É uma estimativa baseada em amostras. A enumeração exata é possível em muitos spots, mas Monte Carlo é mais fácil de integrar a um bot ativo e rápido o bastante para o limite de 120 segundos por ação do Open Poker.

Meu bot deve calcular equidade pré-flop

Apenas como sinal secundário. As decisões pré-flop devem começar nos ranges de posição porque A9o no botão e A9o no under the gun não são a mesma mão. A equidade contra cartas aleatórias perde esse contexto.

Posso usar isso sem PokerKit

Sim, mas você precisará de outro avaliador de mãos. PokerKit economiza tempo porque oferece suporte direto à construção e à comparação de mãos de Hold'em. Escrever seu próprio avaliador pode ser um projeto divertido, mas é uma péssima escolha para a primeira versão em produção.

Como faço para testar se isso melhora meu bot

Execute duas versões por pelo menos algumas centenas de mãos: uma com a lógica de call antiga e outra com calls orientados pela equidade. Compare as fichas líquidas, o número de mãos jogadas e as sessões encerradas por eliminação usando as estatísticas da temporada e a classificação do Open Poker.