pymodaq 4.1.5__py3-none-any.whl → 4.2.1__py3-none-any.whl

pymodaq/extensions/bayesian/utils.py

@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+"""
+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 numpy as np
+from qtpy import QtWidgets
+import tempfile
+from collections import namedtuple
+
+from bayes_opt import BayesianOptimization
+from bayes_opt import UtilityFunction
+
+
+from pymodaq.utils.h5modules.saving import H5Saver
+from pymodaq.utils.data import (DataToExport, DataActuator, DataToActuators, DataCalculated,
+                                DataRaw, Axis)
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.daq_utils import find_dict_in_list_from_key_val, get_entrypoints
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.plotting.data_viewers.viewer import ViewersEnum
+from pymodaq.utils.enums import BaseEnum
+from pymodaq.utils.parameter import Parameter
+from pymodaq.utils.config import BaseConfig
+
+
+if TYPE_CHECKING:
+    from pymodaq.extensions.bayesian.bayesian_optimisation import BayesianOptimisation
+
+logger = set_logger(get_module_name(__file__))
+
+
+class StopType(BaseEnum):
+    Predict = 0
+
+
+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'])
+
+
+StoppingParameters = namedtuple('StoppingParameters',
+                                ['niter', 'stop_type', 'tolerance', 'npoints'])
+
+
+class BayesianAlgorithm:
+
+    def __init__(self, ini_random: int, bounds: dict, **kwargs):
+
+        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._utility = UtilityFunction(kind="ucb", kappa=self.kappa, xi=0.0)
+
+    def set_utility_function(self, kind: str, **kwargs):
+        if kind in UtilityKind.names():
+            self._utility = UtilityFunction(kind, **kwargs)
+
+    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 bounds(self) -> List[np.ndarray]:
+        return [bound for bound in self._algo._space.bounds]
+
+    @bounds.setter
+    def bounds(self, bounds: Union[Dict[str, Tuple[float, float]], Iterable[np.ndarray]]):
+        if isinstance(bounds, dict):
+            self._algo.set_bounds(bounds)
+        else:
+            self._algo.set_bounds(self._algo._space.array_to_params(np.array(bounds)))
+
+    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']
+
+    @property
+    def best_individual(self) -> Union[np.ndarray, None]:
+        max_param = self._algo.max.get('params', None)
+        if max_param is None:
+            return None
+        return self._algo.space.params_to_array(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)
+        return False
+
+    def _posterior(self, x_obs, y_obs, grid):
+
+        if len(x_obs.shape) == 1:
+            x_obs = x_obs.reshape(-1, 1)
+            y_obs = y_obs.reshape(-1, 1)
+            grid = grid.reshape(-1, 1)
+
+        self._algo._gp.fit(x_obs, y_obs)
+
+        mu, sigma = self._algo._gp.predict(grid, return_std=True)
+        return mu, sigma
+
+    def get_dwa_obervations(self, actuators_name):
+        try:
+            axes = [Axis(act, data=np.array([res['params'][act] for res in self._algo.res])) for
+                    act in actuators_name]
+            data_arrays = [np.array([res['target'] for res in self._algo.res])]
+
+            return DataRaw('Observations', data=data_arrays, labels=actuators_name,
+                           axes=axes)
+
+        except Exception as e:
+            pass
+
+    def get_1D_dwa_gp(self, x: np.ndarray, actuator_name: str):
+        """ Get Measurements and predictions as DataWithAxes
+
+        Parameters
+        ----------
+        x: np.ndarray
+            linear grid to get the Bayesian Optimisation On
+        """
+
+        dwa_obervation = self.get_dwa_obervations([actuator_name])
+
+        mu, sigma = self._posterior(dwa_obervation.axes[0].get_data(),
+                                    dwa_obervation.data[0], x)
+
+        dwa_measured = DataCalculated('Measurements', data=[dwa_obervation.data[0]],
+                                      axes=[Axis('measured_axis',
+                                                 data=dwa_obervation.axes[0].get_data())],
+                                      labels=['Sampled'])
+        dwa_prediction = DataCalculated('Prediction', data=[mu],
+                                        axes=[Axis('tested_pos', data=x)],
+                                        errors=[1.96 * sigma])
+        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_scan.py

@@ -22,7 +22,7 @@ from pymodaq.utils import data as data_mod
 from pymodaq.utils.logger import set_logger, get_module_name
 from pymodaq.utils.config import Config, get_set_preset_path
 from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.plotting.data_viewers.viewer import ViewersEnum
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
 
 from pymodaq.utils import exceptions
@@ -384,7 +384,8 @@ class DAQScan(QObject, ParameterManager):
 
     def show_file_content(self):
         try:
-            self.h5saver.init_file(addhoc_file_path=self.h5saver.settings.child(('current_h5_file')).value())
+            self.h5saver.init_file(addhoc_file_path=
+                                   self.h5saver.settings.child('current_h5_file').value())
             self.h5saver.show_file_content()
         except Exception as e:
             logger.exception(str(e))
@@ -1122,8 +1123,7 @@ class DAQScanAcquisition(QObject):
                 if self.Naverage > 1:
                     for nav_axis in nav_axes:
                         nav_axis.index += 1
-                    nav_axes.append(data_mod.Axis('Average', data=np.linspace(0, self.Naverage - 1,
-                                                                              self.Naverage),
+                    nav_axes.append(data_mod.Axis('Average', data=np.linspace(0, self.Naverage - 1, self.Naverage),
                                                   index=0))
                 self.module_and_data_saver.add_nav_axes(nav_axes)
 

pymodaq/extensions/daq_scan_ui.py

@@ -16,7 +16,8 @@ from pymodaq.utils.config import Config, get_set_preset_path
 from pymodaq.utils.gui_utils import DockArea, Dock
 from pymodaq.utils.gui_utils.widgets.spinbox import QSpinBox_ro
 from pymodaq.utils.parameter.pymodaq_ptypes.led import QLED
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.daq_utils import ThreadCommand
 
 if TYPE_CHECKING:

pymodaq/extensions/pid/pid_controller.py

@@ -15,11 +15,11 @@ from pymodaq.utils.daq_utils import ThreadCommand, find_dict_in_list_from_key_va
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
 from pymodaq.utils.gui_utils.widgets import QLED
-from pymodaq.extensions.pid.utils import DataToActuatorPID, get_models
+from pymodaq.extensions.pid.utils import get_models
 from pymodaq.utils.gui_utils.dock import DockArea, Dock
 from pymodaq.utils.gui_utils.custom_app import CustomApp
 from pymodaq.utils.gui_utils.widgets.label import LabelWithFont
-from pymodaq.utils.data import DataToExport, DataCalculated, DataActuator, DataRaw
+from pymodaq.utils.data import DataToExport, DataCalculated, DataActuator, DataRaw, DataToActuators
 from pymodaq.utils.config import Config
 
 config = Config()
@@ -479,7 +479,7 @@ class PIDRunner(QObject):
                                                                             data=[np.array([setpoints[ind]])])
                                                              for ind in range(Nsetpoints)])
         self.outputs = [0. for _ in range(Nsetpoints)]
-        self.outputs_to_actuators = DataToActuatorPID('pid',
+        self.outputs_to_actuators = DataToActuators('pid',
                                                       mode='rel',
                                                       data=[DataActuator(self.model_class.actuators_name[ind],
                                                                          data=self.outputs[ind])
@@ -505,8 +505,13 @@ class PIDRunner(QObject):
     #     self.timeout_timer.timeout.connect(self.timeout)
     #
     def timerEvent(self, event):
-        dte = DataToExport('toplot', data=[self.outputs_to_actuators.merge_as_dwa('Data0D', name='outputs')])
-        dte.append(self.inputs_from_dets.merge_as_dwa('Data0D', name='inputs'))
+        outputs_dwa = self.outputs_to_actuators.merge_as_dwa('Data0D', name='outputs')
+        outputs_dwa.labels = self.modules_manager.selected_actuators_name
+        dte = DataToExport('toplot', data=[outputs_dwa])
+
+        inputs_dwa = self.inputs_from_dets.merge_as_dwa('Data0D', name='inputs')
+        inputs_dwa.labels = self.modules_manager.selected_actuators_name
+        dte.append(inputs_dwa)
         self.pid_output_signal.emit(dte)
 
     @Slot(ThreadCommand)
@@ -582,8 +587,8 @@ class PIDRunner(QObject):
                     self.outputs = [pid.setpoint for pid in self.pids]
 
                 dt = time.perf_counter() - self.current_time
-                self.outputs_to_actuators: DataToActuatorPID = self.model_class.convert_output(self.outputs, dt,
-                                                                                               stab=True)
+                self.outputs_to_actuators: DataToActuators = (
+                    self.model_class.convert_output(self.outputs, dt, stab=True))
 
                 if not self.paused:
                     self.modules_manager.move_actuators(self.outputs_to_actuators,

pymodaq/extensions/pid/utils.py

@@ -9,10 +9,12 @@ from pymodaq.utils.gui_utils.dock import DockArea
 from pymodaq.utils.daq_utils import get_plugins
 from pymodaq.utils.logger import get_module_name, set_logger
 from pymodaq.utils.daq_utils import find_dict_in_list_from_key_val, get_entrypoints
-from pymodaq.utils.data import DataToExport, DataCalculated, DataActuator
+from pymodaq.utils.data import DataToExport, DataCalculated, DataActuator, DataToActuators
+from pymodaq.utils.messenger import deprecation_msg
 
 logger = set_logger(get_module_name(__file__))
 
+
 DAQ_Move_Stage_type = get_plugins('daq_move')
 DAQ_0DViewer_Det_types = get_plugins('daq_0Dviewer')
 DAQ_1DViewer_Det_types = get_plugins('daq_1Dviewer')
@@ -20,31 +22,11 @@ DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
-class DataToActuatorPID(DataToExport):
-    """ Particular case of a DataToExport adding one named parameter to indicate what kind of change should be applied
-    to the actuators, absolute or relative
-
-    Attributes
-    ----------
-    mode: str
-        Adds an attribute called mode holding a string describing the type of change: relative or absolute
-
-    Parameters
-    ---------
-    mode: str
-        either 'rel' or 'abs' for a relative or absolute change of the actuator's values
-    """
+class DataToActuatorPID(DataToActuators):
 
-    def __init__(self, *args, mode='rel', **kwargs):
-        if mode not in ['rel', 'abs']:
-            warnings.warn('Incorrect mode for the actuators, switching to default relative mode: rel')
-            mode = 'rel'
-        kwargs.update({'mode': mode})
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-
-    def __repr__(self):
-        return f'{super().__repr__()}: {self.mode}'
-
+        deprecation_msg('DataToActuatorPID object is deprecated use: pymodaq.utils.data:DataToActuators')
 
 class PIDModelGeneric:
     limits = dict(max=dict(state=False, value=1),
@@ -130,7 +112,7 @@ class PIDModelGeneric:
         """
         raise NotImplementedError
 
-    def convert_output(self, outputs: List[float], dt, stab=True) -> DataToActuatorPID:
+    def convert_output(self, outputs: List[float], dt, stab=True) -> DataToActuators:
         """
         Convert the output of the PID in units to be fed into the actuator
         Parameters
@@ -143,7 +125,7 @@ class PIDModelGeneric:
 
         """
         self.curr_output = outputs
-        return DataToActuatorPID('pid', mode='rel',
+        return DataToActuators('pid', mode='rel',
                                  data=[DataActuator(self.actuators_name[ind], data=outputs[ind])
                                        for ind in range(len(outputs))])
 
@@ -195,6 +177,7 @@ def get_models(model_name=None):
     from pymodaq.extensions.pid.utils import PIDModelGeneric
     models_import = []
     discovered_models = get_entrypoints(group='pymodaq.pid_models')
+    discovered_models = get_entrypoints(group='pymodaq.models')
     if len(discovered_models) > 0:
         for pkg in discovered_models:
             try:

pymodaq/extensions/utils.py

@@ -7,9 +7,11 @@ Created the 27/10/2022
 import importlib
 from pathlib import Path
 import pkgutil
+import warnings
 
 from pymodaq.utils import logger as logger_module
 from pymodaq.utils.daq_utils import get_entrypoints
+from pymodaq.utils.data import DataToExport
 logger = logger_module.set_logger(logger_module.get_module_name(__file__))
 
 
@@ -52,3 +54,4 @@ def get_extensions():
                 logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: {str(e)}')
 
     return extension_import
+