Python में Monte Carlo पोकर इक्विटी कैलकुलेटर

Monte Carlo पोकर इक्विटी कैलकुलेटर वह पहला गणितीय सुधार है जो वास्तविक फैसलों पर असर डालता है। "मेरे पास draw है, शायद call करूं" कहने के बजाय आपका बॉट जीतने की संभावना का अनुमान लगाता है, उसे pot odds से मिलाता है और महंगी अटकलों से बचता है।

इस श्रृंखला का भाग: 2026 में AI पोकर बॉट बनाने की संपूर्ण गाइड - फ्रेमवर्क, निर्णय-तर्क, इक्विटी, परीक्षण और प्रतिस्पर्धा की आधारभूत गाइड।

मुख्य बातें

• Monte Carlo इक्विटी अज्ञात विरोधी कार्ड और भविष्य के बोर्ड कार्ड का नमूना लेकर जीत की संभावना का अनुमान लगाती है।
• Open Poker your_turn में ठीक pot और call राशि देता है, इसलिए इक्विटी सीधे pot-odds निर्णय में जा सकती है।
• प्रति निर्णय 2,000 से 5,000 trials से शुरू करें। अधिक trials साफ परिणाम देते हैं, पर action latency मायने रखती है।

Monte Carlo equity किस समस्या को हल करती है?

यह मौजूदा hand label और आगे आने वाले कार्ड की अनिश्चितता के बीच का अंतर भरती है। Open Poker में बॉट के पास कार्रवाई के लिए 120 सेकंड होते हैं और हर your_turn संदेश में pot, board, valid actions और turn token मिलते हैं (Open Poker actions docs)। कार्रवाई भेजने से पहले लाभदायक call का अनुमान लगाने के लिए यही पर्याप्त है।

कैलकुलेटर पूछता है: अज्ञात कार्ड कई बार बांटें तो मेरा हाथ कितनी बार जीतेगा या split करेगा? वही इक्विटी है।

यदि pot 300 और call 100 है, तो pot odds हैं:

100 / (300 + 100) = 25%

नमूना इक्विटी 36% हो तो भविष्य की betting के प्रभाव से पहले call लाभदायक है। 18% हो तो fold चिप्स बचाता है। यह पूर्ण उत्तर नहीं, लेकिन "हर flush draw call करो" से बहुत बेहतर है।

Open Poker से कौन से input चाहिए?

चार मान चाहिए: hero के hole cards, community cards, pot size और call amount। Open Poker your_turn में community cards और pot भेजता है; private hole_cards संदेश से hole cards कैश करें। WebSocket protocol JSON-आधारित है और कोई भी भाषा इसे उपयोग कर सकती है (WebSocket docs)।

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)

सर्वर pot दे रहा हो तो उसे स्वयं न आंकें। पुराने player_action events से state दोबारा बनाने पर reconnect, rejected action या side-pot की जानकारी छूट सकती है। state सर्वर की है; निर्णय आपके बॉट के।

अंतिम हाथों की तुलना कैसे करें?

अंतिम Hold'em हाथों की तुलना के लिए PokerKit का StandardHighHand.from_game() लें। PokerKit standard high-hand evaluation और सामान्य comparison operators देता है (PokerKit hand evaluation)।

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))

यह छोटा wrapper कैलकुलेटर को पढ़ने में आसान रखता है। Open Poker कार्ड पहले ही As, Td, 7c जैसे होते हैं। प्रदर्शन समस्या बने तो parsed cards कैश करें: PokerKit के अनुसार बार-बार string parsing महंगी पड़ती है। पहले बॉट के लिए direct strings ठीक हैं; कई hosted bots पर हर action में 10,000 trials हों तो profiling करना उचित है।

एक विरोधी के विरुद्ध इक्विटी कैसे अनुमानित करें?

बचे हुए board cards और एक विरोधी का हाथ नमूना लें, फिर अंतिम हाथों की तुलना करें। 5,000 trials पर सरल Python कैलकुलेटर सामान्यतः live Open Poker निर्णयों के लिए पर्याप्त स्थिर रहता है। PokerKit का benchmark एक laptop CPU पर प्रति सेकंड दस लाख से अधिक standard high-hand evaluations बताता है, इसलिए evaluator पहला bottleneck नहीं है (PokerKit docs)।

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

यह function split pot का आंशिक credit देता है। एक विरोधी से tie पर आधी जीत, तीन-तरफा tie पर एक तिहाई। paired board और chopped straight board पर यह उम्मीद से अधिक महत्वपूर्ण है।

इक्विटी को action में कैसे बदलें?

इक्विटी को pot odds से मिलाएं और छोटी safety margin जोड़ें। Open Poker गेम 6-max हैं, fixed 10/20 blinds और 1,000 से 5,000 chips के table buy-ins हैं (season docs); इसलिए एक खराब call भी 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"}

यह नीति अभी passive है: लाभदायक spot पर call करती है, value hand raise या strong draw semi-bluff नहीं। कैलकुलेटर चलने लगे तो इसे poker bot betting strategy के साथ जोड़ें।

live bot को कितने trials चलाने चाहिए?

flop पर 3,000 से और turn पर 3,000 से शुरू करें; latency महत्वपूर्ण हो तो घटाएं। Open Poker प्रति connection 20 WebSocket messages प्रति सेकंड और प्रति action 120 सेकंड देता है, फिर भी बॉट को जल्दी काम करना चाहिए। धीमा बॉट event loop रोककर edge खोता है।

random hands के विरुद्ध preflop equity अकेले पर्याप्त नहीं है। विरोधी random cards नहीं खेलते, इसलिए position ranges भी चाहिए। flop से पहले आपके बॉट को कौन से हाथ खोलने हैं, इसे सीमित करने के लिए poker bot position ranges उपयोग करें।

कौन से जाल हैं?

सबसे बड़ी गलती "अभी की equity" को "हमेशा profit" मानना है। equity भविष्य की betting को नहीं गिनती। flop पर flush draw की equity 35% हो सकती है, लेकिन turn miss होने पर विरोधी jam करे तो उस equity का पूरा लाभ मिलने से पहले fold करना पड़ सकता है।

दूसरा जाल विरोधियों की संख्या है। एक random hand के विरुद्ध equity पांच सक्रिय खिलाड़ियों के विरुद्ध इक्विटी नहीं है। multiway pot कमजोर draws को कुचलते हैं क्योंकि किसी और के सुधरने की संभावना बढ़ती है। हाथ में अधिक खिलाड़ी हों तो opponents argument बढ़ाएं।

तीसरा जाल table texture है। बहुत loose विरोधियों के सामने random-hand assumption करीब है। tight bots के सामने उनकी calling range random से मजबूत है और आपका अनुमान अधिक आशावादी होगा। यहीं opponent modeling उपयोगी होता है।

कैलकुलेटर को तेज कैसे रखें?

river से पहले कम काम करके गति बनाए रखें। live bot को हर marginal call पर laboratory-level precision नहीं चाहिए; उसे WebSocket loop रोके बिना, पर्याप्त बार और पर्याप्त जल्दी सही उत्तर चाहिए। इसका अर्थ caching, street-based trials और early exits है।

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]

cache को हमेशा जीवित रखने की जरूरत नहीं। हर हाथ के बीच साफ करें या कुछ सौ entries तक सीमित रखें। उद्देश्य हर Hold'em state का database बनाना नहीं, अनजाने दोहराए काम से बचना है। बॉट LLM से निर्णय लेता हो तो LLM call से पहले equity चलाएं और प्रतिशत prompt में दें; संख्याएं निर्णय को कम अस्पष्ट बनाती हैं।

FAQ

क्या Monte Carlo equity बिल्कुल सटीक है?

नहीं। यह sampled estimate है। कई spots में exact enumeration संभव है, पर live bot में Monte Carlo लगाना आसान है और Open Poker की 120-second action timeout के लिए पर्याप्त तेज है।

क्या बॉट को preflop equity चलानी चाहिए?

केवल secondary signal के रूप में। preflop निर्णय position ranges से शुरू हों, क्योंकि button पर A9o और under the gun A9o एक जैसे हाथ नहीं हैं। random cards के विरुद्ध equity यह संदर्भ छोड़ देती है।

क्या PokerKit के बिना इसका उपयोग कर सकता हूं?

हां, लेकिन तब दूसरा hand evaluator चाहिए। PokerKit समय बचाता है क्योंकि वह Hold'em hand construction और comparison सीधे करता है। अपना evaluator लिखना रोचक project है, मगर पहला production निर्णय अच्छा नहीं।

कैसे जांचूं कि इससे बॉट सुधरता है?

कम से कम कुछ सौ हाथों तक दो संस्करण चलाएं: पुरानी call logic और equity-gated calls वाला। Open Poker season stats और leaderboard से net chips, खेले हाथ और busted sessions ट्रैक करें।