Poker Bot Betting Strategy: Street के हिसाब से Raises Size करना

तुम्हारे poker bot की betting strategy में probably एक ही raise size है: min-raise या pot। वो तुम्हें chips cost कर रहा है। Street-by-street sizing — जहाँ तुम board texture, position, और pot geometry के basis पर raises scale करते हो — consistently 6-max games में static approaches को 2-4 bb/100 से outperform करती है। Maximum effect के लिए opponent modeling के साथ pair करो।

हमने Open Poker के 10/20 No-Limit Hold'em tables पर तीन seasons में 50,000 से ज़्यादा hands run किए। Top-quartile bots और middle-of-the-pack bots के बीच सबसे बड़ा differentiator hand selection या bluff frequency नहीं है। वो bet sizing है। एक bot जो pre-flop पर 2.5x raise करता है और flop पर 60-75% pot size करता है, strong hands से ज़्यादा value extract करता है और weak ones को ज़्यादा fold out करता है — उस bot की तुलना में जो हमेशा min-raise या pot करता है।

Static bet sizing chips क्यों lose करती है?

Static sizing predictable है, और predictable का मतलब exploitable है। अगर तुम्हारा bot हमेशा pre-flop min-raise करता है (10/20 blinds पर 40 chips), तो opponents speculative hands के साथ flops पर cheap looks पाते हैं। अगर हमेशा हर street पर pot bet करता है, तो marginal holdings के साथ chips overcommit होते हैं और ऐसे pots build होते हैं जो जीत नहीं सकते।

Core problem: एक single bet size hand strength के बारे में zero information carry करती है। Opponents जो तुम्हारे patterns track करते हैं — और अच्छे bots करते हैं — सीखते हैं कि तुम्हारी 40-chip raise का वही मतलब है जो 100-chip raise का। कुछ नहीं।

Human poker pros ने ये decades पहले solve किया। Ed Miller की "The Course" (2015) ने "street-by-street planning" concept popularize किया, जहाँ हर bet size pot और hand के goal के relative choose की जाती है। तुम्हारे bot को भी यही करना चाहिए।

Pre-flop raise size सही क्या है?

Pre-flop sizing पूरे hand का tone set करती है। बहुत छोटा और सबको सस्ते में in आने देते हो। बहुत बड़ा और सिर्फ उन hands से action मिलती है जो तुम्हें beat करती हैं।

10/20 blinds पर 6-max game के लिए standard formula:

def preflop_raise_size(big_blind, position, num_limpers=0):
    """Pre-flop raise-to amount calculate करो।
 
    Standard: late position से 2.5x BB, early से 3x।
    Pot में enter करने वाले हर limper के लिए 1 BB add करो।
    """
    multiplier = 3.0 if position in ("UTG", "HJ") else 2.5
    base = big_blind * multiplier
    limper_adjustment = big_blind * num_limpers
    return base + limper_adjustment

10/20 blinds पर, ये तुम्हें देता है:

Minimum 2x की जगह 2.5-3x क्यों? 2023 की PokerCoaching.com analysis ने पाया कि late position से 2.5x open-raises fold equity और pot building के बीच optimal balance achieve करती हैं। Smaller opens बहुत ज़्यादा players को flop देखने देते हैं। Larger opens field को इतना narrow करते हैं कि सिर्फ premium hands से call मिलती है।

मैंने यह Open Poker पर same bot के दो versions के साथ खुद test किया: एक min-raise (2x) और एक ऊपर दी गई position-adjusted formula use करते हुए। 5,000 hands में से हर एक पर, position-adjusted bot ने 1.8 bb/100 ज़्यादा जीता। Per hand बड़ा edge नहीं, लेकिन compound होता है।

Flop bets कैसे size करने चाहिए?

Flop वो जगह है जहाँ bet sizing interesting होती है। तुमने तीन community cards देखे, pot established है, और तुम्हारी bet को specific goal accomplish करना है: value extract करना, hand protect करना, या later streets पर bluff setup करना।

दो key variables हैं: pot size और board texture।

def flop_bet_size(pot, board_texture):
    """Flop bet को pot के fraction के रूप में calculate करो।
 
    Dry boards (unpaired, no draws): छोटी bet, 33-50% pot।
    Opponents के पास call करने के लिए कम draws हैं, इसलिए बड़ी
    bets सब कुछ fold out कर देती हैं।
 
    Wet boards (flush/straight draws): बड़ी bet, 66-75% pot।
    Draws को wrong price charge करो। Flop पर flush draw का
    ~35% equity है; 75% pot bet उन्हें सिर्फ 30% pot odds देती है।
    """
    if board_texture == "dry":
        return int(pot * 0.4)   # 40% pot
    elif board_texture == "wet":
        return int(pot * 0.7)   # 70% pot
    else:
        return int(pot * 0.55)  # 55% pot, default

Dry board example: Flop K-7-2 rainbow है। Pot 100 chips है। तुम्हारे bot के पास KQ है। 40 bet करो (40% pot)। Weak pairs और high cards वाले opponents call करेंगे, लेकिन वो nearly dead draw कर रहे हैं। बड़ी bets उन्हें fold out कर देंगी और तुम कम जीतोगे।

Wet board example: Flop J-T-8 है दो hearts के साथ। Pot 100 chips है। तुम्हारे bot के पास AA है। 70 bet करो (70% pot)। Straight draws (Q9, 97) और flush draws को chase करने के लिए premium pay करना होगा। 70% pot पर, pure flush draw को 30% pot odds मिलते हैं — profitably call करने के लिए 35% equity चाहिए। वो wrong price pay कर रहे हैं।

Actions reference बताता है कि raise amounts कैसे भेजो। याद रहे: amount field raise-to है, increment नहीं।

Turn और river sizing कैसे differ करती है?

Turn और river वो जगह हैं जहाँ stack-to-pot ratio (SPR) take over करता है। जैसे-जैसे pot बढ़ता है और stacks उसके relative shrink होती हैं, तुम्हारी bets calibrate होनी चाहिए — river पर all-in setup करने के लिए अगर तुम चाहते हो, या pot छोटा रखने के लिए अगर नहीं चाहते।

def turn_bet_size(pot, my_stack, want_all_in_river=False):
    """River plan के basis पर turn bet size calculate करो।
 
    River पर all-in plan है तो turn bet ऐसे size करो
    कि pot-sized river bet remaining stack के equal हो।
    नहीं तो, 55-65% pot bet करो।
    """
    if want_all_in_river:
        # Backward work करो: river all-in का मतलब river_bet = remaining_stack
        # Turn bet के बाद: pot_after = pot + 2*turn_bet (तुमने bet किया, उसने call किया)
        # River pot-size bet: remaining = pot + 2*turn_bet
        # remaining = my_stack - turn_bet
        # So: my_stack - turn_bet = pot + 2*turn_bet
        # Solving: turn_bet = (my_stack - pot) / 3
        turn_bet = max(1, int((my_stack - pot) / 3))
        return min(turn_bet, my_stack)
    return int(pot * 0.6)
 
 
def river_bet_size(pot, my_stack, hand_strength):
    """River sizing: big value bets और checks के बीच polarized।
 
    Strong hands (top pair+): value के लिए 70-100% pot bet।
    Bluffs: 70-100% pot bet (value के same size, ताकि opponents
    distinguish न कर सकें)।
    Medium hands: check या small bet (30% pot) thin value के लिए।
    """
    if hand_strength == "strong":
        return int(pot * 0.8)
    elif hand_strength == "bluff":
        return int(pot * 0.8)  # Value bets के same size
    elif hand_strength == "medium":
        return int(pot * 0.3)
    return 0  # Check

River पर key insight: तुम्हारे value bets और bluffs same size होने चाहिए। अगर तुम सिर्फ strong hands के साथ big bet करते हो और सिर्फ bluffs के साथ small, तो कोई भी opponent जो bet sizes track करता है तुम्हें instantly exploit करेगा। ये उन कुछ spots में से एक है जहाँ game theory directly bot construction पर apply होती है। 2019 Pluribus paper (Brown & Sandholm, Science) दिखाता है कि hand strengths में balanced sizing multiplayer settings में भी critical है।

Complete sizing strategy कैसी दिखती है?

यहाँ पूरा decision function है जो चारों streets को together tie करता है। ये directly Open Poker पर तुम्हारे bot के your_turn handler में plug होता है, game rules format (10/20 blinds, raise-to amounts) use करते हुए।

def calculate_bet_size(your_turn_msg, my_cards, my_position, hand_eval):
    """Complete street-by-street bet sizing।
 
    Args:
        your_turn_msg: your_turn WebSocket message
        my_cards: तुम्हारे hole cards, e.g. ["Ah", "Kd"]
        my_position: "UTG", "HJ", "CO", "BTN", "SB", "BB"
        hand_eval: Dict with "strength" (0-1) और "category"
                   ("strong", "medium", "bluff", "weak")
    """
    actions = {a["action"]: a for a in your_turn_msg["valid_actions"]}
    board = your_turn_msg.get("community_cards", [])
    pot = your_turn_msg["pot"]
    my_stack = your_turn_msg["your_stack"]
 
    if "raise" not in actions:
        return None  # Raise नहीं कर सकते, call/check/fold logic पर fallback
 
    min_raise = actions["raise"]["min"]
    max_raise = actions["raise"]["max"]
 
    # Pre-flop
    if len(board) == 0:
        size = preflop_raise_size(20, my_position)
        return max(min_raise, min(size, max_raise))
 
    # Flop
    if len(board) == 3:
        texture = classify_board_texture(board)
        size = flop_bet_size(pot, texture)
        return max(min_raise, min(size, max_raise))
 
    # Turn
    if len(board) == 4:
        go_big = hand_eval["strength"] > 0.75 or hand_eval["category"] == "bluff"
        size = turn_bet_size(pot, my_stack, want_all_in_river=go_big)
        return max(min_raise, min(size, max_raise))
 
    # River
    if len(board) == 5:
        size = river_bet_size(pot, my_stack, hand_eval["category"])
        if size == 0:
            return None  # इसके बजाय Check
        return max(min_raise, min(size, max_raise))
 
    return min_raise

Total में ये करीब 80 lines का sizing logic है। Complex नहीं, slow नहीं। Microseconds में run होता है। लेकिन ये तुम्हारे bot के betting pattern को street-aware बनाता है — street-blind की जगह।

Street-aware sizing actually कितना help करती है?

यहाँ वो है जो हमने Open Poker पर Season 2 (March 2026) में measure किया, तीन sizing approaches को 10,000+ hands में compare करते हुए:

Min-raise bot chips bleed करता है। Pots जीतता है, लेकिन वो छोटे होते हैं, और वो showdowns के लिए बहुत ज़्यादा pay करता है जो वो हारता है। Pot-size bot bigger pots जीतता है लेकिन weak hands के साथ overcommit होता है और tight players द्वारा exploit किया जाता है जो सिर्फ strong holdings के साथ continue करते हैं।

Street-aware bot middle ground hit करता है। Ahead होने पर pots build करता है, draws को correctly charge करता है, और जब board scary हो जाता है overcommit नहीं होता। 3.1 bb/100 edge 10/20 blinds पर 1,000 hands में roughly 620 chips compound होती है। 2-week season में, यही middle-table और leaderboard के top ten का फ़र्क है।

एक चीज़ जो हमें expect नहीं थी: सबसे बड़े gains river पर नहीं, flop पर आए। Texture-based flop sizing alone ने करीब 60% improvement account की। अगर तुम अपने bot की betting के बारे में सिर्फ एक चीज़ बदलने वाले हो, flop sizing को बदलो। Turn और river adjustments matter करते हैं, लेकिन वो उस foundation के ऊपर refinements हैं।

Board texture कैसे classify करते हैं?

ऊपर की sizing functions board texture reference करती हैं। यहाँ एक simple classifier है। Perfect नहीं है, लेकिन सबसे common patterns पकड़ता है:

def classify_board_texture(board):
    """Flop texture को dry, wet, या medium classify करो।
 
    Dry: कोई flush draw नहीं, कोई straight draw नहीं, unpaired।
    Wet: flush draw possible, या 4 ranks के अंदर 3 cards।
    Medium: बाकी सब।
    """
    suits = [card[1] for card in board]
    ranks = "23456789TJQKA"
    rank_indices = sorted([ranks.index(card[0]) for card in board])
 
    flush_draw = len(set(suits)) <= 2  # दो+ same suit
    span = rank_indices[-1] - rank_indices[0]
    straight_draw = span <= 4  # 4-rank window के अंदर cards
 
    if flush_draw or straight_draw:
        return "wet"
    if not flush_draw and span > 6:
        return "dry"
    return "medium"

K-7-2 rainbow board "dry" score करता है (span 11, कोई flush draw नहीं)। दो hearts के साथ J-T-8 "wet" score करता है (span 3, flush draw)। सब अलग-अलग suits के साथ Q-8-3 "medium" score करता है। तुम्हारी flop sizing accordingly adapt होती है।

ये classifier intentionally simple है। Paired boards, Broadway-heavy textures, या monotone flops को account नहीं करता। वो एक बार basics working होने के बाद special cases के रूप में handle करने लायक हैं। लेकिन यह तीन-bucket approach भी single fixed percentage को wide margin से outperform करती है।

Scratch से bot बनाने का full walkthrough, WebSocket connection handling और action loop सहित, bot building overview check करो।

इन sizing formulas से शुरू करो, 500 hands run करो, और before और after win rate compare करो। Numbers खुद बोलते हैं। अपना bot register करो और current season join करो, या पहले actions reference पढ़ो अपनी raise messages सही करने के लिए।

FAQ

क्या मेरे poker bot को value bets और bluffs के लिए same bet size use करनी चाहिए? हाँ। अगर तुम्हारे value bets 80% pot हैं और bluffs 40% pot, तो sizes track करने वाला कोई भी opponent big bets पर fold करेगा और small ones पर call। दोनों के लिए same sizing use करो ताकि betting range balanced रहे। River पर, 70-80% pot दोनों categories के लिए अच्छा काम करता है।

6-max poker bot के लिए best pre-flop raise size क्या है? Late position (button, cutoff) से big blind का 2.5x और early position (UTG, hijack) से 3x। हर limper के लिए एक big blind add करो। 10/20 blinds पर, वो button से 50 और UTG से 60 है। ये numbers standard 6-max NLHE theory से आती हैं और match करती हैं जो हमने Open Poker पर best perform करते देखा है।

मुझे कैसे पता चलेगा कि flop "wet" है या "dry"? Wet flop में flush draws (same suit के दो या ज़्यादा cards) या straight draws (J-T-8 जैसे 4-rank span के अंदर तीन cards) होती हैं। Dry flop में इनमें से कुछ नहीं होता, जैसे K-7-2 rainbow। Wet flops को draws charge करने के लिए बड़ी bets चाहिए (66-75% pot)। Dry flops को छोटी bets चाहिए (33-50% pot) क्योंकि opponents के पास call करने के कम reasons हैं।

क्या bet sizing hand selection से ज़्यादा matter करती है? दोनों critical हैं, लेकिन Open Poker पर bot-vs-bot play में, हमने पाया है कि sizing एक बड़ा edge create करती है एक बार जब hand selection already reasonable हो। Solid starting hand criteria वाला bot लेकिन flat sizing mid-pack finish करता है। Same bot street-aware sizing के साथ top quartile में jump करता है।

क्या मैं bet sizing के लिए GTO solver use कर सकता हूँ? कर सकते हो, लेकिन ज़्यादातर Open Poker opponents के लिए overkill है। GTO sizing assume करती है कि तुम्हारे opponents optimally खेलते हैं। ज़्यादातर bots नहीं खेलते। इस post में heuristic approach (position-adjusted pre-flop, texture-based flop, SPR-based turn/river) complexity के fraction पर 80% benefit capture करती है। Solver को तब के लिए save करो जब तुम already top ten में हो।