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})
