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

pymodaq/extensions/bayesian/__init__.py

@@ -1,2 +1,2 @@
-from . import bayesian_optimisation
+from . import bayesian_optimization
 from . import utils

pymodaq/extensions/bayesian/acquisition/__init__.py

@@ -0,0 +1,2 @@
+from .acquisition_function_factory import GenericAcquisitionFunctionFactory, GenericAcquisitionFunctionBase
+from .base_acquisition_function import GenericUpperConfidenceBound, GenericExpectedImprovement, GenericProbabilityOfImprovement

pymodaq/extensions/bayesian/acquisition/acquisition_function_factory.py

@@ -0,0 +1,80 @@
+from abc import ABCMeta, abstractmethod
+from typing import Callable
+
+from numpy.random import RandomState
+from bayes_opt.acquisition import AcquisitionFunction
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+
+
+class GenericAcquisitionFunctionBase(metaclass=ABCMeta):
+    _function: AcquisitionFunction
+    usual_name: str
+    short_name: str
+    params : property(abstractmethod)
+
+    def base_acq(self, mean, std):
+        return self._function.base_acq(mean, std)
+
+    def decay_exploration(self):
+        self._function.decay_exploration()
+
+    @property
+    def tradeoff(self):
+        raise NotImplementedError
+
+    @tradeoff.setter
+    def tradeoff(self, tradeoff):
+        raise NotImplementedError
+
+    def suggest(self, gaussian_process, target_space, n_random = 1000, n_l_bfgs_b = 10, fit_gp = True):
+        return self._function.suggest(gaussian_process, target_space, n_random, n_l_bfgs_b, fit_gp)
+    
+
+class GenericAcquisitionFunctionFactory:
+    _builders = {}
+
+    @classmethod
+    def register(cls) -> Callable:
+        """ To be used as a decorator
+
+        Register in the class registry a new scanner class using its 2 identifiers: scan_type and scan_sub_type
+        """
+
+        def inner_wrapper(wrapped_class: GenericAcquisitionFunctionBase) -> Callable:
+            key = wrapped_class.short_name
+
+            if key not in cls._builders:
+                cls._builders[key] = wrapped_class
+            else:
+                logger.warning(f'The {key} builder is already registered. Replacing it')
+            return wrapped_class
+
+        return inner_wrapper
+
+
+    @classmethod
+    def get(cls, key : str) -> GenericAcquisitionFunctionBase:
+        builder = cls._builders.get(key)
+        if not builder:
+            raise ValueError(key)
+        return builder
+
+    @classmethod
+    def create(cls, key, **kwargs) -> GenericAcquisitionFunctionBase:
+        return cls._builders.get(key)(**kwargs)
+
+    @classmethod
+    def keys(cls) -> list[str]:
+        return list(cls._builders.keys())
+
+    @classmethod
+    def short_names(cls) -> list[str]:
+        return list(cls.keys())
+
+    @classmethod
+    def usual_names(cls) -> list[str]:
+        return [cls.get(builder).usual_name for builder in cls._builders]

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()
+