def test_auto_scale(self):
temp_kpis = [KPISpecification(), KPISpecification(auto_scale=False)]
self.mocked_optimizer.kpis = temp_kpis
scaling_factors = self.mocked_optimizer.get_scaling_factors()
self.assertAlmostEqual(self.mocked_optimizer.scaling_values[0],
scaling_factors[0])
self.assertEqual(1.0, scaling_factors[1])
def test_update_kpis(self):
new_kpis = [
KPISpecification(name="new"),
KPISpecification(name="another_new"),
]
self.mco_model.kpis = new_kpis
self.assertEqual(self.mco_model.kpis, new_kpis)
self.assertEqual(self.mco_model.optimizer.kpis, new_kpis)
def test__minimization_score(self):
temp_kpis = [
KPISpecification(),
KPISpecification(objective="MAXIMISE"),
]
self.optimizer_engine.kpis = temp_kpis
score = [10.0, 20.0]
inv_values = self.optimizer_engine._minimization_score(score)
self.assertListEqual(list(inv_values), [10.0, -20.0])
def test_auto_scale(self):
temp_kpis = [KPISpecification(), KPISpecification(auto_scale=False)]
self.mco_model.kpis = temp_kpis
mock_optimizer = MockOptimizer(None, None)
self.optimizer._weighted_optimize = mock_optimizer.optimize
scaling_factors = self.optimizer.get_scaling_factors()
self.assertEqual([0.1, 1.0], scaling_factors)
def test__swap_minmax_kpivalues(self):
temp_kpis = [
KPISpecification(),
KPISpecification(objective="MAXIMISE"),
]
self.mco_model.kpis = temp_kpis
values = [10.0, 20.0]
inv_values = self.mco_model.optimizer._swap_minmax_kpivalues(values)
self.assertListEqual(list(inv_values), [10.0, -20.0])
def get_kpis(self):
return [
KPISpecification(name="gauss1",
objective="MAXIMISE",
auto_scale=False,
scale_factor=1.0),
KPISpecification(name="gauss2",
objective="MINIMISE",
auto_scale=False,
scale_factor=1.0)
]
def setUp(self):
self.plugin = {"id": "pid", "name": "Plugin"}
self.factory = MCOFactory(self.plugin)
self.mco_model = self.factory.create_model()
self.kpis = [KPISpecification(), KPISpecification()]
self.parameters = [1, 1, 1, 1]
self.mco_model.kpis = self.kpis
self.mco_model.parameters = [
self.factory.parameter_factories[0].create_model()
for _ in self.parameters
]
self.optimizer = self.mco_model.optimizer
def setUp(self):
self.plugin = {"id": "pid", "name": "Plugin"}
self.factory = MCOFactory(self.plugin)
self.mco = self.factory.create_optimizer()
self.mco_model = self.factory.create_model()
self.kpis = [KPISpecification(), KPISpecification()]
self.parameters = [1, 1, 1, 1]
self.mco_model.kpis = self.kpis
self.mco_model.parameters = [
self.factory.parameter_factories[0].create_model()
for _ in self.parameters
]
self.evaluator = WorkflowEvaluator(workflow=Workflow())
self.evaluator.workflow.mco = self.mco_model
def test_simple_run(self):
mco = self.factory.create_optimizer()
model = self.factory.create_model()
model.budget = 61
model.parameters = self.parameters
model.kpis = [KPISpecification(), KPISpecification()]
evaluator = Workflow()
evaluator.mco_model = model
kpis = [DataValue(value=1), DataValue(value=2)]
with self.assertTraitChanges(model, "event", count=61):
with mock.patch("force_bdss.api.Workflow.execute",
return_value=kpis) as mock_exec:
mco.run(evaluator)
self.assertEqual(76, mock_exec.call_count)
def get_kpis(self):
return [
KPISpecification(name="slope1",
objective="MINIMISE",
auto_scale=False,
scale_factor=1.0,
lower_bound=0.5,
upper_bound=2.5),
KPISpecification(name="slope2",
objective="MINIMISE",
auto_scale=False,
scale_factor=1.0,
lower_bound=0.5,
upper_bound=2.5)
]
def test_init_model(self):
model = self.factory.create_model()
self.assertEqual([], model.parameters)
self.assertEqual([], model.kpis)
self.assertEqual("Weighted", model.optimizer_mode)
self.assertIsInstance(model.optimizer, WeightedOptimizer)
self.assertListEqual(model.parameters, model.optimizer.parameters)
self.assertListEqual(model.kpis, model.optimizer.kpis)
self.assertEqual("SLSQP", model.optimizer.algorithms)
kpis = [KPISpecification(), KPISpecification()]
parameters = [
self.factory.parameter_factories[0].create_model()
for _ in [1, 1, 1, 1]
]
optimizer_data = {"algorithms": "TNC", "num_points": 10}
model = self.factory.create_model({
"kpis": kpis,
"parameters": parameters,
"optimizer_data": optimizer_data,
})
self.assertListEqual(parameters, model.parameters)
self.assertListEqual(kpis, model.kpis)
self.assertEqual("Weighted", model.optimizer_mode)
self.assertIsInstance(model.optimizer, WeightedOptimizer)
self.assertListEqual(model.parameters, model.optimizer.parameters)
self.assertListEqual(model.kpis, model.optimizer.kpis)
self.assertEqual("TNC", model.optimizer.algorithms)
self.assertEqual(10, model.optimizer.num_points)
optimizer_mode = "NeverGrad"
optimizer_data = {"algorithms": "RandomSearch", "budget": 1000}
model = self.factory.create_model({
"kpis": kpis,
"parameters": parameters,
"optimizer_mode": optimizer_mode,
"optimizer_data": optimizer_data,
})
self.assertListEqual(parameters, model.parameters)
self.assertListEqual(kpis, model.kpis)
self.assertEqual("NeverGrad", model.optimizer_mode)
self.assertIsInstance(model.optimizer, NevergradOptimizer)
self.assertListEqual(model.parameters, model.optimizer.parameters)
self.assertListEqual(model.kpis, model.optimizer.kpis)
self.assertEqual("RandomSearch", model.optimizer.algorithms)
self.assertEqual(1000, model.optimizer.budget)
def test_kpi_bounds(self):
self.optimizer_engine.kpis = [
KPISpecification(lower_bound=0.0, upper_bound=1.0)
]
self.assertListEqual(
[(0.0, 1.0)],
self.optimizer_engine.kpi_bounds,
)
def setUp(self):
self.plugin = ITWMExamplePlugin()
self.factory = self.plugin.mco_factories[0]
self.mco = self.factory.create_optimizer()
self.model = self.factory.create_model()
self.kpis = [KPISpecification(), KPISpecification()]
self.parameters = [1, 1, 1, 1]
self.itwm_parameters_factory = ITWMRangedMCOParameterFactory(
self.factory)
self.parameters = [
self.itwm_parameters_factory.create_model({
"lower_bound": 0.0,
"upper_bound": 1.0
}) for _ in self.parameters
]
self.model.parameters = self.parameters
def test_add_kpi(self):
kpi_spec = KPISpecification(name='outputB')
self.kpi_view.add_kpi(kpi_spec)
self.assertEqual(2, len(self.kpi_view.model_views))
self.assertEqual(3, len(self.kpi_view.kpi_name_options))
self.assertEqual(2, len(self.kpi_view.kpi_names))
self.assertEqual(self.kpi_view.model_views[1].model, kpi_spec)
self.assertEqual('outputB', self.kpi_view.model_views[1].model.name)
self.assertEqual('KPI: outputB (MINIMISE)',
self.kpi_view.model_views[1].label)
self.assertEqual('outputB', self.kpi_view.kpi_names[1])
def setUp(self):
super(TestWorkflowView, self).setUp()
self.workflow.execution_layers[0].data_sources[0].output_slot_info \
= [OutputSlotInfo(name='outputA'), OutputSlotInfo(name='outputX')]
self.workflow.execution_layers[0].data_sources[1].output_slot_info \
= [OutputSlotInfo(name='outputB')]
self.mco_model.kpis.append(KPISpecification(name='outputA'))
self.workflow_view = WorkflowView(
model=self.workflow,
variable_names_registry=self.variable_names_registry
)
def setUp(self):
self.plugin = {"id": "pid", "name": "Plugin"}
self.factory = DummyMCOFactory(self.plugin)
self.kpis = [KPISpecification(), KPISpecification()]
self.parameters = [1, 1, 1, 1]
self.parameters = [
RangedMCOParameterFactory(self.factory).create_model({
"lower_bound":
0.0,
"upper_bound":
1.0
}) for _ in self.parameters
]
self.optimizer = WeightedScipyEngine(parameters=self.parameters,
kpis=self.kpis)
self.mocked_optimizer = DummyOptimizerEngine(
parameters=self.parameters,
kpis=self.kpis,
single_point_evaluator=GaussProbeEvaluator())
def setUp(self):
self.registry = get_basic_variable_names_registry()
self.workflow = self.registry.workflow
self.param1 = self.workflow.mco_model.parameters[0]
self.param2 = self.workflow.mco_model.parameters[1]
self.param3 = self.workflow.mco_model.parameters[2]
self.data_source1 = self.workflow.execution_layers[0].data_sources[0]
self.data_source2 = self.workflow.execution_layers[0].data_sources[1]
self.workflow.mco_model.kpis.append(KPISpecification())
self.kpi_view = KPISpecificationView(
model=self.workflow.mco_model,
variable_names_registry=self.registry
)
def test_internal_run(self):
opt = self.factory.create_optimizer()
model = self.factory.create_model()
model.num_trials = 7
model.evaluation_mode = 'Internal'
parameter_factory = self.factory.parameter_factories[0]
model.parameters = [DummyMCOParameter(parameter_factory)]
model.kpis = [KPISpecification()]
self.evaluator.mco_model = model
kpis = [DataValue(value=1), DataValue(value=2)]
with mock.patch('force_bdss.api.Workflow.execute',
return_value=kpis) as mock_exec:
opt.run(self.evaluator)
self.assertEqual(mock_exec.call_count, 7)
def setUp(self):
super(TestWorkflowTree, self).setUp()
data_sources = [
self.factory_registry.data_source_factories[2].create_model(),
self.factory_registry.data_source_factories[3].create_model(),
]
execution_layer = ExecutionLayer(data_sources=data_sources)
self.workflow.execution_layers.append(execution_layer)
self.workflow.mco_model.kpis.append(KPISpecification())
self.system_state = SystemState()
self.workflow_tree = WorkflowTree(
model=self.workflow,
_factory_registry=self.factory_registry,
system_state=self.system_state,
)
def setUp(self):
self.plugin = {"id": "pid", "name": "Plugin"}
self.factory = DummyMCOFactory(self.plugin)
self.parameters = [
RangedMCOParameterFactory(self.factory).create_model({
"lower_bound":
0.0,
"upper_bound":
1.0
}) for _ in range(4)
]
self.kpis = [KPISpecification()] * 2
self.optimizer = DummyOptimizerEngine(
kpis=self.kpis,
parameters=self.parameters,
single_point_evaluator=GaussProbeEvaluator())
self.scaling_values = self.optimizer.scaling_values.tolist()
def test_subprocess_run(self):
opt = self.factory.create_optimizer()
model = self.factory.create_model()
model.num_trials = 7
model.evaluation_mode = 'Subprocess'
parameter_factory = self.factory.parameter_factories[0]
model.parameters = [DummyMCOParameter(parameter_factory)]
model.kpis = [KPISpecification()]
self.evaluator.mco_model = model
mock_process = mock.Mock()
mock_process.communicate = mock.Mock(return_value=(b"2", b"1 0"))
with mock.patch("subprocess.Popen") as mock_popen:
mock_popen.return_value = mock_process
opt.run(self.evaluator)
self.assertEqual(mock_popen.call_count, 7)
def test__check_model_name(self):
self.mco_options_model_view.available_variables = ([('T1', 'PRESSURE'),
('T2', 'PRESSURE')
])
self.assertEqual(['T1', 'T2'],
self.mco_options_model_view._combobox_values)
self.mco_options_model_view.model = KPISpecification(name='T1')
self.mco_options_model_view.available_variables.remove(
self.mco_options_model_view.available_variables[-1])
self.assertTrue(self.mco_options_model_view.valid)
self.mco_options_model_view.available_variables.remove(
self.mco_options_model_view.available_variables[0])
self.assertEqual('', self.mco_options_model_view.model.name)
error_message = self.mco_options_model_view.model.verify()
self.assertIn('KPI is not named', error_message[0].local_error)
def setUp(self):
super(TestWorkflowInfo, self).setUp()
self.workflow.execution_layers[0].data_sources[0].output_slot_info \
= [OutputSlotInfo(name='outputA'), OutputSlotInfo(name='outputX')]
self.workflow.execution_layers[0].data_sources[1].output_slot_info \
= [OutputSlotInfo(name='outputB')]
self.mco_model.kpis.append(KPISpecification(name='outputA'))
self.workflow_view = WorkflowView(model=self.workflow)
# WorkflowInfo for testing
self.other_plugin = ProbeExtensionPlugin()
self.other_plugin.name = 'A different Probe extension'
plugin_list = [self.plugin, self.other_plugin]
self.workflow_info = WorkflowInfo(
plugins=plugin_list,
workflow_filename='workflow.json',
selected_factory_name='Workflow',
error_message=self.workflow_view.error_message)
def test_run(self):
opt = self.factory.create_optimizer()
model = self.factory.create_model()
parameter_factory = self.factory.parameter_factories[0]
model.parameters = [
parameter_factory.create_model(
data_values={
'lower_bound': 1,
'upper_bound': 3,
'initial_value': 2
}
)
]
model.kpis = [KPISpecification()]
self.evaluator.mco_model = model
mock_process = mock.Mock()
mock_process.communicate = mock.Mock(return_value=(b"1 2 3", b""))
with mock.patch("subprocess.Popen") as mock_popen:
mock_popen.return_value = mock_process
opt.run(self.evaluator)
self.assertEqual(mock_popen.call_count, 2)
def setUp(self):
self.kpi_model_view = KPISpecificationModelView(
model=KPISpecification(name='T1'),
available_variables=[('T1', 'PRESSURE'), ('T2', 'PRESSURE')])
