pymodaq 5.0.18__py3-none-any.whl → 5.1.0__py3-none-any.whl

pymodaq/extensions/bayesian/utils.py

@@ -4,133 +4,129 @@ Created the 31/08/2023
 
 @author: Sebastien Weber
 """
-from abc import ABC, abstractproperty, abstractmethod
+
 from typing import List, TYPE_CHECKING, Union, Dict, Tuple, Iterable
-from pathlib import Path
-import importlib
-import pkgutil
-import inspect
+
+import bayes_opt.exception
 import numpy as np
 from collections import namedtuple
 
 from bayes_opt import BayesianOptimization
-from bayes_opt import UtilityFunction
+from bayes_opt.exception import TargetSpaceEmptyError
+
 
-from pymodaq_utils.utils import find_dict_in_list_from_key_val, get_entrypoints
 from pymodaq_utils.logger import set_logger, get_module_name
-from pymodaq_utils.enums import BaseEnum
-from pymodaq_utils.config import BaseConfig
 
-from pymodaq_gui.parameter import Parameter
-from pymodaq_gui.plotting.data_viewers.viewer import ViewersEnum
 
 from pymodaq_data.data import (DataToExport, DataCalculated,
                                 DataRaw, Axis)
 
-from pymodaq.utils.data import DataActuator, DataToActuators
-from pymodaq.utils.managers.modules_manager import ModulesManager
-
-
-if TYPE_CHECKING:
-    from pymodaq.extensions.bayesian.bayesian_optimisation import BayesianOptimisation
 
-logger = set_logger(get_module_name(__file__))
-
-
-class StopType(BaseEnum):
-    Predict = 0
+from pymodaq.extensions.bayesian.acquisition import GenericAcquisitionFunctionFactory
 
+from pymodaq.extensions.optimizers_base.utils import (
+    GenericAlgorithm, OptimizerModelDefault, StopType, StoppingParameters,
+    OptimizerConfig, PredictionError)
 
-class UtilityKind(BaseEnum):
-    ucb = 'Upper Confidence Bound'
-    ei = 'Expected Improvement'
-    poi = 'Probability of Improvement'
 
-
-UtilityParameters = namedtuple('UtilityParameters',
-                               ['kind', 'kappa', 'xi', 'kappa_decay', 'kappa_decay_delay'])
+logger = set_logger(get_module_name(__file__))
 
 
-StoppingParameters = namedtuple('StoppingParameters',
-                                ['niter', 'stop_type', 'tolerance', 'npoints'])
+class BayesianConfig(OptimizerConfig):
+    config_name = f"bayesian_settings"
 
 
-class BayesianAlgorithm:
 
-    def __init__(self, ini_random: int, bounds: dict, **kwargs):
+class BayesianAlgorithm(GenericAlgorithm):
 
+    def __init__(self, ini_random: int, bounds: dict[str, tuple[float, float]], actuators: list[str], **kwargs):
+        super().__init__(ini_random, bounds, actuators)
         self._algo = BayesianOptimization(f=None,
                                           pbounds=bounds,
                                           **kwargs
                                           )
-        self._next_point: np.ndarray = None
-        self._suggested_coordinates: List[np.ndarray] = []
-        self.ini_random_points = ini_random
-        self.kappa = 2.5
+        self.sorting_index: list = None
 
-        self._utility = UtilityFunction(kind="ucb", kappa=self.kappa, xi=0.0)
+    def set_prediction_function(self, kind: str = '', **kwargs):
+        self._prediction = GenericAcquisitionFunctionFactory.create(kind, **kwargs)
 
-    def set_utility_function(self, kind: str, **kwargs):
-        if kind in UtilityKind.names():
-            self._utility = UtilityFunction(kind, **kwargs)
+    def update_prediction_function(self):
+        """ Update the parameters of the acquisition function (kappa decay for instance)"""
+        self._prediction.decay_exploration()
 
-    def update_utility_function(self):
-        """ Update the parameters of the Utility function (kappa decay for instance)"""
-        self._utility.update_params()
-        self.kappa = self._utility.kappa
+    @property
+    def tradeoff(self):
+        return self._prediction.tradeoff
+
+    def get_random_point(self) -> dict[str, float]:
+        """ Get a random point coordinates in the defined bounds"""
+        point = dict()
+        for key, vals in self.bounds.items():
+            point[key] = (np.max(vals) - np.min(vals)) * np.random.random_sample() + np.min(vals)
+        return point
 
     @property
-    def bounds(self) -> List[np.ndarray]:
-        return [bound for bound in self._algo._space.bounds]
+    def bounds(self) -> dict[str, float]:
+        """ Return bounds as a dict.
+        """
+        return self._algo.space.array_to_params(self._algo.space.bounds)
 
     @bounds.setter
-    def bounds(self, bounds: Union[Dict[str, Tuple[float, float]], Iterable[np.ndarray]]):
+    def bounds(self, bounds: Dict[str, Tuple[float, float]]):
         if isinstance(bounds, dict):
             self._algo.set_bounds(bounds)
         else:
-            self._algo.set_bounds(self._algo._space.array_to_params(np.array(bounds)))
+            raise TypeError('Bounds should be defined as a dictionary')
+
+    def prediction_ask(self) -> dict[str, float]:
+        """ Ask the prediction function or algo to provide the next point to probe
+
+        Warning the space algo object is sorting by name the bounds...
+        """
+        try:
+            return self._algo.space.array_to_params(self._prediction.suggest(self._algo._gp, self._algo.space))
+        except TargetSpaceEmptyError as e:
+            raise PredictionError(str(e))
 
-    def get_random_point(self) -> np.ndarray:
-        """ Get a random point coordinates in the defined bounds"""
-        point = []
-        for bound in self.bounds:
-            point.append((np.max(bound) - np.min(bound)) * np.random.random_sample() +
-                         np.min(bound))
-        return np.array(point)
-
-    def ask(self) -> np.ndarray:
-        if self.ini_random_points > 0:
-            self.ini_random_points -= 1
-            self._next_point = self.get_random_point()
-        else:
-            self._next_point = self._algo.space.params_to_array(self._algo.suggest(self._utility))
-        self._suggested_coordinates.append(self._next_point)
-        return self._next_point
 
     def tell(self, function_value: float):
         self._algo.register(params=self._next_point, target=function_value)
-
+        
     @property
     def best_fitness(self) -> float:
-        return self._algo.max['target']
+        if self._algo.max is None:
+            return 0.001
+        else:
+            return self._algo.max['target']
 
     @property
-    def best_individual(self) -> Union[np.ndarray, None]:
+    def best_individual(self) -> Union[dict[str, float], None]:
         if self._algo.max is None:
             return None
         else:
             max_param = self._algo.max.get('params', None)
             if max_param is None:
                 return None
-            return self._algo.space.params_to_array(max_param)
+            return max_param
 
     def stopping(self, ind_iter: int, stopping_parameters: StoppingParameters):
-        if ind_iter >= stopping_parameters.niter:
-            return True
-        if ind_iter > stopping_parameters.npoints and stopping_parameters.stop_type == 'Predict':
-            coordinates = np.array(self._suggested_coordinates[-stopping_parameters.npoints:]).T
-            return np.all(np.std(coordinates, axis=1)
-                          < stopping_parameters.tolerance)
+        if stopping_parameters.stop_type != StopType.NONE:
+            if ind_iter >= stopping_parameters.niter:  # For instance StopType.ITER
+                return True
+            if ind_iter > stopping_parameters.npoints:
+                if stopping_parameters.stop_type == StopType.PREDICT:
+                    coordinates = np.atleast_1d([
+                        [coordinates[act] for coordinates in self._suggested_coordinates[-stopping_parameters.npoints:]]
+                        for act in self.actuators])
+                    return np.all(np.abs((np.std(coordinates, axis=1) / np.mean(coordinates, axis=1)))
+                                  < stopping_parameters.tolerance)
+                elif stopping_parameters.stop_type == StopType.BEST:
+                    coordinates = np.atleast_1d(
+                        [[best['params'][act] for best in
+                          sorted(self._algo.res, key=lambda x: x['target'])[-stopping_parameters.npoints:]]
+                         for act in self.actuators])
+                    return np.all(np.abs((np.std(coordinates, axis=1) / np.mean(coordinates, axis=1)))
+                                  < stopping_parameters.tolerance)
         return False
 
     def _posterior(self, x_obs, y_obs, grid):
@@ -181,226 +177,4 @@ class BayesianAlgorithm:
         return dwa_measured, dwa_prediction
 
 
-class BayesianModelGeneric(ABC):
-
-    optimisation_algorithm: BayesianAlgorithm = BayesianAlgorithm
-
-    actuators_name: List[str] = []
-    detectors_name: List[str] = []
-
-    observables_dim: List[ViewersEnum] = []
-
-    params = []  # to be subclassed
-
-    def __init__(self, optimisation_controller: 'BayesianOptimisation'):
-        self.optimisation_controller = optimisation_controller  # instance of the pid_controller using this model
-        self.modules_manager: ModulesManager = optimisation_controller.modules_manager
-
-        self.settings = self.optimisation_controller.settings.child('models', 'model_params')  # set of parameters
-        self.check_modules(self.modules_manager)
-
-    def check_modules(self, modules_manager):
-        for act in self.actuators_name:
-            if act not in modules_manager.actuators_name:
-                logger.warning(f'The actuator {act} defined in the model is'
-                               f' not present in the Dashboard')
-                return False
-        for det in self.detectors_name:
-            if det not in modules_manager.detectors_name:
-                logger.warning(f'The detector {det} defined in the model is'
-                               f' not present in the Dashboard')
-
-    def update_detector_names(self):
-        names = self.optimisation_controller.settings.child(
-            'main_settings', 'detector_modules').value()['selected']
-        self.data_names = []
-        for name in names:
-            name = name.split('//')
-            self.data_names.append(name)
-
-    def update_settings(self, param: Parameter):
-        """
-        Get a parameter instance whose value has been modified by a user on the UI
-        To be overwritten in child class
-        """
-        ...
-
-    def update_plots(self):
-        """ Called when updating the live plots """
-        pass
-
-    def ini_model_base(self):
-        self.modules_manager.selected_actuators_name = self.actuators_name
-        self.modules_manager.selected_detectors_name = self.detectors_name
-
-        self.ini_model()
-
-    def ini_model(self):
-        """ To be subclassed
 
-        Initialize whatever is needed by your custom model
-        """
-        raise NotImplementedError
-
-    def runner_initialized(self):
-        """ To be subclassed
-
-        Initialize whatever is needed by your custom model after the optimization runner is
-        initialized
-        """
-        pass
-
-    def convert_input(self, measurements: DataToExport) -> float:
-        """
-        Convert the measurements in the units to be fed to the Optimisation Controller
-        Parameters
-        ----------
-        measurements: DataToExport
-            data object exported from the detectors from which the model extract a float value
-            (fitness) to be fed to the algorithm
-
-        Returns
-        -------
-        float
-
-        """
-        raise NotImplementedError
-
-    def convert_output(self, outputs: List[np.ndarray], best_individual=None) -> DataToActuators:
-        """ Convert the output of the Optimisation Controller in units to be fed into the actuators
-        Parameters
-        ----------
-        outputs: list of numpy ndarray
-            output value from the controller from which the model extract a value of the same units as the actuators
-        best_individual: np.ndarray
-            the coordinates of the best individual so far
-        Returns
-        -------
-        DataToActuatorOpti: derived from DataToExport. Contains value to be fed to the actuators with a a mode
-            attribute, either 'rel' for relative or 'abs' for absolute.
-
-        """
-        raise NotImplementedError
-
-
-class BayesianModelDefault(BayesianModelGeneric):
-
-    actuators_name: List[str] = []  # to be populated dynamically at instantiation
-    detectors_name: List[str] = []  # to be populated dynamically at instantiation
-
-    params = [{'title': 'Optimizing signal', 'name': 'optimizing_signal', 'type': 'group',
-                'children': [
-                    {'title': 'Get data', 'name': 'data_probe', 'type': 'action'},
-                    {'title': 'Optimize 0Ds:', 'name': 'optimize_0d', 'type': 'itemselect',
-                     'checkbox': True},
-        ]},]
-
-    def __init__(self, optimisation_controller: 'BayesianOptimisation'):
-        self.actuators_name = optimisation_controller.modules_manager.actuators_name
-        self.detectors_name = optimisation_controller.modules_manager.detectors_name
-        super().__init__(optimisation_controller)
-
-        self.settings.child('optimizing_signal', 'data_probe').sigActivated.connect(
-            self.optimize_from)
-
-    def ini_model(self):
-        pass
-
-    def optimize_from(self):
-        self.modules_manager.get_det_data_list()
-        data0D = self.modules_manager.settings['data_dimensions', 'det_data_list0D']
-        data0D['selected'] = data0D['all_items']
-        self.settings.child('optimizing_signal', 'optimize_0d').setValue(data0D)
-
-    def update_settings(self, param: Parameter):
-        pass
-
-    def convert_input(self, measurements: DataToExport) -> float:
-        """ Convert the measurements in the units to be fed to the Optimisation Controller
-
-        Parameters
-        ----------
-        measurements: DataToExport
-            data object exported from the detectors from which the model extract a float value
-            (fitness) to be fed to the algorithm
-
-        Returns
-        -------
-        float
-
-        """
-        data_name: str = self.settings['optimizing_signal', 'optimize_0d']['selected'][0]
-        origin, name = data_name.split('/')
-        return float(measurements.get_data_from_name_origin(name, origin).data[0][0])
-
-    def convert_output(self, outputs: List[np.ndarray], best_individual=None) -> DataToActuators:
-        """ Convert the output of the Optimisation Controller in units to be fed into the actuators
-        Parameters
-        ----------
-        outputs: list of numpy ndarray
-            output value from the controller from which the model extract a value of the same units as the actuators
-        best_individual: np.ndarray
-            the coordinates of the best individual so far
-
-        Returns
-        -------
-        DataToActuators: derived from DataToExport. Contains value to be fed to the actuators
-        with a mode            attribute, either 'rel' for relative or 'abs' for absolute.
-
-        """
-        return DataToActuators('outputs', mode='abs',
-                               data=[DataActuator(self.modules_manager.actuators_name[ind],
-                                                  data=float(outputs[ind])) for ind in
-                                     range(len(outputs))])
-
-
-def get_bayesian_models(model_name=None):
-    """
-    Get PID Models as a list to instantiate Control Actuators per degree of liberty in the model
-
-    Returns
-    -------
-    list: list of disct containting the name and python module of the found models
-    """
-    models_import = []
-    discovered_models = get_entrypoints(group='pymodaq.models')
-    if len(discovered_models) > 0:
-        for pkg in discovered_models:
-            try:
-                module = importlib.import_module(pkg.value)
-                module_name = pkg.value
-
-                for mod in pkgutil.iter_modules([
-                    str(Path(module.__file__).parent.joinpath('models'))]):
-                    try:
-                        model_module = importlib.import_module(f'{module_name}.models.{mod.name}',
-                                                               module)
-                        classes = inspect.getmembers(model_module, inspect.isclass)
-                        for name, klass in classes:
-                            if issubclass(klass, BayesianModelGeneric):
-                                if find_dict_in_list_from_key_val(models_import, 'name', mod.name)\
-                                        is None:
-                                    models_import.append({'name': klass.__name__,
-                                                          'module': model_module,
-                                                          'class': klass})
-
-                    except Exception as e:
-                        logger.warning(str(e))
-
-            except Exception as e:
-                logger.warning(f'Impossible to import the {pkg.value} bayesian model: {str(e)}')
-    if find_dict_in_list_from_key_val(models_import, 'name', 'BayesianModelDefault') \
-            is None:
-        models_import.append({'name': 'BayesianModelDefault',
-                              'module': inspect.getmodule(BayesianModelDefault),
-                              'class': BayesianModelDefault})
-    if model_name is None:
-        return models_import
-    else:
-        return find_dict_in_list_from_key_val(models_import, 'name', model_name)
-
-
-class BayesianConfig(BaseConfig):
-    """Main class to deal with configuration values for this plugin"""
-    config_template_path = None
-    config_name = f"bayesian_settings"

pymodaq/extensions/daq_logger/daq_logger.py

@@ -75,8 +75,6 @@ class DAQ_Logger(CustomExt):
         super().__init__(dockarea, dashboard)
 
         self.wait_time = 1000
-
-        self.logger_thread = None
         self.logger: Union[H5Logger, DataBaseLogger] = None
         self.setup_ui()
 
@@ -293,25 +291,22 @@ class DAQ_Logger(CustomExt):
         res = self.set_logging()
 
         # mandatory to deal with multithreads
-        if self.logger_thread is not None:
+        if self.runner_thread is not None:
             self.command_DAQ_signal.disconnect()
-            if self.logger_thread.isRunning():
-                self.logger_thread.exit()
-                while not self.logger_thread.isFinished():
-                    QThread.msleep(100)
-                self.logger_thread = None
+            self.exit_runner_thread()
+            self.runner_thread = None
 
-        self.logger_thread = QThread()
+        self.runner_thread = QThread()
 
         log_acquisition = DAQ_Logging(self.settings, self.logger, self.modules_manager)
 
-        log_acquisition.moveToThread(self.logger_thread)
+        log_acquisition.moveToThread(self.runner_thread)
 
         self.command_DAQ_signal[list].connect(log_acquisition.queue_command)
         log_acquisition.status_sig[list].connect(self.thread_status)
 
-        self.logger_thread.log_acquisition = log_acquisition
-        self.logger_thread.start()
+        self.runner_thread.log_acquisition = log_acquisition
+        self.runner_thread.start()
 
         self._actions['start'].setEnabled(False)
         QtWidgets.QApplication.processEvents()

pymodaq/extensions/daq_logger/h5logging.py

@@ -45,7 +45,7 @@ class H5Logger(AbstractLogger):
 
         self.module_and_data_saver = module_saving.LoggerSaver(self)
         for det in self.modules_manager.detectors_all:
-            det.module_and_data_saver = module_saving.DetectorEnlargeableSaver(det)
+            det.module_and_data_saver = module_saving.DetectorTimeSaver(det)
         self.module_and_data_saver.h5saver = self.h5saver  # will update its h5saver and all submodules's h5saver
 
     def close(self):