def _solve_game_using_eraser(): eraser = Eraser(testing_game) eraser.solve() return eraser
class TestSolvers(unittest.TestCase): @classmethod def setUpClass(self): """ Create Games: 1) Set up a security game, generate corresponding norm_form and harsanyi-transformed norm_form game. 2) Set up a large non-bayesian security game 3) Set up bayesian norm_form, generate corresponding harsanyi- transformed norm_form game. 4) Set up norm_form game. Solve Games: """ # construct games # part 1 self.sec_game = SecurityGame(num_targets=5, max_coverage=3, num_attacker_types=1) self.sec_norm_game = NormalFormGame(game=self.sec_game, harsanyi=False) self.sec_norm_hars_game = NormalFormGame(game=self.sec_norm_game) # part 2 self.large_sec_game = SecurityGame(num_targets=100, max_coverage=30, num_attacker_types=1) # part 3 self.bayse_sec_game = SecurityGame(num_targets=5, max_coverage=3, num_attacker_types=2) self.bayse_sec_norm_game = NormalFormGame(game=self.bayse_sec_game, harsanyi=False) self.bayse_sec_norm_hars_game = NormalFormGame( game=self.bayse_sec_norm_game) # part 4 self.bayse_norm_game = NormalFormGame(num_defender_strategies=10, num_attacker_strategies=3, num_attacker_types=3) self.bayse_norm_hars_game = NormalFormGame(game=self.bayse_norm_game) self.bayse_norm_partial_full_game = NormalFormGame( partial_game_from=self.bayse_norm_game, attacker_types=(0, 1, 2)) self.bayse_norm_partial_game = NormalFormGame( partial_game_from=self.bayse_norm_game, attacker_types=(1, 2)) # part 5 self.norm_game = NormalFormGame(num_defender_strategies=20, num_attacker_strategies=10, num_attacker_types=1) # solve games: # part 1 (non-bayesian security games) print("solving part 1") self.p1_eraser = Eraser(self.sec_game) self.p1_origami = Origami(self.sec_game) self.p1_origami_milp = OrigamiMILP(self.sec_game) self.p1_dobbs = Dobbs(self.sec_norm_game) self.p1_multLP = MultipleLP(self.sec_norm_hars_game) self.p1_multSingLP_sec_game = Multiple_SingleLP(self.sec_game) self.p1_multSingLP_sec_norm_game = Multiple_SingleLP( self.sec_norm_game) self.p1_multSingLP_sec_norm_hars_game = Multiple_SingleLP( self.sec_norm_hars_game) self.p1_eraser.solve() self.p1_origami.solve() self.p1_origami_milp.solve() self.p1_dobbs.solve() self.p1_multLP.solve() self.p1_multSingLP_sec_game.solve() self.p1_multSingLP_sec_norm_game.solve() self.p1_multSingLP_sec_norm_hars_game.solve() # part 2 (large security game) print("solving part 2") self.p2_large_origami = Origami(self.large_sec_game) self.p2_large_origami_milp = OrigamiMILP(self.large_sec_game) self.p2_large_eraser = Eraser(self.large_sec_game) self.p2_large_origami.solve() self.p2_large_origami_milp.solve() self.p2_large_eraser.solve() # part 3 (bayseian security games) print("solving part 3") self.p3_dobbs = Dobbs(self.bayse_sec_norm_game) self.p3_multLP = MultipleLP(self.bayse_sec_norm_hars_game) self.p3_multSingLP = Multiple_SingleLP(self.bayse_sec_game) self.p3_hbgs = HBGS(self.bayse_sec_game) self.p3_hbgs_origami = HBGS(self.bayse_sec_game, True) self.p3_hbgs_norm = HBGS(self.bayse_sec_norm_game) self.p3_dobbs.solve() self.p3_multLP.solve() self.p3_multSingLP.solve() self.p3_hbgs.solve() self.p3_hbgs_origami.solve() self.p3_hbgs_norm.solve() # part 4 (bayesian norm_form game) print("solving part 4") self.p4_dobbs = Dobbs(self.bayse_norm_game) self.p4_multLP = MultipleLP(self.bayse_norm_hars_game) self.p4_multSingLP = Multiple_SingleLP(self.bayse_norm_game) self.p4_dobbs_partial_full = Dobbs(self.bayse_norm_partial_full_game) self.p4_multSingLP_partial_full = \ Multiple_SingleLP(self.bayse_norm_partial_full_game) self.p4_dobbs_partial = Dobbs(self.bayse_norm_partial_game) self.p4_multSingLP_partial = \ Multiple_SingleLP(self.bayse_norm_partial_game) self.p4_hbgs = HBGS(self.bayse_norm_game) self.p4_dobbs.solve() self.p4_multLP.solve() self.p4_multSingLP.solve() self.p4_dobbs_partial.solve() self.p4_dobbs_partial_full.solve() self.p4_multSingLP_partial_full.solve() self.p4_dobbs_partial.solve() self.p4_multSingLP_partial.solve() self.p4_hbgs.solve() # part 5 print("solving part 5") self.p5_dobbs = Dobbs(self.norm_game) self.p5_multLP = MultipleLP(self.norm_game) self.p5_multSingLP = Multiple_SingleLP(self.norm_game) self.p5_dobbs.solve() self.p5_multLP.solve() self.p5_multSingLP.solve() def test_p1(self): """ Test if opt_defender_payoff is the same across all solutions """ self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_eraser.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_multLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_origami.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_origami_milp.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_multSingLP_sec_game.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_multSingLP_sec_norm_game.\ opt_defender_payoff, places=1) self.assertAlmostEqual(self.p1_dobbs.opt_defender_payoff, self.p1_multSingLP_sec_norm_hars_game.\ opt_defender_payoff, places=1) def test_p2(self): """ Test if solvers taking compact representations of large games are in agreement. """ # test that every opt_target is the same for all solvers ori_target = self.p2_large_origami.opt_attacked_target ori_milp_target = self.p2_large_origami_milp.opt_attacked_target ers_target = self.p2_large_eraser.opt_attacked_target print("ORIGAMI SOL: {}".format(self.p2_large_origami.solution_time)) print("ORIGAMI OH SOL: {}".format( self.p2_large_origami.solution_time_with_overhead)) print("ORI_MILP SOL: {}".format( self.p2_large_origami_milp.solution_time)) print("ORI_MILP OH SOL: {}".format( self.p2_large_origami_milp.solution_time_with_overhead)) self.assertEqual(ori_target, ori_milp_target, msg="opt target disagree: origami vs. origami_milp") self.assertEqual(ori_milp_target, ers_target, msg="opt target disagree: origami_milp vs. eraser") # test that coverage is the same for attacked target self.assertAlmostEqual( self.p2_large_origami.opt_coverage[ori_target], self.p2_large_origami_milp.opt_coverage[ori_milp_target], places=1, msg="cov for attacked target disagree: origami vs. origami_milp") self.assertAlmostEqual( self.p2_large_origami.opt_coverage[ori_target], self.p2_large_eraser.opt_coverage[ers_target], places=1, msg="cov for attacked target disagree: origami vs. eraser") # test that payoff is the same self.assertAlmostEqual(self.p2_large_origami.opt_defender_payoff, self.p2_large_origami_milp.opt_defender_payoff, places=1, msg="payoff disagreement: orig vs. orig-milp") self.assertAlmostEqual(self.p2_large_origami.opt_defender_payoff, self.p2_large_eraser.opt_defender_payoff, places=1, msg="payoff disagreement: ori vs. eraser") # test that attackset are the same for origami and origami-milp self.assertEqual( len(self.p2_large_origami.opt_attack_set), len(self.p2_large_origami_milp.opt_attack_set), msg="attackset diff. length: origami vs. origami-milp") def test_p3(self): """ Test if opt_defender_payoff is the same across all solutions """ self.assertAlmostEqual(self.p3_dobbs.opt_defender_payoff, self.p3_multLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p3_dobbs.opt_defender_payoff, self.p3_multSingLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p3_hbgs.opt_defender_payoff, self.p3_dobbs.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p3_hbgs_origami.opt_defender_payoff, self.p3_dobbs.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p3_hbgs_norm.opt_defender_payoff, self.p3_dobbs.opt_defender_payoff, places=1) def test_p4(self): """ Test if bayesian normal form game solvers are in agreement. """ # print("sol tim, dob, mltLP vs. Singl") # print(self.p4_dobbs.solution_time) # print(self.p4_multLP.solution_time) # print(self.p4_multSingLP.solution_time) # test that the expected opt defender payoff is the same self.assertAlmostEqual(self.p4_dobbs.opt_defender_payoff, self.p4_multLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p4_dobbs.opt_defender_payoff, self.p4_multSingLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p4_dobbs_partial_full.opt_defender_payoff, self.p4_multSingLP_partial_full.\ opt_defender_payoff, places=1) self.assertAlmostEqual(self.p4_dobbs_partial.opt_defender_payoff, self.p4_multSingLP_partial.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p4_hbgs.opt_defender_payoff, self.p4_dobbs.opt_defender_payoff, places=1) # test that opt defender strat. yields the same attacker pure strategy self.assertSequenceEqual(self.p4_dobbs.opt_attacker_pure_strategy, self.p4_multSingLP.opt_attacker_pure_strategy) # self.assertSequenceEqual(self.p4_dobbs.opt_attacker_pure_strategy, # self.bayse_norm_hars_game.\ # attacker_pure_strategy_tuples[self.p4_multLP.\ # opt_attacker_pure_strategy]) def test_p5(self): """ Test agreement between all solvers of non-bayesian normal form games. """ # test that the expected opt defender payoff is the same self.assertAlmostEqual(self.p5_dobbs.opt_defender_payoff, self.p5_multLP.opt_defender_payoff, places=1) self.assertAlmostEqual(self.p5_dobbs.opt_defender_payoff, self.p5_multSingLP.opt_defender_payoff, places=1) # test that opt defender strat. yields the same attacker pure strategy self.assertSequenceEqual(self.p5_dobbs.opt_attacker_pure_strategy, self.p5_multSingLP.opt_attacker_pure_strategy) self.assertEqual(self.p5_dobbs.opt_attacker_pure_strategy[0], self.p5_multLP.opt_attacker_pure_strategy)