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])
