def test_simple_cid_examples(self) -> None: get_minimal_cid() get_3node_cid() get_5node_cid() get_5node_cid_with_scaled_utility() get_2dec_cid() get_sequential_cid() get_insufficient_recall_cid() get_trim_example_cid()
def test_make_chance(self) -> None: cid = get_3node_cid() self.assertCountEqual(cid.all_decision_nodes, ['D']) cid.make_decision('S') self.assertCountEqual(cid.all_decision_nodes, ['D', 'S']) cid.make_chance('S') self.assertCountEqual(cid.all_decision_nodes, ['D'])
def test_possible_pure_decision_rules(self) -> None: cid = get_minimal_cid() possible_pure_decision_rules = cid.pure_decision_rules('A') self.assertEqual(len(possible_pure_decision_rules), 2) expected_utilities = [] for decision_rule in possible_pure_decision_rules: cid.add_cpds(decision_rule) cid.check_model() expected_utilities.append(cid.expected_utility({})) self.assertEqual(set(expected_utilities), {0, 1}) cid = get_3node_cid() possible_pure_decision_rules = cid.pure_decision_rules('D') self.assertEqual(len(possible_pure_decision_rules), 4) expected_utilities = [] matrices = set() for decision_rule in possible_pure_decision_rules: cid.add_cpds(decision_rule) matrices.add(tuple(cid.get_cpds('D').values.flatten())) cid.check_model() expected_utilities.append(cid.expected_utility({})) self.assertEqual(set(expected_utilities), {-1, 0, 1}) self.assertEqual(len(matrices), 4) five_node = get_5node_cid() possible_pure_decision_rules = five_node.pure_decision_rules('D') self.assertEqual(len(possible_pure_decision_rules), 16) expected_utilities = [] for decision_rule in possible_pure_decision_rules: five_node.add_cpds(decision_rule) five_node.check_model() expected_utilities.append(five_node.expected_utility({})) self.assertEqual(set(expected_utilities), {0.5, 1.0, 1.5})
def test_query(self) -> None: three_node = get_3node_cid() with self.assertRaises(Exception): three_node.query(['U'], {}) with self.assertRaises(Exception): three_node.query(['U'], {'D': 0}) three_node.impute_random_policy() with self.assertRaises(Exception): three_node.query(['U'], {'S': 0})
def test_make_decision(self) -> None: cid = get_3node_cid() self.assertCountEqual(cid.all_decision_nodes, ['D']) cid.make_decision('S') self.assertCountEqual(cid.all_decision_nodes, ['D', 'S']) self.assertEqual(cid.whose_node['S'], 0) self.assertCountEqual(cid.decision_nodes_agent[0], ['D', 'S']) cid2 = cid.copy_without_cpds() with self.assertRaises(Exception): cid2.make_decision('S')
def test_expected_utility(self) -> None: three_node = get_3node_cid() five_node = get_5node_cid() eu00 = three_node.expected_utility({'D': 0, 'S': 0}) self.assertEqual(eu00, 1) eu10 = three_node.expected_utility({'D': 1, 'S': 0}) self.assertEqual(eu10, 0) eu000 = five_node.expected_utility({'D': 0, 'S1': 0, 'S2': 0}) self.assertEqual(eu000, 2) eu001 = five_node.expected_utility({'D': 0, 'S1': 0, 'S2': 1}) self.assertEqual(eu001, 1)
def test_expected_utility(self) -> None: three_node = get_3node_cid() five_node = get_5node_cid() eu00 = three_node.expected_utility({'D': -1, 'S': -1}) self.assertEqual(eu00, 1) eu10 = three_node.expected_utility({'D': 1, 'S': -1}) self.assertEqual(eu10, -1) eu000 = five_node.expected_utility({'D': 0, 'S1': 0, 'S2': 0}) self.assertEqual(eu000, 2) eu001 = five_node.expected_utility({'D': 0, 'S1': 0, 'S2': 1}) self.assertEqual(eu001, 1) macid_example = prisoners_dilemma() eu_agent0 = macid_example.expected_utility({'D1': 'd', 'D2': 'c'}, agent=1) self.assertEqual(eu_agent0, 0) eu_agent1 = macid_example.expected_utility({'D1': 'd', 'D2': 'c'}, agent=2) self.assertEqual(eu_agent1, -3)
def test_find_all_undir_paths(self) -> None: example = get_3node_cid() self.assertTrue(len(find_all_undir_paths(example, 'S', 'U')) == 2) with self.assertRaises(Exception): find_all_undir_paths(example, 'S', 'A') example2 = MACID([ ('X1', 'D'), ('X2', 'U')], {1: {'D': ['D'], 'U': ['U']}}) self.assertEqual(find_all_undir_paths(example2, 'X1', 'D'), [['X1', 'D']]) self.assertFalse(find_all_undir_paths(example2, 'X1', 'U')) example3 = MACID([ ('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'E'), ('B', 'F'), ('F', 'E')], {1: {'D': ['D'], 'U': ['E']}}) self.assertCountEqual(find_all_undir_paths(example3, 'F', 'A'), [['F', 'E', 'D', 'C', 'B', 'A'], ['F', 'B', 'A']])
def test_optimal_decision_rules(self) -> None: cid = get_minimal_cid() optimal_decision_rules = cid.optimal_pure_decision_rules('A') self.assertEqual(len(optimal_decision_rules), 1) for cpd in optimal_decision_rules: cid.add_cpds(cpd) self.assertEqual(cid.expected_utility({}), 1) cid = get_3node_cid() optimal_decision_rules = cid.optimal_pure_decision_rules('D') self.assertEqual(len(optimal_decision_rules), 1) for cpd in optimal_decision_rules: cid.add_cpds(cpd) self.assertEqual(cid.expected_utility({}), 1) five_node = get_5node_cid() optimal_decision_rules = five_node.optimal_pure_decision_rules('D') self.assertEqual(len(optimal_decision_rules), 4) five_node.impute_optimal_policy() for cpd in optimal_decision_rules: five_node.add_cpds(cpd) self.assertEqual(five_node.expected_utility({}), 1.5)
def test_solve(self) -> None: three_node = get_3node_cid() three_node.solve() solution = three_node.solve() # check that it can be solved repeatedly cpd2 = solution['D'] self.assertTrue(np.array_equal(cpd2.values, np.array([[1, 0], [0, 1]]))) three_node.add_cpds(cpd2) self.assertEqual(three_node.expected_utility({}), 1) two_decisions = get_2dec_cid() solution = two_decisions.solve() cpd = solution['D2'] self.assertTrue(np.array_equal(cpd.values, np.array([[1, 0], [0, 1]]))) two_decisions.add_cpds(*list(solution.values())) self.assertEqual(two_decisions.expected_utility({}), 1) sequential = get_sequential_cid() sequential.solve() cid = get_insufficient_recall_cid() cid.impute_optimal_policy() self.assertEqual(cid.expected_utility({}), 1)
def test_assign_cpd(self) -> None: three_node = get_3node_cid() three_node.add_cpds(TabularCPD('D', 2, np.eye(2), evidence=['S'], evidence_card=[2])) three_node.check_model() cpd = three_node.get_cpds('D').values self.assertTrue(np.array_equal(cpd, np.array([[1, 0], [0, 1]])))
def test_remove_add_edge(self) -> None: cid = get_3node_cid() cid.remove_edge('S', 'D') self.assertTrue(cid.check_model()) cid.add_edge('S', 'D') self.assertTrue(cid.check_model())
def test_copy_without_cpds(self) -> None: cid = get_3node_cid() cid_no_cpds = cid.copy_without_cpds() self.assertTrue(len(cid_no_cpds.cpds) == 0)
def test_query(self) -> None: three_node = get_3node_cid() with self.assertRaises(Exception): three_node._query(['U'], {}) with self.assertRaises(Exception): three_node._query(['U'], {'D': 0})