def test_remove_dpr_profiles_with_no_data(): """Test that dpr removes profiles with no data""" profiles = [[1, 3], [3, 1]] payoffs = [[3, 4], [6, np.nan]] game = dpr.reduce_game(paygame.game(4, 2, profiles, payoffs), 2) assert game.num_profiles == 1 profiles = [[1, 3], [3, 1]] payoffs = [[np.nan, 4], [6, np.nan]] game = dpr.reduce_game(paygame.game(4, 2, profiles, payoffs), 2) assert game.is_empty() profiles = [[1, 3]] payoffs = [[3, 4]] game = dpr.reduce_game(paygame.game(4, 2, profiles, payoffs), 2) assert game.num_profiles == 1 profiles = [[1, 3]] payoffs = [[np.nan, 4]] game = dpr.reduce_game(paygame.game(4, 2, profiles, payoffs), 2) assert game.is_empty()
def test_dpr_names(): """Test names for dpr game""" base = rsgame.empty(3, 2) game = paygame.game_names( ['role'], 3, [['a', 'b']], base.all_profiles(), np.zeros((base.num_all_profiles, base.num_strats))) redgame = dpr.reduce_game(game, 2) expected = paygame.game_names( ['role'], 2, [['a', 'b']], redgame.all_profiles(), np.zeros((redgame.num_all_profiles, base.num_strats))) assert redgame == expected
def test_empty_dpr_1(): """Reduction is empty because profile is invalid""" profiles = [ [2, 4], ] payoffs = [ [1, 2], ] game = paygame.game(6, 2, profiles, payoffs) red_game = dpr.reduce_game(game, 2) assert np.all(red_game.num_role_players == [2]) assert red_game.is_empty()
def test_random_approximate_dpr(players, strategies, _): """Test approximate dpr preserves completeness on random games""" game = gamegen.game(players, strategies) red_counts = 2 + (rand.random(game.num_roles) * (game.num_role_players - 1)).astype(int) red_counts[game.num_role_players == 1] = 1 # Try to reduce game red_game = dpr.reduce_game(game, red_counts) # Assert that reducing all profiles covers reduced game assert red_game.is_complete(), 'DPR did not preserve completeness'
def test_random_dpr(keep_prob, game_desc, _): """Simple test that dpr functions are consistent""" players, strategies, red_players = game_desc # Create game game = gamegen.game(players, strategies, keep_prob) # Try to reduce game red_game = dpr.reduce_game(game, red_players) assert (rsgame.empty(red_players, strategies) == dpr.reduce_game(rsgame.empty(players, strategies), red_players)) # Assert that reducing all profiles covers reduced game reduced_profiles = utils.axis_to_elem(red_game.profiles()) reduced_full_profiles = utils.axis_to_elem( dpr.reduce_profiles(red_game, game.profiles())) assert np.setdiff1d(reduced_profiles, reduced_full_profiles).size == 0, \ "reduced game contained profiles it shouldn't have" # Assert that all contributing profiles are in the expansion of the reduced # game, we need to first filter for complete profiles full_profiles = utils.axis_to_elem(game.profiles()) complete_profs = ~np.isnan(red_game.payoffs()).any(1) full_reduced_profiles = utils.axis_to_elem( dpr.expand_profiles(game, red_game.profiles()[complete_profs])) assert np.setdiff1d(full_reduced_profiles, full_profiles).size == 0, \ 'full game did not have data for all profiles required of reduced' # Assert that dpr counts are accurate num_dpr_profiles = dpr.expand_profiles( game, red_game.all_profiles()).shape[0] assert num_dpr_profiles == red_game.num_all_dpr_profiles # Test the dpr deviation profile counts are accurate rest = red_game.random_restriction() dpr_devs = dpr.expand_profiles( game, restrict.deviation_profiles(red_game, rest)).shape[0] num = restrict.num_dpr_deviation_profiles(red_game, rest) assert dpr_devs == num, \ "num_dpr_deviation_profiles didn't return correct number"
def test_empty_dpr_2(): """Reduction is empty because profile doesn\'t have all payoffs""" profiles = [ [1, 3], ] payoffs = [ [1, 2], ] game = paygame.game(4, 2, profiles, payoffs) red_game = dpr.reduce_game(game, 2) assert np.all(red_game.num_role_players == [2]) assert np.all(red_game.profiles() == [[1, 1]]) assert [1, 1] not in red_game # incomplete profiles don't register
def test_dpr_incomplete_profile(): """Test that when allow_incomplete, we get appropriate payoffs""" profiles = [[4, 0, 0, 9], [1, 3, 9, 0], [2, 2, 9, 0]] payoffs = [[1, 0, 0, 2], [3, 4, 5, 0], [6, 7, 8, 0]] game = paygame.game([4, 9], 2, profiles, payoffs) red_game = dpr.reduce_game(game, [2, 3]) actual = red_game.get_payoffs([2, 0, 0, 3]) assert np.allclose(actual, [1, 0, 0, 2]) actual = red_game.get_payoffs([1, 1, 3, 0]) assert np.allclose(actual, [3, np.nan, 8, 0], equal_nan=True)
def reduce_game(full_game, red_players=None): """Reduce a game using twins reduction Parameters ---------- full_game : Game The game to reduce. red_players : ndarray-like, optional The reduced number of players for each role. This must be None or the reduced number of players for the twins reductions. """ exp_red_players = np.minimum(full_game.num_role_players, 2) utils.check(red_players is None or np.all(exp_red_players == red_players), "twins reduction didn't get expected reduced players") return dpr.reduce_game(full_game, exp_red_players)
def reduce_game(full_game, red_players=None): """Reduce a game using twins reduction Parameters ---------- full_game : Game The game to reduce. red_players : ndarray-like, optional The reduced number of players for each role. This must be None or the reduced number of players for the twins reductions. """ exp_red_players = np.minimum(full_game.num_role_players, 2) utils.check( red_players is None or np.all(exp_red_players == red_players), "twins reduction didn't get expected reduced players") return dpr.reduce_game(full_game, exp_red_players)
def test_approximate_dpr_reduce_game(): """Test approximate dpr game reduction""" game = gamegen.game([3, 4], 2) redgame = dpr.reduce_game(game, 2) # Pure strategies are reduced properly assert (redgame.get_payoffs([2, 0, 0, 2])[0] == game.get_payoffs([3, 0, 0, 4])[0]) # Mixed strategies are reduced properly assert (redgame.get_payoffs([1, 1, 1, 1])[0] == game.get_payoffs([1, 2, 2, 2])[0]) assert (redgame.get_payoffs([1, 1, 1, 1])[1] == game.get_payoffs([2, 1, 2, 2])[1]) assert (redgame.get_payoffs([1, 1, 1, 1])[2] == game.get_payoffs([2, 1, 1, 3])[2]) assert (redgame.get_payoffs([1, 1, 1, 1])[3] == game.get_payoffs([2, 1, 3, 1])[3])
def test_reduction_basic(hardgame, hardgame_str): """Test basic reduction""" with stdin(hardgame_str), stdout() as out, stderr() as err: assert run('red', 'background:2;hft:1'), err.getvalue() game = gamereader.loads(out.getvalue()) assert game == dpr.reduce_game(hardgame, [2, 1])