def score_history(self) -> Tuple[List[str], np.ndarray]: """ Compute the history of the scores for every agent. To do so, we need to simulate the game again, by settling transactions one by one and get the scores after every transaction. :return: a matrix of shape (nb_transactions + 1, nb_agents), where every row i contains the scores after transaction i (i=0 is a row with the initial scores.) """ nb_transactions = len(self.game.transactions) nb_agents = self.game.configuration.nb_agents result = np.zeros((nb_transactions + 1, nb_agents)) temp_game = Game(self.game.configuration, self.game.initialization) # initial scores scores_dict = temp_game.get_scores() result[0, :] = list(scores_dict.values()) keys = list(scores_dict.keys()) # compute the partial scores for every agent after every transaction # (remember that indexes of the transaction start from one, because index 0 is reserved for the initial scores) for idx, tx in enumerate(self.game.transactions): temp_game.settle_transaction(tx) scores_dict = temp_game.get_scores() result[idx + 1, :] = list(scores_dict.values()) return keys, result
def adjusted_score(self) -> Tuple[List[str], np.ndarray]: """ Compute the adjusted score of each agent. :return: a matrix of shape (1, nb_agents), where every column i contains the score of the agent. """ nb_agents = self.game.configuration.nb_agents current_scores = np.zeros((1, nb_agents), dtype=np.float32) eq_agent_states = dict(( agent_pbk, AgentState( self.game.initialization.eq_money_holdings[i], [int(h) for h in self.game.initialization.eq_good_holdings[i]], self.game.initialization.utility_params[i], ), ) for agent_pbk, i in zip( self.game.configuration.agent_pbks, range(self.game.configuration.nb_agents), )) # type: Dict[str, AgentState] result = np.zeros((1, nb_agents), dtype=np.float32) eq_scores = np.zeros((1, nb_agents), dtype=np.float32) eq_scores[0, :] = [ eq_agent_state.get_score() for eq_agent_state in eq_agent_states.values() ] temp_game = Game(self.game.configuration, self.game.initialization) # initial scores initial_scores = np.zeros((1, nb_agents), dtype=np.float32) scores_dict = temp_game.get_scores() initial_scores[0, :] = list(scores_dict.values()) keys = list(scores_dict.keys()) current_scores = np.zeros((1, nb_agents), dtype=np.float32) current_scores[0, :] = initial_scores[0, :] # compute the partial scores for every agent after every transaction # (remember that indexes of the transaction start from one, because index 0 is reserved for the initial scores) for idx, tx in enumerate(self.game.transactions): temp_game.settle_transaction(tx) scores_dict = temp_game.get_scores() current_scores[0, :] = list(scores_dict.values()) result[0, :] = np.divide( np.subtract(current_scores, initial_scores), np.subtract(eq_scores, initial_scores), ) result = np.transpose(result) return keys, result
def test_baseline_agent_score_does_not_decrease(self): """Test that all the baseline agent scores do not decrease after each transaction.""" finished_game = self.tac_controller.game_handler.current_game game_configuration = finished_game.configuration game_initialization = finished_game.initialization game = Game(game_configuration, game_initialization) scores_dict = game.get_scores() current_score = np.asarray(list(scores_dict.values())) next_scores = None for tx in finished_game.transactions: game.settle_transaction(tx) scores_dict = game.get_scores() next_scores = np.asarray(list(scores_dict.values())) assert not (next_scores < current_score).any() current_score = next_scores
def get_initial_scores(self) -> Dict[str, float]: """ Get the initial score for all agents. :return: dictionary mapping agent name to initial score. """ temp_game = Game(self.game.configuration, self.game.initialization) scores_dict = { self.game.configuration.agent_pbk_to_name[agent_pbk]: score for agent_pbk, score in temp_game.get_scores().items() } return scores_dict