def __init__(self, p, workers, target_hand_count, target_priv_node_count,
pub_delete_odds, hand_delete_odds, hand_expand_odds,
pub_expand_odds, adjust_every):
self.workers = workers
self.p = p
self.target_hand_count = target_hand_count
self.target_priv_node_count = target_priv_node_count
self.next_adjust = adjust_every
self.adjust_every = adjust_every
self.pub_delete_odds = pub_delete_odds
self.hand_delete_odds = hand_delete_odds
self.hand_expand_odds = hand_expand_odds
self.pub_expand_odds = pub_expand_odds
self.rng = []
for i in xrange(64):
self.rng.append(lzp.get_rng())
self.run = True
if self.target_hand_count > 0:
self.hc_pid = pid.PID(1.0, 0.0, 30.0)
self.hc_pid.setPoint(self.target_hand_count)
else:
self.hc_pid = None
if self.target_priv_node_count > 0:
self.nc_pid = pid.PID(1.0, 0.0, 10.0)
self.nc_pid.setPoint(self.target_priv_node_count)
else:
self.nc_pid = None
self.work_thread = threading.Thread(target=self.work_loop)
self.work_thread.daemon = True
self.work_thread.start()
self.adjust_retval = np.zeros(3, dtype=np.uint64)
def __init__(self,
p,
flags,
stake_adjust=None,
start_running=True,
hand_expand_odds=0.0,
pub_expand_odds=0.0):
#self.td_gen = td_gen
#self.td_gen = types_data_generator(p.zp)
self.p = p
self.hand_expand_odds = hand_expand_odds
self.pub_expand_odds = pub_expand_odds
self.rng = lzp.get_rng()
self.start_us = C.pointer(
p.root_state.next_states[0].next_states[0].unique_root_node)
self.start_hw = np.ones((2, defs.SAMPLES), dtype=np.float64)
self.start_hw_ctypes = (C.POINTER(C.c_double) * 2)()
self.start_hw_ctypes_p = C.pointer(self.start_hw_ctypes)
self.start_hw_ctypes[0] = self.start_hw[0].ctypes.data_as(
C.POINTER(C.c_double))
self.start_hw_ctypes[1] = self.start_hw[1].ctypes.data_as(
C.POINTER(C.c_double))
self.start_pw = self.start_hw.sum(axis=1)
self.start_pw_ctypes_p = self.start_pw.ctypes.data_as(
C.POINTER(C.c_double))
self.start_stake = np.array((1.0, 0.5), dtype=np.float64)
#self.start_stake = np.array((0.0, 0.0), dtype=np.float64)
self.start_stake_ctypes_p = self.start_stake.ctypes.data_as(
C.POINTER(C.c_double))
if stake_adjust != None:
self.stake_adjust = stake_adjust
else:
self.stake_adjust = np.ones((2, 3), dtype=np.float64)
#self.flags = np.zeros((2), dtype=np.uint64)
self.flags = flags
self.mem_list = C.pointer(C.POINTER(dt.mem_list)())
#self.flags_ctypes_p = self.flags.ctypes.data_as(C.POINTER(C.c_uint64))
#self.flags |= defs.POV_ODDS_FROM_REGS
#self.flags |= defs.UPDATE_REGS
#self.flags |= defs.UPDATE_AVG_ODDS
self.n_iter = 0
self.run = start_running
self.kill = False
self.work_thread = threading.Thread(target=self.work_loop)
self.work_thread.daemon = True
self.work_thread.start()
pass
def __init__(self, gamedir="testipeli", model_filename=""):
self.zp = zpoker.zpoker(gamedir)
self.rng = lzp.get_rng()
self.n_plr = self.zp.i.n_plr
self.sb = self.zp.i.sb
self.bb = self.zp.i.bb
self.cap = self.zp.i.maxbets
if self.n_plr == 2:
next_to_act = 1
else:
next_to_act = 2
if self.n_plr == 2:
initial_state = (0, 2, 1, 0.0, 0.0)
else:
initial_state = (0, self.n_plr, self.n_plr - 2) + tuple(
[0.0] * self.n_plr)
#if self.n_plr == 2:
# initial_state = (0, 2,1,0.5,1)
#else:
# initial_state = (0,self.n_plr, self.n_plr-2)+tuple([0]*(self.n_plr-2))+(0.5,1)
#self.root_state_id = (0, 1, 0, self.n_plr, next_to_act)
self.root_state_id = initial_state
self.root_state = unique_state(self.zp, self.root_state_id, self.sb,
self.bb, self.cap)
self.states_dict = {}
self.states_dict[self.root_state_id] = self.root_state
self.root_state.recursive_generate_all_unique_states(self.states_dict)
self.do_ev = False
self.no_update = 1000
self.odds_from = 0
self.sd = dt.simu_data()
self.sd.info = C.pointer(self.zp.i)
for i in xrange(self.n_plr):
self.sd.plr[i] = (1.0, 1.0, 0.0, 0.0, 0, 1, 1, 0)
self.model_path = ""
self.model_name = ""
self.model_time = ""
def flop_solver():
rng = lzp.get_rng()
start_us = C.pointer(
p.root_state.next_states[0].next_states[0].unique_root_node)
start_hw = np.ones((2, defs.HANDS), dtype=np.float64) / 1225.0
start_hw_p = start_hw.ctypes.data_as(C.POINTER(C.c_double))
start_stake = np.array((1.0, 0.5), dtype=np.float64)
start_stake_p = start_stake.ctypes.data_as(C.POINTER(C.c_double))
flags = np.zeros((2), dtype=np.uint64)
flags |= defs.BR_LOAD_FLOP_DATA
#flags |= defs.UPDATE_REGS
#flags |= defs.UPDATE_AVG_ODDS
path = np.zeros(256, dtype=np.int8)
preflop_types = np.zeros(1, dtype=dt.street_types_np)
preflop_types["hand_types"] = p.zp.slots[0]
preflop_types_p = preflop_types.ctypes.data_as(C.POINTER(dt.street_types))
pub_types = np.zeros(p.zp.i.n_type_types[1], dtype=np.int16)
pub_types.fill(-1)
pub_types[0] = 0
pub_types_p = pub_types.ctypes.data_as(C.POINTER(C.c_int16))
priv_types_p = preflop_types[0]["hand_types"].ctypes.data_as(
C.POINTER(C.c_int16))
ret_ev = np.zeros((2, defs.HANDS), dtype=np.float64)
ret_ev_p = ret_ev.ctypes.data_as(C.POINTER(C.c_double))
lzp.br_solve(start_us, path.ctypes.data_as(C.c_char_p), 0, 1, -1, -1, -1,
preflop_types_p, None, None, None, None, pub_types_p,
priv_types_p, ret_ev_p, start_hw_p, start_stake_p,
flags.ctypes.data_as(C.POINTER(C.c_uint64)), rng, save_path)
print ret_ev[0]
print ret_ev[1]
print(ret_ev[0]).sum()
print(ret_ev[1]).sum()
print np.average(ret_ev[0])
print np.average(ret_ev[1])
print(np.average(ret_ev[0]) + np.average(ret_ev[1])) / 2.0
pdb.set_trace()
#print action_odds_avg
#print action_odds
#print
#print self_hand, board
#print action_odds
# hs = p.zp.get_hand_slot(bc, self_hand)
# print "self hand", self_hand, hs
# board_slots = p.zp.get_board_slots_all_gs(bc)
# print board_slots
# us = p.get_unique_state_from_path(bets)
return action_odds
gamedir = sys.argv[3]
src = sys.argv[6]
rng = lzp.get_rng()
p = plrmodel.plrmodel(gamedir)
p.reset_model_path(sys.argv[4])
p.load_struct(seat=0)
p.recount_data_index(seat=0)
p.mmap_byte_odds(seat=0, source=src)
p.reset_model_path(sys.argv[5])
p.load_struct(seat=1)
p.recount_data_index(seat=1)
p.mmap_byte_odds(seat=1, source=src)
p.set_byte_odds_from_mmap()
#p.mmap_avg_odds()
#p.set_avg_odds_from_mmap()
def flop_solver(flop_queue):
rng = lzp.get_rng()
start_us = C.pointer(
p.root_state.next_states[0].next_states[0].unique_root_node)
start_hw = np.ones((2, defs.HANDS), dtype=np.float64) / 1225.0
#start_hw = np.ones((2,defs.HANDS), dtype=np.float64)/1326.0
start_hw_p = start_hw.ctypes.data_as(C.POINTER(C.c_double))
start_stake = np.array((1.0, 0.5), dtype=np.float64)
start_stake_p = start_stake.ctypes.data_as(C.POINTER(C.c_double))
flags = np.zeros((2), dtype=np.uint64)
flags |= defs.BR_SAVE_FLOP_DATA
#flags |= defs.UPDATE_REGS
#flags |= defs.UPDATE_AVG_ODDS
path = np.zeros(256, dtype=np.int8)
while True:
try:
flop = flop_queue.get(block=False)
except:
print "no flops, breaking"
break
flop_i = lzp.ctoi3[flop[0]][flop[1]][flop[2]]
try:
os.mkdir(save_path + str(flop_i))
except OSError:
if sys.exc_info()[1].strerror == "File exists":
if len(os.listdir(save_path + str(flop_i))) >= 70:
print flop_i, "already done"
continue
pass
flop_types, turn_types, river_types, river_handvals = load_hand_data_for_flop(
flop_i)
preflop_types = np.zeros(1, dtype=dt.street_types_np)
preflop_types["hand_types"] = p.zp.slots[0]
preflop_types_p = preflop_types.ctypes.data_as(
C.POINTER(dt.street_types))
flop_types_p = flop_types.ctypes.data_as(C.POINTER(dt.street_types))
turn_types_p = turn_types.ctypes.data_as(C.POINTER(dt.street_types))
river_types_p = river_types.ctypes.data_as(C.POINTER(dt.street_types))
river_handvals_p = river_handvals.ctypes.data_as(C.POINTER(
dt.hand_hv2))
#flop_types_p = None
#turn_types_p = None
#river_types_p = None
#river_handvals_p = None
pub_types = np.zeros(p.zp.i.n_type_types[1], dtype=np.int16)
pub_types.fill(-1)
pub_types[0] = 0
pub_types_p = pub_types.ctypes.data_as(C.POINTER(C.c_int16))
priv_types_p = preflop_types[0]["hand_types"].ctypes.data_as(
C.POINTER(C.c_int16))
ret_ev = np.zeros((2, defs.HANDS), dtype=np.float64)
ret_ev_p = ret_ev.ctypes.data_as(C.POINTER(C.c_double))
retval = lzp.br_solve(start_us, path.ctypes.data_as(C.c_char_p), 0, 1,
flop_i, -1, -1, preflop_types_p, flop_types_p,
turn_types_p, river_types_p, river_handvals_p,
pub_types_p, priv_types_p, ret_ev_p, start_hw_p,
start_stake_p,
flags.ctypes.data_as(C.POINTER(C.c_uint64)), rng,
save_path)
print "retval", retval