async def test_random_redgame(players, strats, _):
"""Test properties of games returned from scheduler"""
game = gamegen.samplegame(players, strats)
rest = game.random_restriction()
sched = gamesched.samplegamesched(game)
sgame = schedgame.schedgame(sched)
devgame1 = await sgame.get_deviation_game(rest)
prof = devgame1.profiles()[
np.all((devgame1.profiles() == 0) | ~np.isnan(devgame1.payoffs()), 1).nonzero()[
0
][0]
]
assert prof in devgame1
assert (
devgame1.num_complete_profiles
<= devgame1.num_profiles
<= devgame1.num_all_profiles
)
devgame2 = await sgame.get_deviation_game(rest)
assert hash(devgame1) == hash(devgame2)
assert devgame1 == devgame2
assert devgame1 + devgame2 == devgame2 + devgame1
assert np.allclose(devgame1.get_payoffs(prof), devgame2.get_payoffs(prof))
rrest = devgame1.random_restriction()
assert devgame1.restrict(rrest) == devgame2.restrict(rrest)
def test_mixture_regret_parallel(num_mixes, num_boots):
"""Test mixture regret run on multiple processors"""
game = gamegen.samplegame([4, 3], [3, 4])
mixes = game.random_mixtures(num_mixes)
boots = bootstrap.mixture_regret(game, mixes, num_boots)
assert boots.shape == (num_mixes, num_boots)
assert np.all(boots >= 0)
def test_samplegame(players, strategies, _):
"""Test samplegame"""
game = gamegen.samplegame(players, strategies)
assert game.is_complete(), "didn't generate a full game"
assert np.all(players == game.num_role_players), \
"didn't generate correct number of strategies"
assert np.all(strategies == game.num_role_strats), \
"didn't generate correct number of strategies"
def test_samplegame(players, strategies, _):
"""Test samplegame"""
game = gamegen.samplegame(players, strategies)
assert game.is_complete(), "didn't generate a full game"
assert np.all(players == game.num_role_players), \
"didn't generate correct number of strategies"
assert np.all(strategies == game.num_role_strats), \
"didn't generate correct number of strategies"
async def test_random_normalize(players, strats, _):
"""Test normalizing random games"""
game = gamegen.samplegame(players, strats)
sched = gamesched.samplegamesched(game)
sgame = schedgame.schedgame(sched)
rgame = await sgame.get_restricted_game(np.ones(game.num_strats, bool))
ngame = rgame.normalize()
assert np.all(ngame.payoffs() >= -1e-7)
assert np.all(ngame.payoffs() <= 1 + 1e-7)
async def test_noise_profile():
"""Test adding noise"""
sgame = gamegen.samplegame([4, 3], [3, 4])
profs = sgame.random_profiles(20)
sched = gamesched.samplegamesched(
sgame, lambda w: rand.normal(0, w, sgame.num_strats), lambda: (rand.random(),)
)
paylist = await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
pays = np.stack(paylist)
assert np.allclose(pays[profs == 0], 0)
async def test_exception(players, strats, when, _):
"""Test that exceptions are raised appropriately"""
game = gamegen.samplegame(players, strats)
sched = gamesched.samplegamesched(game)
esched = utils.ExceptionScheduler(sched, 10, when)
sgame = schedgame.schedgame(esched)
rests = np.concatenate(
[game.random_restrictions(3), np.ones((1, game.num_strats), bool)]
)
with pytest.raises(utils.SchedulerException):
await asyncio.gather(*[sgame.get_restricted_game(rest) for rest in rests])
async def test_basic_profile_sample():
"""Test basic profile in sample game"""
sgame = gamegen.samplegame([4, 3], [3, 4])
profs = sgame.random_profiles(20)
sched = gamesched.samplegamesched(sgame)
assert rsgame.empty_copy(sched) == rsgame.empty_copy(sgame)
paylist = await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
pays = np.stack(paylist)
assert np.allclose(pays[profs == 0], 0)
assert str(sched) == repr(sgame)
async def test_duplicate_profile_sample():
"""Test duplicate profile in sample game"""
sgame = gamegen.samplegame([4, 3], [3, 4], 0)
profs = sgame.random_profiles(20)
sched = gamesched.samplegamesched(sgame)
paylist1 = await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
pays1 = np.stack(paylist1)
paylist2 = await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
pays2 = np.stack(paylist2)
assert np.allclose(pays1[profs == 0], 0)
assert np.allclose(pays2[profs == 0], 0)
assert np.allclose(pays1, pays2)
async def test_basic_profile():
"""Test that basic profiles are sampled twice"""
sgame = gamegen.samplegame([4, 3], [3, 4])
profs = utils.axis_from_elem(
np.unique(utils.axis_to_elem(sgame.random_profiles(20))))
save = savesched.savesched(gamesched.samplegamesched(sgame))
sched = countsched.countsched(save, 10)
assert str(sched) is not None
paylist = await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
pays = np.stack(paylist)
assert np.allclose(pays[profs == 0], 0)
savegame = save.get_game()
assert list(savegame.num_samples) == [10]
async def test_basic_profile(_):
"""Test that profiles are saved"""
sgame = gamegen.samplegame([4, 3], [3, 4], 0)
profs = sgame.all_profiles()
basesched = gamesched.samplegamesched(sgame)
sched = savesched.savesched(basesched)
assert str(sched) == str(basesched)
assert rsgame.empty_copy(sgame) == rsgame.empty_copy(sched)
await asyncio.gather(*[sched.sample_payoffs(p) for p in profs[:10]])
sched.get_game()
sched = savesched.savesched(gamesched.samplegamesched(sgame))
await asyncio.gather(*[sched.sample_payoffs(p) for p in profs])
savegame = sched.get_game()
assert sgame == savegame
assert sgame == sched.get_game()
async def test_random_complete_dev(players, strats, _):
"""Test the deviations are complete in random games"""
game = gamegen.samplegame(players, strats)
sched = gamesched.samplegamesched(game)
sgame = schedgame.schedgame(sched)
mix = sgame.random_sparse_mixture()
supp = mix > 0
dev_game = await sgame.get_deviation_game(supp)
devs, jac = dev_game.deviation_payoffs(mix, jacobian=True)
assert not np.isnan(devs).any()
assert not np.isnan(jac[supp]).any()
assert np.isnan(jac[~supp]).all()
for role in range(sgame.num_roles):
mask = (role == sgame.role_indices)
dev_game = await sgame.get_deviation_game(supp, role_index=role)
rdevs = dev_game.deviation_payoffs(mix)
assert np.allclose(rdevs[supp], devs[supp])
assert np.allclose(rdevs[mask], devs[mask])
assert supp[~mask].all() or np.isnan(rdevs[~mask]).any()
async def test_random_caching(players, strats, _):
"""Test that profiles are cached (identical)"""
game = gamegen.samplegame(players, strats)
rest1, rest2 = game.random_restrictions(2)
sched = gamesched.samplegamesched(game)
sgame = schedgame.schedgame(sched)
assert str(sgame) == str(sched)
rgame11 = await sgame.get_restricted_game(rest1)
rgame21 = await sgame.get_restricted_game(rest2)
devs11 = await sgame.get_deviation_game(rest1)
devs21 = await sgame.get_deviation_game(rest2)
rgame12 = await sgame.get_restricted_game(rest1)
rgame22 = await sgame.get_restricted_game(rest2)
assert rgame11 == rgame12
assert rgame21 == rgame22
devs12 = await sgame.get_deviation_game(rest1)
devs22 = await sgame.get_deviation_game(rest2)
assert devs11 == devs12
assert devs21 == devs22
def fix_sgame():
"""Create a sample game"""
return gamegen.samplegame([2, 3], [4, 3], 0.05)
def test_sparse_samplegame():
"""Test sparse sample game"""
game = gamegen.samplegame([4, 4], [4, 4], 0.5, 0)
# Very unlikely to fail
assert not game.is_complete()
def test_add_widths(players, strats, func):
"""Test add widths"""
sgame = gamegen.samplegame(players, strats, noise_distribution=func)
assert sgame.is_complete()
def test_add_widths(players, strats, func):
"""Test add widths"""
sgame = gamegen.samplegame(players, strats, noise_distribution=func)
assert sgame.is_complete()
def test_sparse_samplegame():
"""Test sparse sample game"""
game = gamegen.samplegame([4, 4], [4, 4], 0.5, 0)
# Very unlikely to fail
assert not game.is_complete()
