pymodaq 5.0.4__py3-none-any.whl → 5.1.0a0__py3-none-any.whl

pymodaq/extensions/{bayesian/bayesian_optimisation.py → optimizers_base/optimizer.py}

@@ -1,94 +1,75 @@
-from typing import List, Union, Optional
+import abc
+from typing import List,  Optional
 import tempfile
 from pathlib import Path
 
+
 from qtpy import QtWidgets, QtCore
 import time
 import numpy as np
 
-from pymodaq.utils.data import DataToExport, DataToActuators, DataCalculated, DataActuator
+from collections import OrderedDict
+
+
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq_utils import utils
 from pymodaq_utils import config as config_mod
-from pymodaq_utils.enums import BaseEnum
-
-from pymodaq_gui.config import ConfigSaverLoader
+from pymodaq_utils.enums import BaseEnum, StrEnum
 from pymodaq_utils.logger import set_logger, get_module_name
 
+from pymodaq_data.h5modules.data_saving import DataEnlargeableSaver
+
 from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
-from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
 from pymodaq_gui.utils import QLED
-from pymodaq_gui.utils.utils import mkQApp
 from pymodaq_gui import utils as gutils
 from pymodaq_gui.parameter import utils as putils
 from pymodaq_gui.h5modules.saving import H5Saver
+from pymodaq_gui.config import ConfigSaverLoader
 
-from pymodaq_data.h5modules.data_saving import DataEnlargeableSaver
-
-
-from pymodaq.extensions.bayesian.utils import (get_bayesian_models, BayesianModelGeneric,
-                                               BayesianAlgorithm, UtilityKind,
-                                               UtilityParameters, StopType, StoppingParameters)
+from pymodaq.utils.data import DataToExport, DataToActuators, DataCalculated, DataActuator
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
-from pymodaq.extensions.bayesian.utils import BayesianConfig
 from pymodaq.extensions.utils import CustomExt
 
-EXTENSION_NAME = 'BayesianOptimisation'
-CLASS_NAME = 'BayesianOptimisation'
+from pymodaq.utils.h5modules import module_saving
+
+from pymodaq.extensions.optimizers_base.utils import (
+    get_optimizer_models, OptimizerModelGeneric,
+    GenericAlgorithm, StopType, StoppingParameters,
+    OptimizerConfig)
+from pymodaq.extensions.optimizers_base.thread_commands import OptimizerToRunner, OptimizerThreadStatus
+
 
 logger = set_logger(get_module_name(__file__))
 config = config_mod.Config()
 
+PREDICTION_PARAMS = []  # to be subclassed in ral optimizer implementations
+MODELS = get_optimizer_models()
 
-class DataNames(BaseEnum):
-    Fitness = 0
-    Individual = 1
-    ProbedData = 2
-    Actuators = 3
-    Kappa = 4
 
+class DataNames(StrEnum):
+    Fitness = 'fitness'
+    Individual = 'individual'
+    ProbedData = 'probed_data'
+    Actuators = 'actuators'
+    Tradeoff = 'tradeoff'
 
-class BayesianOptimisation(CustomExt):
-    """ PyMoDAQ extension of the DashBoard to perform the optimization of a target signal
-    taken form the detectors as a function of one or more parameters controlled by the actuators.
-    """
 
-    command_runner = QtCore.Signal(utils.ThreadCommand)
-    models = get_bayesian_models()
-    explored_viewer_name = 'algo/ProbedData'
-    optimisation_done_signal = QtCore.Signal(DataToExport)
-
-    params = [
+def optimizer_params(prediction_params: list[dict]):
+    return [
         {'title': 'Main Settings:', 'name': 'main_settings', 'expanded': True, 'type': 'group',
          'children': [
-             {'title': 'Utility Function:', 'name': 'utility', 'expanded': False, 'type': 'group',
-              'children': [
-                  {'title': 'Kind', 'name': 'kind', 'type': 'list',
-                   'limits': UtilityKind.to_dict_value()},
-                  {'title': 'Kappa:', 'name': 'kappa', 'type': 'slide', 'value': 2.576,
-                   'min': 0.001, 'max': 100, 'subtype': 'log',
-                   'tip': 'Parameter to indicate how closed are the next parameters sampled.'
-                          'Higher value = favors spaces that are least explored.'
-                          'Lower value = favors spaces where the regression function is the '
-                          'highest.'},
-                  {'title': 'Kappa actual:', 'name': 'kappa_actual', 'type': 'float', 'value': 2.576,
-                   'tip': 'Current value of the kappa parameter', 'readonly': True},
-                  {'title': 'xi:', 'name': 'xi', 'type': 'slide', 'value': 0,
-                   'tip': 'Governs the exploration/exploitation tradeoff.'
-                          'Lower prefers exploitation, higher prefers exploration.'},
-                  {'title': 'Kappa decay:', 'name': 'kappa_decay', 'type': 'float', 'value': 0.9,
-                   'tip': 'kappa is multiplied by this factor every iteration.'},
-                  {'title': 'Kappa decay delay:', 'name': 'kappa_decay_delay', 'type': 'int',
-                   'value': 20, 'tip': 'Number of iterations that must have passed before applying '
-                                      'the decay to kappa.'},
-              ]},
+             {'title': 'Prediction Function:', 'name': 'prediction', 'expanded': False, 'type': 'group',
+              'children': prediction_params
+
+              },
              {'title': 'Stopping Criteria:', 'name': 'stopping', 'expanded': False, 'type': 'group',
               'children': [
                   {'title': 'Niteration', 'name': 'niter', 'type': 'int', 'value': 100, 'min': -1},
                   {'title': 'Type:', 'name': 'stop_type', 'type': 'list',
                    'limits': StopType.names()},
                   {'title': 'Tolerance', 'name': 'tolerance', 'type': 'slide', 'value': 1e-2,
-                   'min': 1e-8, 'max': 1, 'subtype': 'log',},
+                   'min': 1e-8, 'max': 1, 'subtype': 'log', },
                   {'title': 'Npoints', 'name': 'npoints', 'type': 'int', 'value': 5, 'min': 1},
               ]},
              {'title': 'Ini. State', 'name': 'ini_random', 'type': 'int', 'value': 5},
@@ -97,43 +78,219 @@ class BayesianOptimisation(CustomExt):
 
         {'title': 'Models', 'name': 'models', 'type': 'group', 'expanded': True, 'visible': True,
          'children': [
-            {'title': 'Models class:', 'name': 'model_class', 'type': 'list',
-             'limits': [d['name'] for d in models]},
-            {'title': 'Ini Model', 'name': 'ini_model', 'type': 'action', },
-            {'title': 'Ini Algo', 'name': 'ini_runner', 'type': 'action', 'enabled': False},
-            {'title': 'Model params:', 'name': 'model_params', 'type': 'group', 'children': []},
-        ]},
+             {'title': 'Models class:', 'name': 'model_class', 'type': 'list',
+              'limits': [d['name'] for d in MODELS]},
+             {'title': 'Ini Model', 'name': 'ini_model', 'type': 'action', },
+             {'title': 'Ini Algo', 'name': 'ini_runner', 'type': 'action', 'enabled': False},
+             {'title': 'Model params:', 'name': 'model_params', 'type': 'group', 'children': []},
+         ]},
         {'title': 'Move settings:', 'name': 'move_settings', 'expanded': True, 'type': 'group',
          'visible': False, 'children': [
-             {'title': 'Units:', 'name': 'units', 'type': 'str', 'value': ''}]},
+            {'title': 'Units:', 'name': 'units', 'type': 'str', 'value': ''}]},
 
     ]
 
+
+class DataToActuatorsOpti(DataToActuators):
+    """ Specific class including the step in the optimization loop for further use"""
+    ind_iter: int
+    def __init__(self, *args, ind_iter=0, **kwargs):
+        super().__init__(*args, ind_iter=ind_iter, **kwargs)
+
+    def __repr__(self):
+        return f'{super().__repr__()} iter:{self.ind_iter}'
+
+
+class OptimizationRunner(QtCore.QObject):
+    algo_output_signal = QtCore.Signal(DataToExport)
+    algo_finished = QtCore.Signal(DataToExport)
+    saver_signal = QtCore.Signal(DataToActuatorsOpti)
+
+    runner_command = QtCore.Signal(utils.ThreadCommand)
+
+    def __init__(self, model_class: OptimizerModelGeneric, modules_manager: ModulesManager,
+                 algorithm: GenericAlgorithm, stopping_params: StoppingParameters):
+        super().__init__()
+
+        self.det_done_datas: DataToExport = None
+        self.input_from_dets: float = None
+        self.outputs: List[np.ndarray] = []
+        self.output_to_actuators: DataToActuators = None
+        self.dte_actuators: DataToExport = None
+        self.stopping_params: StoppingParameters = stopping_params
+
+        self.model_class: OptimizerModelGeneric = model_class
+        self.modules_manager: ModulesManager = modules_manager
+
+        self.running = True
+        self._ind_iter = -1
+
+        self.optimization_algorithm: GenericAlgorithm = algorithm
+
+
+    def queue_command(self, command: utils.ThreadCommand):
+        """
+        """
+        if command.command == OptimizerToRunner.RUN:
+            if command.attribute is None:
+                command.attribute = {}
+            self.run_opti(**command.attribute)
+
+        elif command.command == OptimizerToRunner.STOP:
+            self.running = False
+
+        elif command.command == OptimizerToRunner.STOPPING:
+            self.stopping_params: StoppingParameters = command.attribute
+
+        elif command.command == OptimizerToRunner.BOUNDS:
+            self.optimization_algorithm.bounds = command.attribute
+
+    def run_opti(self, sync_detectors=True, sync_acts=True):
+        """Start the optimization loop
+
+        Parameters
+        ----------
+        sync_detectors: (bool) if True will make sure all selected detectors (if any) all got their data before calling
+            the model
+        sync_acts: (bool) if True will make sure all selected actuators (if any) all reached their target position
+         before calling the model
+        """
+        self.running = True
+        converged = False
+        try:
+            if sync_detectors:
+                self.modules_manager.connect_detectors()
+            if sync_acts:
+                self.modules_manager.connect_actuators()
+
+            self.current_time = time.perf_counter()
+            logger.info('Optimisation loop starting')
+            while self.running:
+                self._ind_iter += 1
+
+                next_target = self.optimization_algorithm.ask()
+
+                self.outputs = next_target
+                self.output_to_actuators: DataToActuators = \
+                    self.model_class.convert_output(
+                        self.outputs,
+                        best_individual=self.optimization_algorithm.best_individual
+                    )
+
+                self.modules_manager.move_actuators(self.output_to_actuators,
+                                                    self.output_to_actuators.mode,
+                                                    polling=sync_acts)
+
+                # Do the evaluation (measurements)
+                self.det_done_datas = self.modules_manager.grab_data()
+                self.input_from_dets = self.model_class.convert_input(self.det_done_datas)
+
+                #log data
+                self.runner_command.emit(
+                    utils.ThreadCommand(OptimizerThreadStatus.ADD_DATA,))
+
+                # Run the algo internal mechanic
+                self.optimization_algorithm.tell(float(self.input_from_dets))
+
+                dte = DataToExport('algo', data=[
+                    self.individual_as_data(
+                        np.array([self.optimization_algorithm.best_fitness]),
+                        DataNames.Fitness),
+                    self.individual_as_data(
+                        self.optimization_algorithm.best_individual,
+                        DataNames.Individual),
+                    DataCalculated(DataNames.ProbedData,
+                                   data=[np.array([self.input_from_dets])],),
+                    self.output_to_actuators.merge_as_dwa(
+                        'Data0D', DataNames.Actuators),
+                    DataCalculated(DataNames.Tradeoff,
+                                   data=[np.array([self.optimization_algorithm.tradeoff])])
+                    ])
+                self.algo_output_signal.emit(dte)
+                self.saver_signal.emit(DataToActuatorsOpti(DataNames.Actuators,
+                                                           data = self.output_to_actuators.deepcopy().data,
+                                                           mode=self.output_to_actuators.mode,
+                                                           ind_iter=self._ind_iter))
+
+                self.optimization_algorithm.update_prediction_function()
+
+                if self.optimization_algorithm.stopping(self._ind_iter, self.stopping_params):
+                    converged = True
+                    break
+
+                self.current_time = time.perf_counter()
+                QtWidgets.QApplication.processEvents()
+                QtWidgets.QApplication.processEvents()
+            logger.info('Optimisation loop exiting')
+            self.modules_manager.connect_actuators(False)
+            self.modules_manager.connect_detectors(False)
+
+            if converged:
+                self.algo_finished.emit(dte)
+
+        except Exception as e:
+            logger.exception(str(e))
+
+    @staticmethod
+    def individual_as_data(individual: np.ndarray, name: str = 'Individual') -> DataCalculated:
+        return DataCalculated(name, data=[np.atleast_1d(np.squeeze(coordinate)) for coordinate in
+                                          np.atleast_1d(np.squeeze(individual))])
+
+
+class GenericOptimization(CustomExt):
+    """ PyMoDAQ extension of the DashBoard to perform the optimization of a target signal
+    taken form the detectors as a function of one or more parameters controlled by the actuators.
+    """
+
+    command_runner = QtCore.Signal(utils.ThreadCommand)
+    explored_viewer_name = f'algo/{DataNames.ProbedData}'
+    optimization_done_signal = QtCore.Signal(DataToExport)
+
+    runner = OptimizationRunner  # replace in real implementation if customization is needed
+    DISPLAY_BEST = True
+
+    params = optimizer_params(PREDICTION_PARAMS)
+
+    config_saver = OptimizerConfig  #to be redefined in real implementation if needed
+
     def __init__(self, dockarea, dashboard):
         super().__init__(dockarea, dashboard)
 
-        self.algorithm: Optional[BayesianAlgorithm] = None
+        self._ini_runner = False
+
+        self.algorithm: Optional[GenericAlgorithm] = None
         self.viewer_fitness: Optional[Viewer0D] = None
         self.viewer_observable: Optional[ViewerDispatcher] = None
-        self.model_class: Optional[BayesianModelGeneric] = None
+        self.model_class: Optional[OptimizerModelGeneric] = None
         self._save_main_settings = True
         self._modules_manager = ModulesManager(self.dashboard.detector_modules,
                                                self.dashboard.actuators_modules)
         self.modules_manager.actuators_changed[list].connect(self.update_actuators)
         self.modules_manager.settings.child('data_dimensions').setOpts(expanded=False)
         self.modules_manager.settings.child('actuators_positions').setOpts(expanded=False)
+
+        self._h5saver: H5Saver = None
+        self.h5saver.settings.child('do_save').hide()
+        self.h5saver.settings.child('custom_name').hide()
+        self.h5saver.new_file_sig.connect(self.create_new_file)
+
         self.setup_ui()
 
-        self.bayesian_config = BayesianConfig()
+        self.optimizer_config = self.config_saver()
+
         self.mainsettings_saver_loader = ConfigSaverLoader(
-            self.settings.child('main_settings'), self.bayesian_config)
+            self.settings.child('main_settings'), self.optimizer_config)
+
+        self._base_name: str = None
 
         self.h5temp: H5Saver = None
         self.temp_path: tempfile.TemporaryDirectory = None
-
         self.enlargeable_saver: DataEnlargeableSaver = None
         self.live_plotter = LoaderPlotter(self.dockarea)
 
+        self._module_and_data_saver: module_saving.OptimizerSaver = None
+
+        self._ind_iter: int = 0
         self.enl_index = 0
 
         self.settings.child('models', 'ini_model').sigActivated.connect(
@@ -141,6 +298,62 @@ class BayesianOptimisation(CustomExt):
 
         self.settings.child('models', 'ini_runner').sigActivated.connect(
             self.get_action('ini_runner').trigger)
+        self.ini_custom_attributes()
+
+    @property
+    def title(self):
+        return f'{self.__class__.__name__}'
+
+    def ini_custom_attributes(self):
+        """ Here you can reimplement specific attributes"""
+        self._base_name: str = 'Optimizer'  # base name used for naming the hdf5 file
+
+    @property
+    def h5saver(self):
+        if self._h5saver is None:
+            self._h5saver = H5Saver(save_type='optimizer', backend=config('general', 'hdf5_backend'))
+            self._h5saver.settings.child('base_name').setValue('Optimizer')
+        if self._h5saver.h5_file is None:
+            self._h5saver.init_file(update_h5=True)
+        if not self._h5saver.isopen():
+            self._h5saver.init_file(addhoc_file_path=self._h5saver.settings['current_h5_file'])
+        return self._h5saver
+
+    @h5saver.setter
+    def h5saver(self, h5saver_temp: H5Saver):
+        self._h5saver = h5saver_temp
+
+    @property
+    def module_and_data_saver(self):
+        if not self._module_and_data_saver.h5saver.isopen():
+            self._module_and_data_saver.h5saver = self.h5saver
+        return self._module_and_data_saver
+
+    @module_and_data_saver.setter
+    def module_and_data_saver(self, mod: module_saving.OptimizerSaver):
+        self._module_and_data_saver = mod
+        self._module_and_data_saver.h5saver = self.h5saver
+
+    def create_new_file(self, new_file):
+        if new_file:
+            self.close_file()
+        self.module_and_data_saver.h5saver = self.h5saver  # force all control modules to update their h5saver
+
+    def close_file(self):
+        self.h5saver.close_file()
+
+    def add_data(self, dta: DataToActuatorsOpti):
+        if self.is_action_checked('save'):
+            self.module_and_data_saver.add_data(axis_values=[dwa[0] for dwa in dta],
+                                                init_step=dta.ind_iter == 0)
+
+    @abc.abstractmethod
+    def validate_config(self) -> bool:
+        pass
+
+    @property
+    def config_path(self) -> Path:
+        return self.optimizer_config.config_path
 
     @property
     def modules_manager(self) -> ModulesManager:
@@ -160,32 +373,37 @@ class BayesianOptimisation(CustomExt):
         ########
         pyqtgraph.dockarea.Dock
         """
+        self.docks['saving'] = gutils.Dock('Saving')
+        self.docks['saving'].addWidget(self.h5saver.settings_tree)
+        self.dockarea.addDock(self.docks['saving'])
+
         self.docks['settings'] = gutils.Dock('Settings')
-        self.dockarea.addDock(self.docks['settings'])
-        splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        self.dockarea.addDock(self.docks['settings'], 'below', self.docks['saving'])
+        splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
         self.docks['settings'].addWidget(splitter)
         splitter.addWidget(self.settings_tree)
         splitter.addWidget(self.modules_manager.settings_tree)
-        self.modules_manager.show_only_control_modules(False)
+        self.modules_manager.show_only_control_modules(True)
+
         splitter.setSizes((int(self.dockarea.height() / 2),
                            int(self.dockarea.height() / 2)))
-
-        widget_observable = QtWidgets.QWidget()
-        widget_observable.setLayout(QtWidgets.QHBoxLayout())
-        observable_dockarea = gutils.DockArea()
-        widget_observable.layout().addWidget(observable_dockarea)
-        self.viewer_observable = ViewerDispatcher(observable_dockarea, direction='bottom')
-        self.docks['observable'] = gutils.Dock('Observable')
-        self.dockarea.addDock(self.docks['observable'], 'right', self.docks['settings'])
-        self.docks['observable'].addWidget(widget_observable)
-
-        if len(self.models) != 0:
-            self.get_set_model_params(self.models[0]['name'])
+        if self.DISPLAY_BEST:
+            widget_observable = QtWidgets.QWidget()
+            widget_observable.setLayout(QtWidgets.QHBoxLayout())
+            observable_dockarea = gutils.DockArea()
+            widget_observable.layout().addWidget(observable_dockarea)
+            self.viewer_observable = ViewerDispatcher(observable_dockarea, direction='bottom')
+            self.docks['observable'] = gutils.Dock('Observable')
+            self.dockarea.addDock(self.docks['observable'], 'right', self.docks['settings'])
+            self.docks['observable'].addWidget(widget_observable)
+
+        if len(MODELS) != 0:
+            self.get_set_model_params(MODELS[0]['name'])
 
     def get_set_model_params(self, model_name):
         self.settings.child('models', 'model_params').clearChildren()
-        if len(self.models) > 0:
-            model_class = utils.find_dict_in_list_from_key_val(self.models, 'name', model_name)['class']
+        if len(MODELS) > 0:
+            model_class = utils.find_dict_in_list_from_key_val(MODELS, 'name', model_name)['class']
             params = getattr(model_class, 'params')
             self.settings.child('models', 'model_params').addChildren(params)
 
@@ -223,26 +441,26 @@ class BayesianOptimisation(CustomExt):
         elif param.name() in putils.iter_children(self.settings.child('models', 'model_params'), []):
             if self.model_class is not None:
                 self.model_class.update_settings(param)
-        elif param.name() in putils.iter_children(
-                self.settings.child('main_settings', 'utility'), []):
-            if param.name() != 'kappa_actual':
-                self.update_utility_function()
         elif param.name() in putils.iter_children(
                 self.settings.child('main_settings', 'bounds'), []):
             self.update_bounds()
         elif param.name() in putils.iter_children(
             self.settings.child('main_settings', 'stopping'), []):
             self.update_stopping_criteria()
-        if self._save_main_settings and param.name() in putils.iter_children(
-                self.settings.child('main_settings'), []):
+        elif param.name() in putils.iter_children(
+                self.settings.child('main_settings', 'prediction'), []):
+            if param.name() != 'tradeoff_actual':
+                self.update_prediction_function()
+
+        if self._save_main_settings and self.model_class is not None and param.name() in putils.iter_children(
+               self.settings.child('main_settings'), []):
             self.mainsettings_saver_loader.save_config()
 
-    def update_utility_function(self):
-        utility_settings = self.settings.child('main_settings', 'utility')
-        uparams = UtilityParameters(utility_settings['kind'], utility_settings['kappa'],
-                                    utility_settings['xi'], utility_settings['kappa_decay'],
-                                    utility_settings['kappa_decay_delay'])
-        self.command_runner.emit(utils.ThreadCommand('utility', uparams))
+    def update_prediction_function(self):
+        utility_settings = self.settings.child('main_settings', 'prediction')
+        uparams = {child.name() : child.value() for child in utility_settings.children()}
+        self.command_runner.emit(
+            utils.ThreadCommand(OptimizerToRunner.PREDICTION, uparams))
 
     def get_stopping_parameters(self) -> StoppingParameters:
         stopping_settings = self.settings.child('main_settings', 'stopping')
@@ -253,20 +471,23 @@ class BayesianOptimisation(CustomExt):
         return stopping_params
 
     def update_stopping_criteria(self):
-        self.command_runner.emit(utils.ThreadCommand('stopping', self.get_stopping_parameters()))
+        self.command_runner.emit(
+            utils.ThreadCommand(OptimizerToRunner.STOPPING, self.get_stopping_parameters()))
 
     def update_bounds(self):
         bounds = {}
         for child in self.settings.child('main_settings', 'bounds').children():
             bounds[child.name()] = (child['min'], child['max'])
 
-        self.command_runner.emit(utils.ThreadCommand('bounds', bounds))
+        self.command_runner.emit(utils.ThreadCommand(OptimizerToRunner.BOUNDS, bounds))
 
     def setup_actions(self):
         logger.debug('setting actions')
         self.add_action('quit', 'Quit', 'close2', "Quit program")
         self.add_action('ini_model', 'Init Model', 'ini')
         self.add_widget('model_led', QLED, toolbar=self.toolbar)
+        self.add_action('save', 'Save?', 'SaveAs', tip='If checked, data will be saved',
+                        checkable=True)
         self.add_action('ini_runner', 'Init the Optimisation Algorithm', 'ini', checkable=True,
                         enabled=False)
         self.add_widget('runner_led', QLED, toolbar=self.toolbar)
@@ -277,24 +498,30 @@ class BayesianOptimisation(CustomExt):
 
     def connect_things(self):
         logger.debug('connecting things')
-        self.connect_action('quit', self.quit, )
+        self.connect_action('quit', self.quit)
         self.connect_action('ini_model', self.ini_model)
-        self.connect_action('ini_runner', self.ini_optimisation_runner)
-        self.connect_action('run', self.run_optimisation)
+        self.connect_action('ini_runner', self.ini_optimization_runner)
+        self.connect_action('run', self.run_optimization)
         self.connect_action('gotobest', self.go_to_best)
+        self.connect_action('save', self.ini_saver)
+        self.h5saver.new_file_sig.connect(self.create_new_file)
 
     def go_to_best(self):
         best_individual = self.algorithm.best_individual
-        actuators = self.modules_manager.selected_actuators_name
-        dte_act = DataToActuators('best', data=[
-            DataActuator(actuators[ind], data=float(best_individual[ind])) for ind in range(len(best_individual))
-        ],
-                                  mode='abs')
-        self.modules_manager.connect_actuators(True)
-        self.modules_manager.move_actuators(dte_act, polling=True)
-        self.modules_manager.connect_actuators(False)
+        if best_individual is not None:
+            actuators = self.modules_manager.selected_actuators_name
+            dte_act = DataToActuators('best',
+                                      data=[
+                                          DataActuator(actuators[ind],
+                                                       data=float(best_individual[ind]))
+                                          for ind in range(len(best_individual))
+                                      ],
+                                      mode='abs')
+            self.modules_manager.connect_actuators(True)
+            self.modules_manager.move_actuators(dte_act, polling=True)
+            self.modules_manager.connect_actuators(False)
 
-        self.modules_manager.grab_datas()
+            self.modules_manager.grab_datas()
 
     def quit(self):
         self.dockarea.parent().close()
@@ -303,7 +530,7 @@ class BayesianOptimisation(CustomExt):
     def set_model(self):
         model_name = self.settings.child('models', 'model_class').value()
         self.model_class = utils.find_dict_in_list_from_key_val(
-            self.models, 'name', model_name)['class'](self)
+            MODELS, 'name', model_name)['class'](self)
         self.model_class.ini_model_base()
 
     def ini_temp_file(self):
@@ -350,7 +577,7 @@ class BayesianOptimisation(CustomExt):
 
         QtWidgets.QApplication.processEvents()
         win_width = self.dockarea.width()
-        self.docks['settings'].container().setSizes((int(win_width / 5),
+        self.docks['settings'].container().parent().setSizes((int(win_width / 5),
                                                      int(2 * win_width / 5),
                                                      int(2 * win_width / 5), 10, 10))
 
@@ -370,21 +597,34 @@ class BayesianOptimisation(CustomExt):
                 {'title': 'max', 'name': 'max', 'type': 'float', 'value': 5},
             ]})
         self.settings.child('main_settings', 'bounds').addChildren(params)
-        self.mainsettings_saver_loader.base_path = [self.model_class.__class__.__name__] + \
-            self.modules_manager.selected_actuators_name
-        self.mainsettings_saver_loader.load_config()
-        self._save_main_settings = True
+
+        try:
+            self.mainsettings_saver_loader.base_path = [self.model_class.__class__.__name__] + \
+                                                       self.modules_manager.selected_actuators_name
+            self.mainsettings_saver_loader.load_config()
+            self._save_main_settings = True
+        except Exception as e:
+            logger.exception(f'Could not load the configuration')
+
+        self.update_after_actuators_changed(self.modules_manager.selected_actuators_name)
+
+    @abc.abstractmethod
+    def update_after_actuators_changed(self, actuators: list[str]):
+        """ Actions to do after the actuators have been updated
+
+        To be implemented
+        """
+        ...
 
     def format_bounds(self):
-        bound_dict = {}
+        bound_dict = OrderedDict([])
         for bound in self.settings.child('main_settings', 'bounds').children():
             bound_dict.update({bound.name(): (bound['min'], bound['max'])})
         return bound_dict
 
+    @abc.abstractmethod
     def set_algorithm(self):
-        self.algorithm = BayesianAlgorithm(
-            ini_random=self.settings['main_settings', 'ini_random'],
-            bounds=self.format_bounds(),)
+        self.algorithm = ...
 
     def ini_model(self):
         try:
@@ -398,8 +638,9 @@ class BayesianOptimisation(CustomExt):
             self.get_action('model_led').set_as_true()
             self.set_action_enabled('ini_model', False)
 
-            self.viewer_observable.update_viewers(['Viewer0D', 'Viewer0D'],
-                                                  ['Fitness', 'Individual'])
+            if self.DISPLAY_BEST:
+                self.viewer_observable.update_viewers(['Viewer0D', 'Viewer0D'],
+                                                      ['Fitness', 'Individual'])
             self.settings.child('models', 'ini_model').setValue(True)
             self.settings.child('models', 'ini_runner').setOpts(enabled=True)
             self.set_action_enabled('ini_runner', True)
@@ -416,37 +657,68 @@ class BayesianOptimisation(CustomExt):
         except Exception as e:
             logger.exception(str(e))
 
-    def ini_optimisation_runner(self):
-        if self.is_action_checked('ini_runner'):
-            self.set_algorithm()
-
-            self.settings.child('models', 'ini_runner').setValue(True)
-            self.enl_index = 0
-
-            self.ini_temp_file()
-            self.ini_live_plot()
-
-            self.runner_thread = QtCore.QThread()
-            runner = OptimisationRunner(self.model_class, self.modules_manager, self.algorithm,
-                                        self.get_stopping_parameters())
-            self.runner_thread.runner = runner
-            runner.algo_output_signal.connect(self.process_output)
-            runner.algo_finished.connect(self.optimisation_done)
-            self.command_runner.connect(runner.queue_command)
+    def ini_saver(self):
+        if self.is_action_checked('save'):
+            self.module_and_data_saver = module_saving.OptimizerSaver(
+                self, enl_axis_names=self.modules_manager.selected_actuators_name,
+                enl_axis_units=[act.units for act in self.modules_manager.actuators])
+            self.create_new_file(True)
+            self.module_and_data_saver.h5saver = self.h5saver
 
-            runner.moveToThread(self.runner_thread)
+    def ini_optimization_runner(self):
+        if self.is_action_checked('ini_runner'):
 
-            self.runner_thread.start()
-            self.get_action('runner_led').set_as_true()
-            self.set_action_enabled('run', True)
-            self.model_class.runner_initialized()
-            self.update_utility_function()
+            if not self._ini_runner:
+                self._ini_runner = True
+                self.set_algorithm()
+
+                if self.is_action_checked('save'):
+                    node = self.module_and_data_saver.get_set_node(new=True)
+                    self.h5saver.settings.child('current_scan_name').setValue(node.name)
+
+                self.settings.child('models', 'ini_runner').setValue(True)
+                self.enl_index = 0
+
+                self.ini_temp_file()
+                self.ini_live_plot()
+
+                self.runner_thread = QtCore.QThread()
+                runner = self.runner(self.model_class, self.modules_manager, self.algorithm,
+                                     self.get_stopping_parameters())
+                self.runner_thread.runner = runner
+                runner.algo_output_signal.connect(self.process_output)
+                runner.algo_finished.connect(self.optimization_done)
+                runner.runner_command.connect(self.thread_status)
+                runner.saver_signal.connect(self.add_data)
+                self.command_runner.connect(runner.queue_command)
+
+                runner.moveToThread(self.runner_thread)
+
+                self.runner_thread.start()
+                self.get_action('runner_led').set_as_true()
+                self.set_action_enabled('run', True)
+                self.model_class.runner_initialized()
+                self.update_prediction_function()
         else:
             if self.is_action_checked('run'):
                 self.get_action('run').trigger()
                 QtWidgets.QApplication.processEvents()
-            self.runner_thread.terminate()
+
+            self.splash.setVisible(True)
+            self.splash.showMessage('Quitting Runner Thread')
+            try:
+                self.command_runner.disconnect()
+            except TypeError:
+                pass
+            self.runner_thread.quit()
+            self.runner_thread.wait(5000)
+            if not self.runner_thread.isFinished():
+                self.runner_thread.terminate()
+                self.runner_thread.wait()
+            self.runner_thread = None
+            self.splash.setVisible(False)
             self.get_action('runner_led').set_as_false()
+            self._ini_runner = False
 
     def clean_h5_temp(self):
         if self.temp_path is not None:
@@ -456,30 +728,30 @@ class BayesianOptimisation(CustomExt):
             except Exception as e:
                 logger.exception(str(e))
 
-    def optimisation_done(self, dte: DataToExport):
+    def optimization_done(self, dte: DataToExport):
         self.go_to_best()
-        self.optimisation_done_signal.emit(dte)
+        self.optimization_done_signal.emit(dte)
 
     def process_output(self, dte: DataToExport):
 
         self.enl_index += 1
-        dwa_kappa = dte.remove(dte.get_data_from_name(DataNames.Kappa.name))
-        self.settings.child('main_settings', 'utility', 'kappa_actual').setValue(
-            float(dwa_kappa[0][0])
-        )
-
-        dwa_data = dte.remove(dte.get_data_from_name(DataNames.ProbedData.name))
-        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name(DataNames.Actuators.name))
-        self.viewer_observable.show_data(dte)
+        try:
+            dwa_tradeoff = dte.remove(dte.get_data_from_name(DataNames.Tradeoff))
+            self.settings.child('main_settings', 'prediction', 'tradeoff_actual').setValue(
+                float(dwa_tradeoff[0][0])
+            )
+        except KeyError:
+            pass
+        dwa_data = dte.remove(dte.get_data_from_name(DataNames.ProbedData))
+        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name(DataNames.Actuators))
+        if self.DISPLAY_BEST:
+            self.viewer_observable.show_data(dte)
 
-        # dwa_observations = self.algorithm.get_dwa_obervations(
-        #     self.modules_manager.selected_actuators_name)
         self.model_class.update_plots()
 
-        best_individual = dte.get_data_from_name(DataNames.Individual.name)
+        best_individual = dte.get_data_from_name(DataNames.Individual)
         best_indiv_as_list = [float(best_individual[ind][0]) for ind in range(len(best_individual))]
 
-
         self.enlargeable_saver.add_data('/RawData', dwa_data,
                                         axis_values=dwa_actuators.values())
         if len(best_indiv_as_list) == 1 or (
@@ -495,191 +767,26 @@ class BayesianOptimisation(CustomExt):
     def enable_controls_opti(self, enable: bool):
         pass
 
-    def run_optimisation(self):
+    def run_optimization(self):
         if self.is_action_checked('run'):
+            self.set_action_enabled('save', False)
             self.get_action('run').set_icon('pause')
-            self.command_runner.emit(utils.ThreadCommand('start', {}))
+            self.set_action_checked('gotobest', False)
+            self.set_action_enabled('gotobest', False)
+            self.command_runner.emit(utils.ThreadCommand(OptimizerToRunner.START))
             QtWidgets.QApplication.processEvents()
             QtWidgets.QApplication.processEvents()
-            self.command_runner.emit(utils.ThreadCommand('run', {}))
+            self.command_runner.emit(utils.ThreadCommand(OptimizerToRunner.RUN))
         else:
             self.get_action('run').set_icon('run2')
-            self.command_runner.emit(utils.ThreadCommand('stop', {}))
+            self.set_action_enabled('save', True)
+            self.command_runner.emit(utils.ThreadCommand(OptimizerToRunner.STOP))
             self.set_action_enabled('gotobest', True)
-
-            QtWidgets.QApplication.processEvents()
-
-
-class OptimisationRunner(QtCore.QObject):
-    algo_output_signal = QtCore.Signal(DataToExport)
-    algo_finished = QtCore.Signal(DataToExport)
-
-    def __init__(self, model_class: BayesianModelGeneric, modules_manager: ModulesManager,
-                 algorithm: BayesianAlgorithm, stopping_params: StoppingParameters):
-        super().__init__()
-
-        self.det_done_datas: DataToExport = None
-        self.input_from_dets: float = None
-        self.outputs: List[np.ndarray] = []
-        self.dte_actuators: DataToExport = None
-        self.stopping_params: StoppingParameters = stopping_params
-
-        self.model_class: BayesianModelGeneric = model_class
-        self.modules_manager: ModulesManager = modules_manager
-
-        self.running = True
-
-        self.optimisation_algorithm: BayesianAlgorithm = algorithm
-
-        self._ind_iter: int = 0
-
-    @QtCore.Slot(utils.ThreadCommand)
-    def queue_command(self, command: utils.ThreadCommand):
-        """
-        """
-        if command.command == "run":
-            self.run_opti(**command.attribute)
-
-        elif command.command == "stop":
-            self.running = False
-
-        elif command.command == 'utility':
-            utility_params: UtilityParameters = command.attribute
-            self.optimisation_algorithm.set_utility_function(
-                utility_params.kind,
-                kappa=utility_params.kappa,
-                xi=utility_params.xi,
-                kappa_decay=utility_params.kappa_decay,
-                kappa_decay_delay=utility_params.kappa_decay_delay)
-
-        elif command.command == 'stopping':
-            self.stopping_params: StoppingParameters = command.attribute
-
-        elif command.command == 'bounds':
-            self.optimisation_algorithm.set_bounds(command.attribute)
-
-    def run_opti(self, sync_detectors=True, sync_acts=True):
-        """Start the optimisation loop
-
-        Parameters
-        ----------
-        sync_detectors: (bool) if True will make sure all selected detectors (if any) all got their data before calling
-            the model
-        sync_acts: (bool) if True will make sure all selected actuators (if any) all reached their target position
-         before calling the model
-        """
-        self.running = True
-        converged = False
-        try:
-            if sync_detectors:
-                self.modules_manager.connect_detectors()
-            if sync_acts:
-                self.modules_manager.connect_actuators()
-
-            self.current_time = time.perf_counter()
-            logger.info('Optimisation loop starting')
-            while self.running:
-                self._ind_iter += 1
-
-                next_target = self.optimisation_algorithm.ask()
-
-                self.outputs = next_target
-                self.output_to_actuators: DataToActuators =\
-                    self.model_class.convert_output(
-                        self.outputs,
-                        best_individual=self.optimisation_algorithm.best_individual
-                    )
-
-                self.modules_manager.move_actuators(self.output_to_actuators,
-                                                    self.output_to_actuators.mode,
-                                                    polling=sync_acts)
-
-                # Do the evaluation (measurements)
-                self.det_done_datas = self.modules_manager.grab_data()
-                self.input_from_dets = self.model_class.convert_input(self.det_done_datas)
-
-                # Run the algo internal mechanic
-                self.optimisation_algorithm.tell(float(self.input_from_dets))
-
-                dte = DataToExport('algo',
-                                   data=[self.individual_as_data(
-                                       np.array([self.optimisation_algorithm.best_fitness]),
-                                       DataNames.Fitness.name),
-                                       self.individual_as_data(
-                                           self.optimisation_algorithm.best_individual,
-                                           DataNames.Individual.name),
-                                       DataCalculated(DataNames.ProbedData.name,
-                                                      data=[np.array([self.input_from_dets])],
-                                                      ),
-                                       self.output_to_actuators.merge_as_dwa(
-                                           'Data0D', DataNames.Actuators.name),
-                                       DataCalculated(
-                                           DataNames.Kappa.name,
-                                           data=[
-                                               np.array([self.optimisation_algorithm.kappa])])
-                                         ])
-                self.algo_output_signal.emit(dte)
-
-                self.optimisation_algorithm.update_utility_function()
-
-                if self.optimisation_algorithm.stopping(self._ind_iter, self.stopping_params):
-                    converged = True
-                    break
-
-            self.current_time = time.perf_counter()
             QtWidgets.QApplication.processEvents()
 
-            logger.info('Optimisation loop exiting')
-            self.modules_manager.connect_actuators(False)
-            self.modules_manager.connect_detectors(False)
-
-            if converged:
-                self.algo_finished.emit(dte)
-
-        except Exception as e:
-            logger.exception(str(e))
-
-    @staticmethod
-    def individual_as_data(individual: np.ndarray, name: str = 'Individual') -> DataCalculated:
-        return DataCalculated(name, data=[np.atleast_1d(np.squeeze(coordinate)) for coordinate in
-                                          np.atleast_1d(np.squeeze(individual))])
-
-
-def main(init_qt=True):
-    import sys
-    from pathlib import Path
-    from pymodaq.utils.daq_utils import get_set_preset_path
-
-    if init_qt:  # used for the test suite
-        app = mkQApp("PyMoDAQ Dashboard")
-
-    from pymodaq.dashboard import DashBoard
-
-    win = QtWidgets.QMainWindow()
-    area = gutils.dock.DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-
-    dashboard = DashBoard(area)
-    daq_scan = None
-    file = Path(get_set_preset_path()).joinpath(f"{'beam_steering_mock'}.xml")
-
-    if file.exists():
-        dashboard.set_preset_mode(file)
-        daq_scan = dashboard.load_bayesian()
-    else:
-        msgBox = QtWidgets.QMessageBox()
-        msgBox.setText(f"The default file specified in the configuration file does not exists!\n"
-                       f"{file}\n"
-                       f"Impossible to load the DAQScan Module")
-        msgBox.setStandardButtons(msgBox.Ok)
-        ret = msgBox.exec()
+    def thread_status(self, status: utils.ThreadCommand):
+        pass
 
-    if init_qt:
-        sys.exit(app.exec_())
-    return dashboard, daq_scan, win
 
 
-if __name__ == '__main__':
-    main()