def test_experiment_generator(self):
sampler = LHSSampler()
shared_abc_1 = parameters.RealParameter("shared ab 1", 0, 1)
shared_abc_2 = parameters.RealParameter("shared ab 2", 0, 1)
unique_a = parameters.RealParameter("unique a ", 0, 1)
unique_b = parameters.RealParameter("unique b ", 0, 1)
uncertainties = [shared_abc_1, shared_abc_2, unique_a, unique_b]
designs = sampler.generate_designs(uncertainties, 10)
designs.kind = parameters.Scenario
# everything shared
model_a = Model("A", mock.Mock())
model_b = Model("B", mock.Mock())
model_a.uncertainties = [shared_abc_1, shared_abc_2, unique_a]
model_b.uncertainties = [shared_abc_1, shared_abc_2, unique_b]
model_structures = [model_a, model_b]
policies = [parameters.Policy('policy 1'),
parameters.Policy('policy 2'),
parameters.Policy('policy 3')]
gen = parameters.experiment_generator(designs, model_structures,
policies)
experiments = []
for entry in gen:
experiments.append(entry)
self.assertEqual(len(experiments), 2*3*10)
def test_model_structures(self):
function = mock.Mock()
model_a = Model("A", function)
ensemble = ModelEnsemble()
ensemble.model_structures = model_a
self.assertEqual(ensemble.model_structures[0], model_a)
model_a = Model("A", function)
model_b = Model("B", function)
ensemble = ModelEnsemble()
ensemble.model_structures = [model_a, model_b]
self.assertEqual(list(ensemble.model_structures), [model_a, model_b])
def test_to_robust_problem(self, mocked_platypus):
mocked_model = Model('test', function=mock.Mock())
mocked_model.levers = [
RealParameter('a', 0, 1),
RealParameter('b', 0, 1)
]
mocked_model.uncertainties = [
RealParameter('c', 0, 1),
RealParameter('d', 0, 1)
]
mocked_model.outcomes = [ScalarOutcome('x'), ScalarOutcome('y')]
scenarios = 5
robustness_functions = [
ScalarOutcome('mean x', variable_name='x', function=mock.Mock()),
ScalarOutcome('mean y', variable_name='y', function=mock.Mock())
]
problem = to_robust_problem(mocked_model, scenarios,
robustness_functions)
self.assertEqual('robust', problem.searchover)
for entry in problem.parameters:
self.assertIn(entry.name, mocked_model.levers.keys())
self.assertEqual(['a', 'b'], problem.parameter_names)
self.assertEqual(['mean x', 'mean y'], problem.outcome_names)
def test_to_problem(self, mocked_platypus):
mocked_model = Model('test', function=mock.Mock())
mocked_model.levers = [
RealParameter('a', 0, 1),
RealParameter('b', 0, 1)
]
mocked_model.uncertainties = [
RealParameter('c', 0, 1),
RealParameter('d', 0, 1)
]
mocked_model.outcomes = [ScalarOutcome('x'), ScalarOutcome('y')]
mocked_model.constraints = []
searchover = 'levers'
problem = to_problem(mocked_model, searchover)
self.assertEqual(searchover, problem.searchover)
for entry in problem.parameters:
self.assertIn(entry.name, mocked_model.levers.keys())
self.assertIn(entry, list(mocked_model.levers))
for entry in problem.outcome_names:
self.assertIn(entry.name, mocked_model.outcomes.keys())
searchover = 'uncertainties'
problem = to_problem(mocked_model, searchover)
self.assertEqual(searchover, problem.searchover)
for entry in problem.parameters:
self.assertIn(entry.name, mocked_model.uncertainties.keys())
self.assertIn(entry, list(mocked_model.uncertainties))
for entry in problem.outcome_names:
self.assertIn(entry.name, mocked_model.outcomes.keys())
def test_init(self):
model_name = 'modelname'
model = Model(model_name, lambda x:x)
self.assertEqual(model.name, model_name)
self.assertRaises(EMAError, Model, '', 'model name')
def test_run_model(self):
model_name = 'modelname'
function = mock.Mock()
model = Model(model_name, function)
model.uncertainties = [RealParameter('a', 0, 1)]
model.run_model(Scenario(**{'a': 0.1, 'b': 1}), Policy('test'))
function.assert_called_once_with(a=0.1)
# test complete translation of scenario
model = Model(model_name, function)
model.uncertainties = [
RealParameter('a', 0, 1, variable_name=['a', 'b'])
]
scenario = Scenario(**{'a': 0.1})
model.run_model(scenario, Policy('test'))
self.assertIn('a', scenario.keys())
self.assertIn('b', scenario.keys())
model = Model(model_name, function)
cats = [
Category('some name', [1, 2], multivalue=True),
Category('some other name', [3, 4], multivalue=True)
]
model.uncertainties = [
CategoricalParameter('a', cats, variable_name=['a', 'b'])
]
scenario = Scenario(**{'a': 'some name'})
model.run_model(scenario, Policy('test'))
self.assertIn('a', scenario.keys())
self.assertIn('b', scenario.keys())
self.assertEqual(scenario['a'], 1)
self.assertEqual(scenario['b'], 2)
scenario = Scenario(**{'a': 'some other name'})
model.run_model(scenario, Policy('test'))
self.assertIn('a', scenario.keys())
self.assertIn('b', scenario.keys())
self.assertEqual(scenario['a'], 3)
self.assertEqual(scenario['b'], 4)
def test_model_uncertainties(self):
model_name = 'modelname'
model = Model(model_name, lambda x:x)
self.assertTrue(len(model.uncertainties.keys())==0)
unc_a = RealParameter('a', 0, 1)
model.uncertainties = unc_a
self.assertTrue(len(model.uncertainties.keys())==1)
self.assertTrue(unc_a.name in model.uncertainties)
def test_model_init(self):
model_name = 'modelname'
def initial_func(a=1):
return a
model = Model(model_name,initial_func)
def policy_func(a=1):
return a
policy = Policy('test', function=policy_func, unknown='a')
model.model_init(policy)
self.assertEqual(policy, model.policy)
self.assertEqual(model.function, policy_func)
with self.assertRaises(AttributeError):
model.unknown
def test_perform_experiments(self):
# everything shared
model_a = Model("A", mock.Mock())
model_b = Model("B", mock.Mock())
model_c = Model("C", mock.Mock())
models = [model_a, model_b, model_c]
# let's add some uncertainties to this
shared_abc_1 = RealParameter("shared abc 1", 0, 1)
shared_abc_2 = RealParameter("shared abc 2", 0, 1)
shared_ab_1 = RealParameter("shared ab 1", 0, 1)
shared_bc_1 = RealParameter("shared bc 1", 0, 1)
a_1 = RealParameter("a 1", 0, 1)
b_1 = RealParameter("b 1", 0, 1)
model_a.uncertainties = [shared_abc_1, shared_abc_2, shared_ab_1, a_1]
model_b.uncertainties = [
shared_abc_1, shared_abc_2, shared_ab_1, shared_bc_1, b_1
]
model_c.uncertainties = [shared_abc_1, shared_abc_2, shared_bc_1]
#let's add an outcome to this
outcome_shared = TimeSeriesOutcome("test")
model_a.outcomes = [outcome_shared]
model_b.outcomes = [outcome_shared]
model_c.outcomes = [outcome_shared]
for model in models:
model.function.return_value = {
a: [0.1] * 10
for a in outcome_shared.variable_name
}
ensemble = ModelEnsemble()
ensemble.model_structures = [model_a, model_b, model_c]
ensemble.policies = [Policy('None')]
ensemble.perform_experiments(10,
uncertainty_union=True,
outcome_union=True,
reporting_interval=1)
# for model in models:
# model.function.assert_has_calls() TODO::
ensemble.perform_experiments(10,
uncertainty_union=True,
outcome_union=False,
reporting_interval=1)
ensemble.perform_experiments(10,
uncertainty_union=False,
outcome_union=True,
reporting_interval=1)
ensemble.perform_experiments(10,
uncertainty_union=False,
outcome_union=False,
reporting_interval=1)
#
# self.assertRaises(ValueError, ensemble.perform_experiments,
# 10, uncertainty_union=False,
# union_outcomes='Label')
with mock.patch(
'ema_workbench.em_framework.ensemble.MultiprocessingPool'
) as MockPool:
ensemble.parallel = True
mockedCallback = mock.Mock(DefaultCallback)
mockedCallback.configure_mock(**{'i': 30})
mockedCallback.return_value = mockedCallback
ensemble.perform_experiments(10,
uncertainty_union=True,
outcome_union=True,
reporting_interval=1,
callback=mockedCallback)
self.assertEqual(2, len(MockPool.mock_calls))
MockPool.reset_mock()
mockedCallback = mock.Mock(DefaultCallback)
mockedCallback.configure_mock(**{'i': 10})
mockedCallback.return_value = mockedCallback
self.assertRaises(EMAError,
ensemble.perform_experiments,
10,
uncertainty_union=True,
outcome_union=True,
reporting_interval=1,
callback=mockedCallback)
def test_cleanup(self):
model_name = 'modelname'
model = Model(model_name, lambda x:x)
model.cleanup()
def test(self):
model = Model('test', mock.Mock())
client = mock.Mock(spec=ipyparallel.Client)
