class StaticBucketer:
"""compute buckets of the board using expected hand strength"""
def __init__(self):
"""initialize expect hand strength and bucket count"""
self.ehs = ExpectedHandStrength(file_path="../Data/EHS/")
self.bucket_count = 500
def compute_buckets(self, board):
"""compute buckets using expected hand strength
:parameter board: a list of board card
:return a buckets FloatTensor (bucket_count, )
"""
board_count = len(board)
rd = [0, None, None, 1, 2, 3][board_count]
assert board_count in (0, 3, 4, 5)
ehs_tensor = self.ehs.get_hand_ehs(board)
board_mask = Mask.get_board_mask(board)
# use fixed interval bucketing, convert ehs to [0,1,2...499]
buckets = ehs_tensor.clone()
buckets[board_mask] *= (self.bucket_count - 1)
buckets.floor_()
return buckets
def get_bucket_count(self):
"""get total bucket count
:return the number of buckets
"""
return self.bucket_count
class Analyser:
def __init__(self):
self.root = None
self.ehs = ExpectedHandStrength(file_path="../Data/EHS/")
def load_tree(self, path=None):
with open(path or "../Data/Tree/root_tensor.dat", "rb") as f:
self.root = pickle.load(f)
def analyse(self, node):
board = node.board
values = node.cf_values
ehs_list = self.ehs.get_possible_hand_ehs(board_cards=board, rd=3)
for i in range(1326):
if ehs_list[i] == -1:
assert values[0][i] == values[1][i] == 0
ehs_tensor = torch.FloatTensor(ehs_list)
ehs_tensor_sorted, idx = ehs_tensor.sort(descending=True)
values_sorted_by_ehs = values[:, idx]
for i in range(1326):
print(values_sorted_by_ehs[:, i])
def __init__(self):
self.save_folder = "../Data/TrainingSamples/Texas/CardValue/"
self.round = None
self.board_count = None
self.save_path = None
self.solver = None
self.range_generator = None
self.tree_builder = None
self.batch_count = None
self.deck = None
self.batch_size = Arguments.batch_size
self.intervals = [(100, 100), (200, 400), (400, 2000), (2000, 6000), (6000, 19950)]
self.inputs_ph = None # placeholder of inputs
self.targets_ph = None # placeholder of targets
self.mask_ph = None # placeholder of mask
self.ehs = ExpectedHandStrength(file_path="../Data/EHS/")
self.counter = len(os.listdir(self.save_folder))
# -*- coding: utf-8 -*-
import time
import pickle
import numpy as np
from Range.ehs import ExpectedHandStrength
from CFR.public_cfr_numpy import PublicTreeCFR
from Range.range_generator import RangeGenerator
from HandIsomorphism.hand_isomorphism_encapsulation import HandIsomorphismEncapsulation as HandIsomorphism
from PokerTree.tree_builder import TexasHoldemTreeBuilder as TreeBuilder
board = [0, 32, 40, 44, 48]
rg = RangeGenerator(ehs=ExpectedHandStrength(file_path="../Data/EHS/"))
rg.set_board(board=board)
ranges_0 = rg.generate_ranges(1)
ranges_1 = rg.generate_ranges(1)
start_range = np.ndarray(shape=(2, 1326), dtype=float)
start_range[0] = ranges_0[0]
start_range[1] = ranges_1[0]
street = 3
tb = TreeBuilder(bet_sizing=None)
root = tb.build_tree(street=street,
initial_bets=[2000, 2000],
current_player=0,
board=board)
hand_iso = HandIsomorphism()
hand_iso.setup_by_round(rounds=street + 1, mode="board")
solver = PublicTreeCFR(hand_iso=hand_iso)
s = time.time()
solver.run_cfr(root, start_range)
def __init__(self):
"""initialize expect hand strength and bucket count"""
self.ehs = ExpectedHandStrength(file_path="../Data/EHS/")
self.bucket_count = 500
def __init__(self):
self.root = None
self.ehs = ExpectedHandStrength(file_path="../Data/EHS/")
# -*- coding: utf-8 -*-
from Range.ehs import ExpectedHandStrength
ehs = ExpectedHandStrength(file_path="../Data/EHS/")
assert len(ehs.preflop_ehs) == 169
assert len(ehs.flop_ehs) == 1286792
assert len(ehs.turn_ehs) == 13960050
assert len(ehs.river_ehs) == 123156254
board = [0, 1, 2]
rd = 1
ehs_list = ehs.get_possible_hand_ehs(board_cards=board, rd=rd)
assert len(ehs_list) == 1326
for e in ehs_list:
assert e == -1 or 0 <= e <= 1