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"
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()