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