async def test_innerloop_by_role_simple(base):
"""Test that inner loop works by role"""
sgame = gamegen.samplegame_replace(base)
sched = gamesched.samplegamesched(sgame)
eqa = await innerloop.inner_loop(schedgame.schedgame(sched),
devs_by_role=True)
verify_dist_thresh(eqa)
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)
async def test_innerloop_num_eqa(base, num):
"""Test that inner loop returns alternate number of equilibria"""
sgame = gamegen.samplegame_replace(base)
sched = gamesched.samplegamesched(sgame)
eqa = await innerloop.inner_loop(schedgame.schedgame(sched),
num_equilibria=num,
devs_by_role=True)
verify_dist_thresh(eqa)
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_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_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_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_innerloop_dpr(redgame):
"""Test that inner loop handles dpr"""
fullgame = rsgame.empty(redgame.num_role_players**2,
redgame.num_role_strats)
profs = dpr.expand_profiles(fullgame, redgame.all_profiles())
pays = np.random.random(profs.shape)
pays[profs == 0] = 0
sgame = paygame.samplegame_replace(fullgame, profs, [pays[:, None]])
sched = gamesched.samplegamesched(sgame)
game = schedgame.schedgame(sched, dpr, redgame.num_role_players)
eqa = await innerloop.inner_loop(game)
verify_dist_thresh(eqa)
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_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
async def test_innerloop_simple(base):
"""Test that inner loop works for a simple setup"""
sgame = gamegen.samplegame_replace(base)
sched = gamesched.samplegamesched(sgame)
eqa = await innerloop.inner_loop(schedgame.schedgame(sched))
verify_dist_thresh(eqa)
