pymodaq 5.1.6__py3-none-any.whl

pymodaq/extensions/bayesian/acquisition/base_acquisition_function.py

@@ -0,0 +1,105 @@
+from bayes_opt.acquisition import UpperConfidenceBound, ExpectedImprovement, ProbabilityOfImprovement
+from pymodaq.extensions.bayesian.acquisition import GenericAcquisitionFunctionFactory, GenericAcquisitionFunctionBase
+
+
+@GenericAcquisitionFunctionFactory.register()
+class GenericUpperConfidenceBound(GenericAcquisitionFunctionBase):
+    usual_name = "Upper Confidence Bound"
+    short_name = "ucb"
+    params = [
+        {'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': 'tradeoff_actual', 'type': 'float', 'value': 2.576,
+         'tip': 'Current value of the kappa parameter', 'readonly': True},
+        {'title': 'Exploration decay:', 'name': 'exploration_decay', 'type': 'float', 'value': 0.9,
+         'tip': 'kappa is multiplied by this factor every iteration.'},
+        {'title': 'Exploration decay delay:', 'name': 'exploration_decay_delay', 'type': 'int', 'value': 20,
+         'tip': 'Number of iterations that must have passed before applying the decay to kappa.'}
+    ]
+    
+
+    def __init__(self,  **kwargs):
+        super().__init__()
+        self._function = UpperConfidenceBound(
+            kappa=kwargs.get('kappa', 2.576),
+            exploration_decay=kwargs.get('exploration_decay', None),
+            exploration_decay_delay=kwargs.get('exploration_decay_delay', None),
+            random_state=kwargs.get('random_state', None),
+        )
+
+    @property
+    def tradeoff(self):
+        return self._function.kappa
+
+    @tradeoff.setter
+    def tradeoff(self, tradeoff):
+        self._function.kappa = tradeoff
+
+@GenericAcquisitionFunctionFactory.register()
+class GenericProbabilityOfImprovement(GenericAcquisitionFunctionBase):
+    usual_name = "Probability of Improvement"
+    short_name = "poi"
+    params = [ 
+        {'title': 'Xi:', 'name': 'xi', 'type': 'slide', 'value': 0,
+         'tip': 'Governs the exploration/exploitation tradeoff.'
+                'Lower prefers exploitation, higher prefers exploration.'},
+        {'title': 'Xi actual:', 'name': 'tradeoff_actual', 'type': 'float', 'value': 2.576,
+         'tip': 'Current value of the xi parameter', 'readonly': True},
+        {'title': 'Exploration decay:', 'name': 'exploration_decay', 'type': 'float', 'value': 0.9,
+         'tip': 'Xi is multiplied by this factor every iteration.'},
+        {'title': 'Exploration decay delay:', 'name': 'exploration_decay_delay', 'type': 'int', 'value': 20,
+         'tip': 'Number of iterations that must have passed before applying the decay to xi.'}
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._function = ProbabilityOfImprovement(
+            xi=kwargs.get('xi'),
+            exploration_decay=kwargs.get('exploration_decay', None),
+            exploration_decay_delay=kwargs.get('exploration_decay_delay', None),
+            random_state=kwargs.get('random_state', None),
+        )
+
+    @property
+    def tradeoff(self):
+        return self._function.xi
+
+    @tradeoff.setter
+    def tradeoff(self, tradeoff):
+        self._function.xi = tradeoff
+
+@GenericAcquisitionFunctionFactory.register()
+class GenericExpectedImprovement(GenericAcquisitionFunctionBase):
+    usual_name = "Expected Improvement"
+    short_name = "ei"
+    params = [ 
+        {'title': 'Xi:', 'name': 'xi', 'type': 'slide', 'value': 0,
+         'tip': 'Governs the exploration/exploitation tradeoff.'
+                'Lower prefers exploitation, higher prefers exploration.'},
+        {'title': 'Xi actual:', 'name': 'tradeoff_actual', 'type': 'float', 'value': 2.576,
+         'tip': 'Current value of the xi parameter', 'readonly': True},
+        {'title': 'Exploration decay:', 'name': 'exploration_decay', 'type': 'float', 'value': 0.9,
+         'tip': 'Xi is multiplied by this factor every iteration.'},
+        {'title': 'Exploration decay delay:', 'name': 'exploration_decay_delay', 'type': 'int', 'value': 20,
+         'tip': 'Number of iterations that must have passed before applying the decay to xi.'}
+    ]
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._function = ExpectedImprovement(
+            xi=kwargs.get('xi'),
+            exploration_decay=kwargs.get('exploration_decay', None),
+            exploration_decay_delay=kwargs.get('exploration_decay_delay', None),
+            random_state=kwargs.get('random_state', None),
+        )
+
+    @property
+    def tradeoff(self):
+        return self._function.xi
+
+    @tradeoff.setter
+    def tradeoff(self, tradeoff):
+        self._function.xi = tradeoff

pymodaq/extensions/bayesian/bayesian_optimization.py

@@ -0,0 +1,143 @@
+
+
+from pymodaq_utils import config as config_mod, utils
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import ThreadCommand
+
+
+from pymodaq.extensions.bayesian.utils import BayesianAlgorithm, BayesianConfig
+
+from pymodaq.extensions.bayesian.acquisition import GenericAcquisitionFunctionFactory
+
+from pymodaq.extensions.optimizers_base.optimizer import (
+    GenericOptimization, OptimizationRunner, optimizer_params, OptimizerAction)
+from pymodaq.extensions.optimizers_base.utils import OptimizerModelDefault, find_key_in_nested_dict
+from pymodaq.extensions.optimizers_base.thread_commands import OptimizerToRunner, OptimizerThreadStatus
+
+
+logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
+
+
+EXTENSION_NAME = 'BayesianOptimization'
+CLASS_NAME = 'BayesianOptimization'
+
+PREDICTION_NAMES = GenericAcquisitionFunctionFactory.usual_names()
+PREDICTION_SHORT_NAMES = GenericAcquisitionFunctionFactory.short_names()
+PREDICTION_PARAMS = ([{'title': 'Kind', 'name': 'kind', 'type': 'list',
+                      'value': PREDICTION_NAMES[0],
+                      'limits': {name: short_name for name, short_name in zip(PREDICTION_NAMES, PREDICTION_SHORT_NAMES)}}
+                     ] +
+                     [{'title': 'Options', 'name': 'options', 'type': 'group',
+                       'children': GenericAcquisitionFunctionFactory.get(PREDICTION_SHORT_NAMES[0]).params}]
+                     )
+
+
+class BayesianOptimizationRunner(OptimizationRunner):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def queue_command(self, command: ThreadCommand):
+        """
+        """
+        if command.command == OptimizerToRunner.PREDICTION:
+            kind = command.attribute.pop('kind')
+            self.optimization_algorithm.set_acquisition_function(
+                kind,
+                **command.attribute)
+        else:
+            super().queue_command(command)
+
+
+class BayesianOptimization(GenericOptimization):
+    """ 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.
+    """
+
+    runner = BayesianOptimizationRunner
+    params = optimizer_params(PREDICTION_PARAMS)
+    config_saver = BayesianConfig
+
+    def ini_custom_attributes(self):
+        """ Here you can reimplement specific attributes"""
+        self._base_name: str = 'Bayesian'
+
+    def update_after_actuators_changed(self, actuators: list[str]):
+        """ Actions to do after the actuators have been updated
+        """
+        pass
+
+    def update_prediction_function(self):
+        """ Get the selected prediction function options and pass them to the Runner
+
+        Should be reimplemented in real Optimizer implementation
+        """
+        utility_settings = self.settings.child('main_settings', 'prediction')
+
+        kind = utility_settings.child('kind').value()
+        uparams = {child.name() : child.value() for child in utility_settings.child('options').children()}
+        uparams['kind'] = kind
+        self.command_runner.emit(
+            utils.ThreadCommand(OptimizerToRunner.PREDICTION, uparams))
+
+
+    def validate_config(self) -> bool:
+        utility = find_key_in_nested_dict(self.optimizer_config.to_dict(), 'prediction')
+        if utility:
+            try:
+                kind = utility.pop('kind', None)
+                if kind is not None:
+                    GenericAcquisitionFunctionFactory.create(kind, **utility)
+            except ValueError:
+                return False
+
+        return True
+
+    def value_changed(self, param):
+        """ to be subclassed for actions to perform when one of the param's value in self.settings is changed
+
+        For instance:
+        if param.name() == 'do_something':
+            if param.value():
+                print('Do something')
+                self.settings.child('main_settings', 'something_done').setValue(False)
+
+        Parameters
+        ----------
+        param: (Parameter) the parameter whose value just changed
+        """
+        super().value_changed(param)
+        if param.name() == 'kind':
+            param.parent().child('options').clearChildren()
+            param.parent().child('options').addChildren(
+                GenericAcquisitionFunctionFactory.get(param.value()).params)
+
+    def set_algorithm(self):
+        self.algorithm = BayesianAlgorithm(
+            ini_random=self.settings['main_settings', 'ini_random'],
+            bounds=self.format_bounds(),
+            actuators=self.modules_manager.selected_actuators_name)
+
+    def thread_status(self, status: utils.ThreadCommand):
+        super().thread_status(status)
+        if status.command == OptimizerThreadStatus.TRADE_OFF:
+            self.settings.child('main_settings', 'prediction', 'options', 'tradeoff_actual').setValue(status.attribute)
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('Bayesian Optimiser')
+    #preset_file_name = config('presets', f'beam_steering')
+
+    dashboard, extension, win = load_dashboard_with_preset('beam_steering', 'Bayesian')
+
+    app.exec()
+
+    return dashboard, extension, win
+
+if __name__ == '__main__':
+    main()
+

pymodaq/extensions/bayesian/utils.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 31/08/2023
+
+@author: Sebastien Weber
+"""
+
+from typing import List, TYPE_CHECKING, Union, Dict, Tuple, Iterable
+
+import bayes_opt.exception
+import numpy as np
+from collections import namedtuple
+
+from bayes_opt import BayesianOptimization
+from bayes_opt.exception import TargetSpaceEmptyError
+
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+
+from pymodaq_data.data import (DataToExport, DataCalculated,
+                                DataRaw, Axis)
+
+
+from pymodaq.extensions.bayesian.acquisition import GenericAcquisitionFunctionFactory
+
+from pymodaq.extensions.optimizers_base.utils import (
+    GenericAlgorithm, OptimizerModelDefault, StopType, StoppingParameters,
+    OptimizerConfig, PredictionError)
+
+
+logger = set_logger(get_module_name(__file__))
+
+
+class BayesianConfig(OptimizerConfig):
+    config_name = f"bayesian_settings"
+
+
+
+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.sorting_index: list = None
+
+    def set_prediction_function(self, kind: str = '', **kwargs):
+        self._prediction = GenericAcquisitionFunctionFactory.create(kind, **kwargs)
+
+    def update_prediction_function(self):
+        """ Update the parameters of the acquisition function (kappa decay for instance)"""
+        self._prediction.decay_exploration()
+
+    @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) -> 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: Dict[str, Tuple[float, float]]):
+        if isinstance(bounds, dict):
+            self._algo.set_bounds(bounds)
+        else:
+            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 tell(self, function_value: float):
+        self._algo.register(params=self._next_point, target=function_value)
+        
+    @property
+    def best_fitness(self) -> float:
+        if self._algo.max is None:
+            return 0.001
+        else:
+            return self._algo.max['target']
+
+    @property
+    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 max_param
+
+    def stopping(self, ind_iter: int, stopping_parameters: StoppingParameters):
+        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):
+
+        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
+
+
+

pymodaq/extensions/console.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 25/10/2022
+
+@author: Sebastien Weber
+"""
+
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtconsole.inprocess import QtInProcessKernelManager
+
+from pymodaq_utils import config as configmod
+from pymodaq_utils.utils import get_version
+
+
+config = configmod.Config()
+
+BANNER = f'PyMoDAQ v{get_version("pymodaq")}\n' \
+         'Main objects available for interaction:\n'\
+         '* dashboard: Main Dashboard Object\n'\
+         '* mods: ModuleManager of the dashboard\'s Control Modules\n'\
+         '* np: numpy module\n\n'\
+         'For inline plotting use: %matplotlib\n\n'
+
+
+class QtConsole(RichJupyterWidget):
+    """Live IPython console widget.
+    .. image:: img/IPythonWidget.png
+    :param custom_banner: Custom welcome message to be printed at the top of
+       the console.
+    """
+
+    def __init__(self, parent=None, custom_banner=None, *args, **kwargs):
+        if parent is not None:
+            kwargs["parent"] = parent
+        super().__init__(*args, **kwargs)
+        if custom_banner is not None:
+            self.banner = custom_banner
+        self.kernel_manager = kernel_manager = QtInProcessKernelManager()
+        kernel_manager.start_kernel()
+
+        self.kernel_client = kernel_client = self._kernel_manager.client()
+        kernel_client.start_channels()
+
+        def stop():
+            kernel_client.stop_channels()
+            kernel_manager.shutdown_kernel()
+        self.exit_requested.connect(stop)
+
+    def push_variables(self, variable_dict):
+        """ Given a dictionary containing name / value pairs, push those
+        variables to the IPython console widget.
+        :param variable_dict: Dictionary of variables to be pushed to the
+            console's interactive namespace (```{variable_name: object, …}```)
+        """
+        self.kernel_manager.kernel.shell.push(variable_dict)
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+
+    app = mkQApp('Console')
+
+    prog = QtConsole(style_sheet=config('style', 'syntax_highlighting'),
+                     syntax_style=config('style', 'syntax_highlighting'),
+                     custom_banner=BANNER,
+                     )
+    prog.show()
+    app.exec()
+    return prog
+
+
+if __name__ == '__main__':
+    main()

pymodaq/extensions/daq_logger/__init__.py

@@ -0,0 +1 @@
+from .daq_logger import main

pymodaq/extensions/daq_logger/abstract.py

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractLogger(ABC):
+    """
+    Minimal set of methods a class should implement to be considered as a logger in PyMoDAQ and used by the DAQ_Logger
+    extension
+
+    See Also
+    --------
+    pymodaq.utils.h5modules.H5Logger or pymodaq.utils.db.db_logger.DbLoggerGUI
+    """
+    @abstractmethod
+    def close(self):
+        pass
+
+    @property
+    @abstractmethod
+    def settings_tree(self):
+        pass
+
+    @property
+    @abstractmethod
+    def settings(self):
+        pass
+
+    @abstractmethod
+    def init_logger(self, settings):
+        pass
+
+    @abstractmethod
+    def get_handler(self):
+        """
+        returns a log handler to save the output of the error log into the particular implementation of the Logger object
+        """
+        pass
+
+    @abstractmethod
+    def add_detector(self, module_name, settings):
+        pass
+
+    @abstractmethod
+    def add_actuator(self, module_name, settings):
+        pass
+
+    @abstractmethod
+    def add_data(self, data):
+        pass
+
+    @abstractmethod
+    def stop_logger(self):
+        pass