def test_set_start_state_list(self, check_state):
model = MC(['b', 'a'], [1, 2])
check_state.return_value = True
model.set_start_state([State('a', 0), State('b', 1)])
model_state = [State('b', 1), State('a', 0)]
check_state.assert_called_once_with(model, model_state)
self.assertEqual(model.state, model_state)
def test_add_transition_model_bad_type(self):
model = MC()
grade_tm_matrix_bad = [[0.1, 0.5, 0.4], [0.2, 0.2, 0.6], 'abc']
# if transition_model is not a dict or np.array
self.assertRaises(ValueError, model.add_transition_model, 'var', 123)
self.assertRaises(ValueError, model.add_transition_model, 'var',
grade_tm_matrix_bad)
def test_generate_sample_less_arg(self, random_state, sample_discrete):
model = MC(['a', 'b'], [2, 2])
model.transition_models['a'] = {
0: {
0: 0.1,
1: 0.9
},
1: {
0: 0.2,
1: 0.8
}
}
model.transition_models['b'] = {
0: {
0: 0.3,
1: 0.7
},
1: {
0: 0.4,
1: 0.6
}
}
random_state.return_value = [State('a', 0), State('b', 1)]
sample_discrete.side_effect = [[1], [0]] * 2
gen = model.generate_sample(size=2)
samples = [sample for sample in gen]
expected_samples = [[State('a', 1), State('b', 0)]] * 2
self.assertEqual(samples, expected_samples)
def test_sample(self):
model = MC(['a', 'b'], [2, 2])
model.transition_models['a'] = {
0: {
0: 0.1,
1: 0.9
},
1: {
0: 0.2,
1: 0.8
}
}
model.transition_models['b'] = {
0: {
0: 0.3,
1: 0.7
},
1: {
0: 0.4,
1: 0.6
}
}
sample = model.sample(start_state=[State('a', 0),
State('b', 1)],
size=2)
self.assertEqual(len(sample), 2)
self.assertEqual(list(sample.columns), ['a', 'b'])
self.assertTrue(
list(sample.loc[0]) in [[0, 0], [0, 1], [1, 0], [1, 1]])
self.assertTrue(
list(sample.loc[1]) in [[0, 0], [0, 1], [1, 0], [1, 1]])
def test_random_state(self):
model = MC(['a', 'b'], [2, 3])
state = model.random_state()
vars = [v for v, s in state]
self.assertEqual(vars, ['a', 'b'])
self.assertGreaterEqual(state[0].state, 0)
self.assertGreaterEqual(state[1].state, 0)
self.assertLessEqual(state[0].state, 1)
self.assertLessEqual(state[1].state, 2)
def test_init(self, check_state):
model = MC(self.variables, self.card, self.start_state)
self.assertListEqual(model.variables, self.variables)
self.assertDictEqual(model.cardinalities, self.cardinalities)
self.assertDictEqual(model.transition_models,
{var: {}
for var in self.variables})
check_state.assert_called_once_with(model, self.start_state)
self.assertListEqual(model.state, self.start_state)
def test_transition_model_bad_matrix_dimension(self):
model = MC(['var'], [2])
transition_model = np.array([0.3, 0.7])
# check for square dimension of the matrix
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
transition_model = np.array([[0.3, 0.6, 0.1], [0.3, 0.3, 0.4]])
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
def test_sample_less_arg(self, random_state):
model = MC(['a', 'b'], [2, 2])
random_state.return_value = [State('a', 0), State('b', 1)]
sample = model.sample(size=1)
random_state.assert_called_once_with(model)
self.assertEqual(model.state, random_state.return_value)
self.assertEqual(len(sample), 1)
self.assertEqual(list(sample.columns), ['a', 'b'])
self.assertEqual(list(sample.loc[0]), [0, 1])
def setUp(self):
self.variables = ['intel', 'diff', 'grade']
self.card = [3, 2, 3]
self.cardinalities = {'intel': 3, 'diff': 2, 'grade': 3}
self.intel_tm = {
0: {
0: 0.1,
1: 0.25,
2: 0.65
},
1: {
0: 0.5,
1: 0.3,
2: 0.2
},
2: {
0: 0.3,
1: 0.3,
2: 0.4
}
}
self.intel_tm_matrix = np.array([[0.1, 0.25, 0.65], [0.5, 0.3, 0.2],
[0.3, 0.3, 0.4]])
self.diff_tm = {0: {0: 0.3, 1: 0.7}, 1: {0: 0.75, 1: 0.25}}
self.diff_tm_matrix = np.array([[0.3, 0.7], [0.75, 0.25]])
self.grade_tm = {
0: {
0: 0.4,
1: 0.2,
2: 0.4
},
1: {
0: 0.9,
1: 0.05,
2: 0.05
},
2: {
0: 0.1,
1: 0.4,
2: 0.5
}
}
self.grade_tm_matrix = [[0.4, 0.2, 0.4], [0.9, 0.05, 0.05],
[0.1, 0.4, 0.5]]
self.start_state = [
State('intel', 0),
State('diff', 1),
State('grade', 2)
]
self.model = MC()
self.sample = DataFrame(index=range(200), columns=['a', 'b'])
self.sample.a = [1] * 100 + [0] * 100
self.sample.b = [0] * 100 + [1] * 100
def test_is_stationarity_failure(self):
model = MC(['intel', 'diff'], [2, 3])
model.set_start_state([State('intel', 0), State('diff', 2)])
intel_tm = {0: {0: 0.25, 1: 0.75}, 1: {0: 0.5, 1: 0.5}}
model.add_transition_model('intel', intel_tm)
diff_tm = {
0: {
0: 0.1,
1: 0.5,
2: 0.4
},
1: {
0: 0.2,
1: 0.2,
2: 0.6
},
2: {
0: 0.7,
1: 0.15,
2: 0.15
}
}
model.add_transition_model('diff', diff_tm)
self.assertFalse(model.is_stationarity(0.002, None))
def test_transition_model_dict_to_matrix(self):
model = MC(['var'], [2])
transition_model = {0: {0: 0.3, 1: 0.7}, 1: {0: 0.5, 1: 0.5}}
transition_model_matrix = np.array([[0.3, 0.7], [0.5, 0.5]])
model.add_transition_model('var', transition_model_matrix)
self.assertDictEqual(model.transition_models['var'], transition_model)
def test_add_transition_model_success(self):
model = MC(['var'], [2])
transition_model = {0: {0: 0.3, 1: 0.7}, 1: {0: 0.5, 1: 0.5}}
model.add_transition_model('var', transition_model)
self.assertDictEqual(model.transition_models['var'], transition_model)
def test_add_transition_model_bad_probability_sum(self):
model = MC(['var'], [2])
# transition probabilities from state=0 do not sum to 1.0
transition_model = {0: {0: 0.1, 1: 0.2}, 1: {0: 0.5, 1: 0.5}}
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
def test_add_transition_model_bad_probability(self):
model = MC(['var'], [2])
transition_model = {0: {0: -0.1, 1: 1.1}, 1: {0: 0.5, 1: 0.5}}
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
def test_check_state_bad_var_value(self):
model = MC(['a'], [2])
# value of variable >= cardinaliity
self.assertRaises(ValueError, model._check_state, [State('a', 3)])
def test_check_state_bad_type(self):
model = MC()
# state is non-iterable
self.assertRaises(ValueError, model._check_state, 123)
# state is a string
self.assertRaises(ValueError, model._check_state, 'abc')
def test_add_variables_from(self, add_var):
model = MC()
model.add_variables_from(self.variables, self.card)
calls = [call(model, *p) for p in zip(self.variables, self.card)]
add_var.assert_has_calls(calls)
def test_add_variable_existing(self, warn):
model = MC(['p'], [2])
model.add_variable('p', 3)
self.assertEqual(warn.call_count, 1)
def test_copy(self):
model = MC(['a', 'b'], [2, 2], [State('a', 0), State('b', 1)])
model.add_transition_model('a', {
0: {
0: 0.1,
1: 0.9
},
1: {
0: 0.2,
1: 0.8
}
})
model.add_transition_model('b', {
0: {
0: 0.3,
1: 0.7
},
1: {
0: 0.4,
1: 0.6
}
})
copy = model.copy()
self.assertIsInstance(copy, MC)
self.assertEqual(sorted(model.variables), sorted(copy.variables))
self.assertEqual(model.cardinalities, copy.cardinalities)
self.assertEqual(model.transition_models, copy.transition_models)
self.assertEqual(model.state, copy.state)
model.add_variable('p', 1)
model.set_start_state([State('a', 0), State('b', 1), State('p', 0)])
model.add_transition_model('p', {0: {0: 1}})
self.assertNotEqual(sorted(model.variables), sorted(copy.variables))
self.assertEqual(sorted(['a', 'b']), sorted(copy.variables))
self.assertNotEqual(model.cardinalities, copy.cardinalities)
self.assertEqual({'a': 2, 'b': 2}, copy.cardinalities)
self.assertNotEqual(model.state, copy.state)
self.assertEqual([State('a', 0), State('b', 1)], copy.state)
self.assertNotEqual(model.transition_models, copy.transition_models)
self.assertEqual(len(copy.transition_models), 2)
self.assertEqual(copy.transition_models['a'], {
0: {
0: 0.1,
1: 0.9
},
1: {
0: 0.2,
1: 0.8
}
})
self.assertEqual(copy.transition_models['b'], {
0: {
0: 0.3,
1: 0.7
},
1: {
0: 0.4,
1: 0.6
}
})
def test_add_variable_new(self):
model = MC(['a'], [2])
model.add_variable('p', 3)
self.assertIn('p', model.variables)
self.assertEqual(model.cardinalities['p'], 3)
self.assertDictEqual(model.transition_models['p'], {})
def test_check_state_success(self):
model = MC(['a'], [2])
self.assertTrue(model._check_state([State('a', 1)]))
def test_add_transition_model_bad_transition(self):
model = MC(['var'], [2])
# transition for state=1 is not a dict
transition_model = {0: {0: 0.1, 1: 0.9}, 1: 'abc'}
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
def test_prob_from_sample(self, sample):
model = MC(['a', 'b'], [2, 2])
sample.return_value = self.sample
probabilites = model.prob_from_sample([State('a', 1), State('b', 0)])
self.assertEqual(list(probabilites), [1] * 50 + [0] * 50)
def test_check_state_bad_vars(self):
model = MC()
# state_vars and model_vars differ
self.assertRaises(ValueError, model._check_state, [State(1, 2)])
def test_init_less_args(self):
model = MC()
self.assertListEqual(model.variables, [])
self.assertDictEqual(model.cardinalities, {})
self.assertDictEqual(model.transition_models, {})
self.assertIsNone(model.state)
def test_set_start_state_none(self):
model = MC()
model.state = 'state'
model.set_start_state(None)
self.assertIsNone(model.state)
def test_add_transition_model_bad_states(self):
model = MC(['var'], [2])
# transition for state=1 not defined
transition_model = {0: {0: 0.1, 1: 0.9}}
self.assertRaises(ValueError, model.add_transition_model, 'var',
transition_model)
def test_add_transition_model_bad_type(self):
model = MC()
# if transition_model is not a dict
self.assertRaises(ValueError, model.add_transition_model, 'var', 123)
