def reset(self): self.drawbag = DrawBag(self.contents) self.players = [] player_id = 1 for p in range(self.n_players): self.players.append(Player(str(player_id))) player_id += 1 self.current_player_num = 0 self.done = False logger.debug(f'\n\n---- NEW GAME ----') self.board = Board(self.board_size) self.board.fill(self.drawbag.draw(self.squares)) for net in self.nets: self.board.add_net(net) self.place_hudson() self.turns_taken = 0 return self.observation
def reset(self): self.round = 0 self.deck = Deck() self.players = [] self.action_bank = [] self.played_cards = [] self.zobrane3 = False self.stalsom = False self.zobrane3 = False self.stalsom = False self.menimna = "" self.ktoryvysnik = "" self.beres = 0 player_id = 1 for p in range(self.n_players): self.players.append(Player(str(player_id))) player_id += 1 for player in self.players: player.hand.add(self.deck.pop(5)) self.current_player_num = 0 self.done = False self.tableCard = self.deck.pop()[0] logger.debug(f"\n\n---- NEW GAME ----") return self.observation
def main(): # requires n_comp_to_use, pc1_chunk_size import sys logger.log(sys.argv) common_arg_parser = get_common_parser() cma_args, cma_unknown_args = common_arg_parser.parse_known_args() this_run_dir = get_dir_path_for_this_run(cma_args) traj_params_dir_name = get_full_params_dir(this_run_dir) intermediate_data_dir = get_intermediate_data_dir(this_run_dir) save_dir = get_save_dir( this_run_dir) if not os.path.exists(intermediate_data_dir): os.makedirs(intermediate_data_dir) ''' ========================================================================================== get the pc vectors ========================================================================================== ''' result = do_pca(cma_args.n_components, cma_args.n_comp_to_use, traj_params_dir_name, intermediate_data_dir, proj=False, origin="mean_param", use_IPCA=cma_args.use_IPCA, chunk_size=cma_args.chunk_size, reuse=True) logger.debug("after pca") final_pcs = result["first_n_pcs"] all_param_iterator = get_allinone_concat_df(dir_name=traj_params_dir_name, use_IPCA=True, chunk_size=cma_args.pc1_chunk_size) plane_angles_vs_final_plane_along_the_way = [] ipca = IncrementalPCA(n_components=cma_args.n_comp_to_use) # for sparse PCA to speed up for chunk in all_param_iterator: logger.log(f"currently at {all_param_iterator._currow}") ipca.partial_fit(chunk.values) first_n_pcs = ipca.components_[:cma_args.n_comp_to_use] assert final_pcs.shape[0] == first_n_pcs.shape[0] plane_angle = cal_angle_between_nd_planes(first_n_pcs, final_pcs) plane_angles_vs_final_plane_along_the_way.append(plane_angle) plot_dir = get_plot_dir(cma_args) if not os.path.exists(plot_dir): os.makedirs(plot_dir) plane_angles_vs_final_plane_plot_dir = get_plane_angles_vs_final_plane_along_the_way_plot_dir(plot_dir, cma_args.n_comp_to_use) if not os.path.exists(plane_angles_vs_final_plane_plot_dir): os.makedirs(plane_angles_vs_final_plane_plot_dir) angles_plot_name = f"plane_angles_vs_final_plane_plot_dir " plot_2d(plane_angles_vs_final_plane_plot_dir, angles_plot_name, np.arange(len(plane_angles_vs_final_plane_along_the_way)), plane_angles_vs_final_plane_along_the_way, "num of chunks", "angle with diff in degrees", False)
def reset(self): self.deck = Deck(self.contents) self.discard = Discard() self.discard.add(self.deck.draw(self.cards_to_discard)) self.centre_card = Position() if self.manual: next_card = input('What card is drawn?: ') self.centre_card.add(self.deck.pick(next_card)) else: self.centre_card.add(self.deck.draw(1)) self.centre_counters = Counters() self.players = [] player_id = 1 for p in range(self.n_players): self.players.append(Player(str(player_id))) player_id += 1 for p in self.players: p.position = Position() p.counters.add(self.counters_per_player) self.turns_taken = 0 self.current_player_num = 0 self.done = False logger.debug(f'\n\n---- NEW GAME ----') return self.observation
def check_game_over(self): board = self.board current_player_num = self.current_player_num players = self.players # check game over for i in range(self.grid_length): # horizontals and verticals if ((self.square_is_player(i * self.grid_length, current_player_num) and self.square_is_player( i * self.grid_length + 1, current_player_num) and self.square_is_player(i * self.grid_length + 2, current_player_num)) or (self.square_is_player(i + 0, current_player_num) and self.square_is_player(i + self.grid_length, current_player_num) and self.square_is_player( i + self.grid_length * 2, current_player_num))): return 1, True # diagonals if ((self.square_is_player(0, current_player_num) and self.square_is_player(4, current_player_num) and self.square_is_player( 8, current_player_num)) or (self.square_is_player(2, current_player_num) and self.square_is_player(4, current_player_num) and self.square_is_player( 6, current_player_num))): return 1, True if self.turns_taken == self.num_squares: logger.debug("Board full") return 0, True return 0, False
def choose_tile(self, square): tile = self.board.remove(square) if tile is None: logger.debug(f"Player {self.current_player.id} trying to pick tile from square {square} but doesn't exist!") raise Exception('tile not found') logger.debug(f"Player {self.current_player.id} picking {tile.symbol}") self.current_player.position.add([tile])
def reset(self): self.board = [Token('.', 0)] * self.num_squares self.players = [Player('1', Token('X', 1)), Player('2', Token('O', -1))] self.current_player_num = 0 self.turns_taken = 0 self.done = False logger.debug(f'\n\n---- NEW GAME ----') return self.observation
def switch_hands(self): logger.debug(f'\nSwitching hands...') playernhand = self.players[-1].hand for i in range(self.n_players - 1, -1, -1): if i > 0: self.players[i].hand = self.players[i - 1].hand self.players[0].hand = playernhand
def continue_game(self): while self.current_player_num != self.agent_player_num: self.render() action = self.current_agent.choose_action(self, choose_best_action = False, mask_invalid_actions = False) observation, reward, done, _ = super(SelfPlayEnv, self).step(action) logger.debug(f'Rewards: {reward}') logger.debug(f'Done: {done}') if done: break return observation, reward, done, None
def print_top_actions(self, action_probs, env=None): top5_action_idx = np.argsort(-action_probs)[:5] top5_actions = action_probs[top5_action_idx] if env is not None and env.name == "blobwar": formatter = env.decode_action else: formatter = lambda action: action logger.debug( f"Top 5 actions: {[str(formatter(i)) + ': ' + str(round(a, 5)) for i, a in zip(top5_action_idx, top5_actions)]}" )
def step(self, action): reward = [0] * self.n_players done = False # check move legality if self.legal_actions[action] == 0: reward = [1.0 / (self.n_players - 1)] * self.n_players reward[self.current_player_num] = -1 done = True #play the card(s) else: self.action_bank.append(action) if len(self.action_bank) == self.n_players: logger.debug( f'\nThe chosen cards are now played simultaneously') for i, action in enumerate(self.action_bank): player = self.players[i] pickup_chopsticks, first_card, second_card = self.convert_action( action) self.play_card(first_card, player) if pickup_chopsticks: self.pickup_chopsticks(player) self.play_card(second_card, player) self.action_bank = [] self.switch_hands() self.current_player_num = (self.current_player_num + 1) % self.n_players if self.current_player_num == 0: self.turns_taken += 1 if self.turns_taken == self.cards_per_player: self.score_round() if self.round >= self.n_rounds: self.score_puddings() reward = self.score_game() done = True else: self.render() self.reset_round() self.done = done return self.observation, reward, done, {}
def score_puddings(self): logger.debug('\nPudding counts...') puddings = [] for p in self.players: puddings.append( len([ card for card in p.position.cards if card.type == 'pudding' ])) logger.debug(f'Puddings: {puddings}') pudding_winners = self.get_limits(puddings, 'max') for i in pudding_winners: self.players[i].score += 6 // len(pudding_winners) logger.debug( f'Player {self.players[i].id} 1st place puddings: {6 // len(pudding_winners)}' ) pudding_losers = self.get_limits(puddings, 'min') for i in pudding_losers: self.players[i].score -= 6 // len(pudding_losers) logger.debug( f'Player {self.players[i].id} last place puddings: {-6 // len(pudding_losers)}' )
def choose_action(self, env, choose_best_action, mask_invalid_actions): if self.name == "greedy": return self.greedy(env, choose_best_action, mask_invalid_actions) if self.name == 'rules': action_probs = np.array(env.rules_move()) value = None else: action_probs = self.model.action_probability(env.observation) value = self.model.policy_pi.value(np.array([env.observation]))[0] logger.debug(f'Value {value:.2f}') # logger.debug(f'\n action probs:{action_probs} ') self.print_top_actions(action_probs, env=env) if mask_invalid_actions: action_probs = mask_actions(env.legal_actions, action_probs) logger.debug('Masked ->') self.print_top_actions(action_probs, env=env) action = np.argmax(action_probs) formatter = env.decode_action if env is not None and env.name == "blobwar" else lambda action: action logger.debug(f'Best action {formatter(action)}') if not choose_best_action: action = sample_action(action_probs) logger.debug(f'Sampled action : {formatter(action)} chosen') return action
def setup_opponents(self): if self.opponent_type == 'rules': self.opponent_agent = Agent('greedy') else: # incremental load of new model best_model_name = get_best_model_name(self.name) if self.best_model_name != best_model_name: self.opponent_models.append( load_model(self, best_model_name)) self.best_model_name = best_model_name if self.opponent_type == 'random': start = 0 end = len(self.opponent_models) - 1 i = random.randint(start, end) self.opponent_agent = Agent('ppo_opponent', self.opponent_models[i]) elif self.opponent_type == 'best': self.opponent_agent = Agent('ppo_opponent', self.opponent_models[-1]) elif self.opponent_type == 'mostly_best': j = random.uniform(0, 1) if j < 0.8: self.opponent_agent = Agent('ppo_opponent', self.opponent_models[-1]) else: start = 0 end = len(self.opponent_models) - 1 i = random.randint(start, end) self.opponent_agent = Agent('ppo_opponent', self.opponent_models[i]) elif self.opponent_type == 'base': self.opponent_agent = Agent('base', self.opponent_models[0]) self.agent_player_num = np.random.choice(self.n_players) self.agents = [self.opponent_agent] * self.n_players self.agents[self.agent_player_num] = None try: # if self.players is defined on the base environment logger.debug( f'Agent plays as Player {self.players[self.agent_player_num].id}' ) except: pass
def check_game_over(self, board = None , player = None): if board is None: board = self.board if player is None: player = self.current_player_num for x,y,z,a in WINNERS: if self.square_is_player(board, x, player) and self.square_is_player(board, y, player) and self.square_is_player(board, z, player) and self.square_is_player(board, a, player): return 1, True if self.turns_taken == self.num_squares: logger.debug("Board full") return 0, True return 0, False #-0.01 here to encourage choosing the win?
def reset(self): self.round = 0 self.deck = Deck(self.contents) self.discard = Discard() self.players = [] self.action_bank = [] player_id = 1 for p in range(self.n_players): self.players.append(Player(str(player_id))) player_id += 1 self.current_player_num = 0 self.done = False self.reset_round() logger.debug(f'\n\n---- NEW GAME ----') return self.observation
def play_card(self, card_num, player): card_name = self.contents[card_num]['info']['name'] card = player.hand.pick(card_name) if card is None: logger.debug(f"Player {player.id} trying to play {card_num} but doesn't exist!") raise Exception('Card not found') logger.debug(f"Player {player.id} playing {str(card.order) + ': ' + card.symbol + ': ' + str(card.id)}") if card.type == 'nigiri': for c in player.position.cards: if c.type == 'wasabi' and c.played_upon == False: c.played_upon = True card.played_on_wasabi = True break player.position.add([card])
def step(self, action): reward = [0] * self.n_players done = False draw_card = False # check move legality if self.legal_actions[action] == 0: reward = [1.0 / (self.n_players - 1)] * self.n_players reward[self.current_player_num] = -1 done = True #play the card(s) else: if action == 0: logger.debug(f'\nPlayer chooses to play a counter') self.current_player.counters.remove(1) self.centre_counters.add(1) self.current_player_num = (self.current_player_num + 1) % self.n_players else: logger.debug( f'Player chooses to take card {self.centre_card.cards[0].symbol} and {self.centre_counters.size()} counters' ) self.current_player.position.add(self.centre_card.cards) self.current_player.counters.add(self.centre_counters.size()) self.centre_card.reset() self.centre_counters.reset() if self.deck.size() == self.deck_size_at_end: reward = self.score_game() done = True else: if self.manual: next_card = input('What card is drawn?: ') self.centre_card.add(self.deck.pick(next_card)) else: self.centre_card.add(self.deck.draw(1)) self.turns_taken += 1 self.done = done return self.observation, reward, done, {}
def continue_game(self): """Working with partial rewards and at the end of the round, sum up reward amount step""" adversary_round_rewards = [0, 0] if self.current_player_num != self.agent_player_num: self.render() action = self.current_agent.choose_action( self, choose_best_action=False, mask_invalid_actions=False) # # if self.opponent_type == 'rules': # assert(self.core.check_move(self.decode_action(action)),"Adversary rules based cannot play bad moves") observation, rewards, done, _ = super(SelfPlayEnvBlobwar, self).step(action) # formatted_action = super(SelfPlayEnvBlobwar, self).decode_action(action) logger.debug( f'Action played by adversary({"o" if self.agent_player_num==0 else "x"}): {action}' ) for i in range(len(self.agents)): adversary_round_rewards[i] = rewards[i] return observation, adversary_round_rewards, done, None
def reset(self): #pick a random board self.board = Board(random.choice(ALL_BOARDS)) #reset players player_id = 1 for p in range(self.n_players): player = Player(player_id) player.r_deck.shuffle() player.s_deck.shuffle() self.board.add_player(player) player_id += 1 self.current_player_num = 0 #TODO add initial position in learning self.set_start_positions() self.done = False self.last_turn = False logger.debug(f'\n\n---- NEW GAME ----') self.render_map(first_turn=True) self.draw_card() return self.observation
def step(self, action): self.render() observation, reward, done, _ = super(SelfPlayEnv, self).step(action) logger.debug(f'Action played by agent: {action}') logger.debug(f'Rewards: {reward}') logger.debug(f'Done: {done}') if not done: observation, reward, done, _ = self.continue_game() agent_reward = reward[self.agent_player_num] logger.debug(f'\nReward To Agent: {agent_reward}') if done: self.render() return observation, agent_reward, done, {}
def score_maki(self, maki): logger.debug('\nMaki counts...') logger.debug(f'Maki: {maki}') maki_winners = self.get_limits(maki, 'max') for i in maki_winners: self.players[i].score += 6 // len(maki_winners) maki[i] = None #mask out the winners logger.debug(f'Player {self.players[i].id} 1st place maki: {6 // len(maki_winners)}') if len(maki_winners) == 1: #now get second place as winners are masked with None maki_winners = self.get_limits(maki, 'max') for i in maki_winners: self.players[i].score += 3 // len(maki_winners) logger.debug(f'Player {self.players[i].id} 2nd place maki: {3 // len(maki_winners)}')
def choose_action(self, env, choose_best_action, mask_invalid_actions): if self.name == 'human': if env.render_mode is "print": while True: try: action = int(input('\nPlease choose an action: ')) break except ValueError: pass else: co_ords = np.array(env.fig.ginput(n=1, timeout=99999999)).ravel() # all_sites = np.array(list(product([0, 1, 2], repeat=2))) all_sites = np.array([[0, 0], [1, 0], [2, 0], [0, 1], [1, 1], [2, 1], [0, 2], [1, 2], [2, 2]]) all_sites_dist = np.sqrt( np.square((co_ords[0] - all_sites[:, 0])) + np.square((co_ords[1] - all_sites[:, 1]))) action = np.argmin(all_sites_dist) sleep(0.2) return int(action) elif self.name == 'rules': action_probs = np.array(env.rules_move()) value = None else: action_probs = self.model.action_probability(env.observation) value = self.model.policy_pi.value(np.array([env.observation]))[0] logger.debug(f'Value {value:.2f}') self.print_top_actions(action_probs) # if mask_invalid_actions: # action_probs = mask_actions(env.legal_actions, action_probs) # logger.debug('Masked ->') # # self.print_top_actions(action_probs) action = np.argmax(action_probs) logger.debug(f'Best action {action}') if not choose_best_action: action = sample_action(action_probs) logger.debug(f'Sampled action {action} chosen') return int(action)
def choose_action(self, env, choose_best_action, mask_invalid_actions): if self.name == 'rules': action_probs = np.array(env.rules_move()) value = None else: action_probs = self.model.action_probability(env.observation) value = self.model.policy_pi.value(np.array([env.observation]))[0] logger.debug(f'Value {value:.2f}') self.print_top_actions(action_probs) if mask_invalid_actions: action_probs = mask_actions(env.legal_actions, action_probs) logger.debug('Masked ->') self.print_top_actions(action_probs) action = np.argmax(action_probs) logger.debug(f'Best action {action}') if not choose_best_action: action = sample_action(action_probs) logger.debug(f'Sampled action {action} chosen') return action
def main(): import sys logger.log(sys.argv) common_arg_parser = get_common_parser() cma_args, cma_unknown_args = common_arg_parser.parse_known_args() origin_name = "final_param" this_run_dir = get_dir_path_for_this_run(cma_args) plot_dir_alg = get_plot_dir(cma_args) traj_params_dir_name = get_full_params_dir(this_run_dir) intermediate_data_dir = get_intermediate_data_dir(this_run_dir, params_scope="pi") save_dir = get_save_dir(this_run_dir) if not os.path.exists(intermediate_data_dir): os.makedirs(intermediate_data_dir) if not os.path.exists(plot_dir_alg): os.makedirs(plot_dir_alg) start_file = get_full_param_traj_file_path(traj_params_dir_name, "pi_start") start_params = pd.read_csv(start_file, header=None).values[0] ''' ========================================================================================== get the pc vectors ========================================================================================== ''' pca_indexes = cma_args.other_pca_index pca_indexes = [int(pca_index) for pca_index in pca_indexes.split(":")] n_comp_to_project_on = pca_indexes result = do_pca(n_components=cma_args.n_components, traj_params_dir_name=traj_params_dir_name, intermediate_data_dir=intermediate_data_dir, use_IPCA=cma_args.use_IPCA, chunk_size=cma_args.chunk_size, reuse=True) logger.debug("after pca") if origin_name == "final_param": origin_param = result["final_params"] elif origin_name == "start_param": origin_param = start_params else: origin_param = result["mean_param"] proj_coords = project(result["pcs_components"], pcs_slice=n_comp_to_project_on, origin_name=origin_name, origin_param=origin_param, IPCA_chunk_size=cma_args.chunk_size, traj_params_dir_name=traj_params_dir_name, intermediate_data_dir=intermediate_data_dir, n_components=cma_args.n_components, reuse=True) ''' ========================================================================================== eval all xy coords ========================================================================================== ''' other_pcs_plot_dir = get_other_pcs_plane_plot_dir(plot_dir_alg, pca_indexes) if not os.path.exists(other_pcs_plot_dir): os.makedirs(other_pcs_plot_dir) plot_3d_trajectory_path_only( other_pcs_plot_dir, f"{pca_indexes}_final_origin_3d_path_plot", proj_coords, explained_ratio=result["explained_variance_ratio"][pca_indexes])
def render(self, mode='human', close=False): if close: return if not self.done: logger.debug(f'\n\n-------TURN {self.turns_taken + 1}-----------') logger.debug(f"It is Player {self.current_player.id}'s turn to choose") else: logger.debug(f'\n\n-------FINAL POSITION-----------') out = '\n' for square in range(self.squares): if self.board.hudson == square: if self.board.hudson_facing == 'R': out += '>H>\t' elif self.board.hudson_facing == 'L': out += '<H<\t' elif self.board.hudson_facing == 'U': out += '^H^\t' elif self.board.hudson_facing == 'D': out += 'vHv\t' elif self.board.tiles[square] == None: if self.board.nets[square]: out += '-🥅-\t' else: out += '---\t' else: out += self.board.tiles[square].symbol + ':' + str(self.board.tiles[square].id) + '\t' if square % self.board_size == self.board_size - 1: logger.debug(out) out = '' logger.debug('\n') for p in self.players: logger.debug(f'Player {p.id}\'s position') if p.position.size() > 0: out = ' '.join([tile.symbol for tile in sorted(p.position.tiles, key=lambda x: x.id) if tile.type != 'cricket']) out += ' ' + ' '.join([tile.symbol for tile in p.position.tiles if tile.type == 'cricket']) logger.debug(out) else: logger.debug('Empty') logger.debug(f'\n{self.drawbag.size()} tiles left in drawbag') if self.verbose: obs_sparse = [i if o == 1 else (i,o) for i,o in enumerate(self.observation) if o != 0] logger.debug(f'\nObservation: \n{obs_sparse}') if self.done: logger.debug(f'\n\nGAME OVER') else: logger.debug(f'\nLegal actions: {[i for i,o in enumerate(self.legal_actions) if o != 0]}') logger.debug(f'\n') for p in self.players: logger.debug(f'Player {p.id} points: {p.position.score}')
def choose_net_tile(self): logger.debug(f'Player {self.current_player.id} choosing extra tile using net') self.current_player.position.add(self.drawbag.draw(1))
def render(self, mode='human', close=False): if close: return if self.turns_taken < self.cards_per_player: logger.debug( f'\n\n-------ROUND {self.round} : TURN {self.turns_taken + 1}-----------' ) logger.debug( f"It is Player {self.current_player.id}'s turn to choose") else: logger.debug( f'\n\n-------FINAL ROUND {self.round} POSITION-----------') for p in self.players: logger.debug(f'\nPlayer {p.id}\'s hand') if p.hand.size() > 0: logger.debug(' '.join([ str(card.order) + ': ' + card.symbol for card in sorted(p.hand.cards, key=lambda x: x.id) ])) else: logger.debug('Empty') logger.debug(f'Player {p.id}\'s position') if p.position.size() > 0: logger.debug(' '.join([ str(card.order) + ': ' + card.symbol + ': ' + str(card.id) for card in sorted(p.position.cards, key=lambda x: x.id) ])) else: logger.debug('Empty') logger.debug(f'\n{self.deck.size()} cards left in deck') logger.debug(f'{self.discard.size()} cards discarded') if self.verbose: logger.debug( f'\nObservation: \n{[i if o == 1 else (i,o) for i,o in enumerate(self.observation) if o != 0]}' ) if not self.done: logger.debug( f'\nLegal actions: {[i for i,o in enumerate(self.legal_actions) if o != 0]}' ) if self.done: logger.debug(f'\n\nGAME OVER') if self.turns_taken == self.cards_per_player: for p in self.players: logger.debug(f'Player {p.id} points: {p.score}')
def main(): # requires n_comp_to_use, pc1_chunk_size import sys logger.log(sys.argv) common_arg_parser = get_common_parser() cma_args, cma_unknown_args = common_arg_parser.parse_known_args() this_run_dir = get_dir_path_for_this_run(cma_args) traj_params_dir_name = get_full_params_dir(this_run_dir) intermediate_data_dir = get_intermediate_data_dir(this_run_dir) if not os.path.exists(intermediate_data_dir): os.makedirs(intermediate_data_dir) logger.log("grab final params") final_file = get_full_param_traj_file_path(traj_params_dir_name, "final") final_params = pd.read_csv(final_file, header=None).values[0] logger.log("grab start params") start_file = get_full_param_traj_file_path(traj_params_dir_name, "start") start_params = pd.read_csv(start_file, header=None).values[0] V = final_params - start_params ''' ========================================================================================== get the pc vectors ========================================================================================== ''' result = do_pca(cma_args.n_components, cma_args.n_comp_to_use, traj_params_dir_name, intermediate_data_dir, proj=False, origin="mean_param", use_IPCA=cma_args.use_IPCA, chunk_size=cma_args.chunk_size, reuse=True) logger.debug("after pca") final_plane = result["first_n_pcs"] count_file = get_full_param_traj_file_path(traj_params_dir_name, "total_num_dumped") total_num = pd.read_csv(count_file, header=None).values[0] all_param_iterator = get_allinone_concat_df( dir_name=traj_params_dir_name, use_IPCA=True, chunk_size=cma_args.pc1_chunk_size) unduped_angles_along_the_way = [] duped_angles_along_the_way = [] diff_along = [] unweighted_pc1_vs_V_angles = [] duped_pc1_vs_V_angles = [] pc1_vs_V_diffs = [] unweighted_ipca = IncrementalPCA( n_components=cma_args.n_comp_to_use) # for sparse PCA to speed up all_matrix_buffer = [] try: i = -1 for chunk in all_param_iterator: i += 1 if i >= 2: break chunk = chunk.values unweighted_ipca.partial_fit(chunk) unweighted_angle = cal_angle_between_nd_planes( final_plane, unweighted_ipca.components_[:cma_args.n_comp_to_use]) unweighted_pc1_vs_V_angle = postize_angle( cal_angle_between_nd_planes(V, unweighted_ipca.components_[0])) unweighted_pc1_vs_V_angles.append(unweighted_pc1_vs_V_angle) #TODO ignore 90 or 180 for now if unweighted_angle > 90: unweighted_angle = 180 - unweighted_angle unduped_angles_along_the_way.append(unweighted_angle) np.testing.assert_almost_equal( cal_angle_between_nd_planes( unweighted_ipca.components_[:cma_args.n_comp_to_use][0], final_plane[0]), cal_angle( unweighted_ipca.components_[:cma_args.n_comp_to_use][0], final_plane[0])) all_matrix_buffer.extend(chunk) weights = gen_weights(all_matrix_buffer, Funcs[cma_args.func_index_to_use]) logger.log(f"currently at {all_param_iterator._currow}") # ipca = PCA(n_components=1) # for sparse PCA to speed up # ipca.fit(duped_in_so_far) wpca = WPCA(n_components=cma_args.n_comp_to_use ) # for sparse PCA to speed up tic = time.time() wpca.fit(all_matrix_buffer, weights=weights) toc = time.time() logger.debug( f"WPCA of {len(all_matrix_buffer)} data took {toc - tic} secs " ) duped_angle = cal_angle_between_nd_planes( final_plane, wpca.components_[:cma_args.n_comp_to_use]) duped_pc1_vs_V_angle = postize_angle( cal_angle_between_nd_planes(V, wpca.components_[0])) duped_pc1_vs_V_angles.append(duped_pc1_vs_V_angle) pc1_vs_V_diffs.append(duped_pc1_vs_V_angle - unweighted_pc1_vs_V_angle) #TODO ignore 90 or 180 for now if duped_angle > 90: duped_angle = 180 - duped_angle duped_angles_along_the_way.append(duped_angle) diff_along.append(unweighted_angle - duped_angle) finally: plot_dir = get_plot_dir(cma_args) if not os.path.exists(plot_dir): os.makedirs(plot_dir) angles_plot_name = f"WPCA" \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(duped_angles_along_the_way)), duped_angles_along_the_way, "num of chunks", "angle with diff in degrees", False) angles_plot_name = f"Not WPCA exponential 2" \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(unduped_angles_along_the_way)), unduped_angles_along_the_way, "num of chunks", "angle with diff in degrees", False) angles_plot_name = f"Not WPCA - WPCA diff_along exponential 2," \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(diff_along)), diff_along, "num of chunks", "angle with diff in degrees", False) angles_plot_name = f"PC1 VS VWPCA PC1 VS V" \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(duped_pc1_vs_V_angles)), duped_pc1_vs_V_angles, "num of chunks", "angle with diff in degrees", False) angles_plot_name = f"PC1 VS VNot WPCA PC1 VS V" \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(unweighted_pc1_vs_V_angles)), unweighted_pc1_vs_V_angles, "num of chunks", "angle with diff in degrees", False) angles_plot_name = f"PC1 VS VNot WPCA - WPCA diff PC1 VS V" \ f"cma_args.pc1_chunk_size: {cma_args.pc1_chunk_size} " plot_2d(plot_dir, angles_plot_name, np.arange(len(pc1_vs_V_diffs)), pc1_vs_V_diffs, "num of chunks", "angle with diff in degrees", False) del all_matrix_buffer import gc gc.collect()
def pickup_chopsticks(self, player): logger.debug(f'Player {player.id} picking up chopsticks') chopsticks = player.position.pick('chopsticks') player.hand.add([chopsticks])