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', kind=1), ScalarOutcome('y', kind=1) ] 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, 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, mocked_model.outcomes.keys())
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', kind=1), ScalarOutcome('y', kind=1)] 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, 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, mocked_model.outcomes.keys())
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_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_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_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_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_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(['mean x', 'mean y'], problem.outcome_names)
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_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_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':0}) 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':1}) 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(self): model = Model('test', mock.Mock()) client = mock.Mock(spec=ipyparallel.Client)
def test_cleanup(self): model_name = 'modelname' model = Model(model_name, lambda x:x) model.cleanup()
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_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]), Category('some other name', [3,4])] model.uncertainties = [CategoricalParameter('a', cats, variable_name=['a', 'b'], multivalue=True)] scenario = Scenario(**{'a':cats[0].value}) 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':cats[1].value}) 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)