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

pymodaq/extensions/adaptive/loss_function/loss_factory.py

@@ -0,0 +1,106 @@
+from abc import ABCMeta, abstractmethod
+from typing import Callable, Type, Union, Sequence
+from pymodaq_utils.enums import StrEnum
+
+
+from adaptive.learner import Learner1D, Learner2D, LearnerND, BaseLearner
+
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+
+
+class LossDim(StrEnum):
+
+    LOSS_1D = 'Loss1D'
+    LOSS_2D = 'Loss2D'
+    LOSS_ND = 'LossND'
+
+    @staticmethod
+    def get_enum_from_dim_as_int(dim: int):
+        if dim == 1:
+            return LossDim.LOSS_1D
+        elif dim == 2:
+            return LossDim.LOSS_2D
+        elif dim > 2:
+            return LossDim.LOSS_ND
+        else:
+            raise ValueError(f'No Loss with dim={dim} is known')
+
+    def get_learner_from_enum(self, bounds: Sequence[tuple[float, float]],
+                              loss_function: 'LossFunctionBase') -> Union[Learner1D, Learner2D, LearnerND]:
+        """ Return an instance of a Learner given the enum value
+
+        Parameters
+        ----------
+        bounds: type depends on the learner, could be a tuple of real numbers (Learner1D) or a tuple of tuples of real
+            numbers
+        loss_function: one of the LossFunction class as given by the LossFunctinoFactory
+
+        See Also:
+        ---------
+        :class:`LossFunctionFactory`
+        """
+        if self == self.LOSS_1D:
+            bounds = bounds[0]
+            return Learner1D(None, bounds, loss_per_interval=loss_function)
+        elif self == self.LOSS_2D:
+            return Learner2D(None, bounds, loss_per_triangle=loss_function)
+        elif self == self.LOSS_ND:
+            return LearnerND(None, bounds, loss_per_simplex=loss_function)
+        else:
+            raise ValueError(f'No learner for this enum: {self}')
+
+
+class LossFunctionBase(metaclass=ABCMeta):
+    _loss : Callable
+    dim: LossDim
+    usual_name: str
+    params: list[dict] = []
+
+    def __call__(self, *args, **kwargs):
+        return self._loss(**kwargs)
+
+
+class LossFunctionFactory:
+    _builders = {}
+
+    @classmethod
+    def register(cls) -> Callable:
+        """ To be used as a decorator
+
+        Register in the class registry a new LossFunction class using its 2 identifiers: LossDim and usual_name
+        """
+
+        def inner_wrapper(wrapped_class: LossFunctionBase) -> Callable:
+            key = wrapped_class.usual_name
+            dim = wrapped_class.dim
+            if dim not in cls._builders:
+                cls._builders[dim] = {}
+            if key not in cls._builders[dim]:
+                cls._builders[dim][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, dim: LossDim, key : str) -> Type[LossFunctionBase]:
+        loss = cls._builders.get(dim).get(key)
+        if not loss:
+            raise ValueError(f'Unknown Loss function with dim={dim} and key={key}')
+        return loss
+
+    @classmethod
+    def create(cls, dim: LossDim, key: str, **kwargs) -> LossFunctionBase:
+        return cls.get(dim, key)()(**kwargs)
+
+    @classmethod
+    def dims(cls) -> list[LossDim]:
+        return list(cls._builders.keys())
+
+    @classmethod
+    def keys(cls, dim: LossDim) -> list[str]:
+            return list(cls._builders.get(dim).keys())

pymodaq/extensions/adaptive/utils.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 31/08/2023
+
+@author: Sebastien Weber
+"""
+
+from typing import List, TYPE_CHECKING, Union, Dict, Tuple, Iterable
+
+import numpy as np
+from collections import OrderedDict
+from collections.abc import Iterable as IterableClass
+
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_data.data import (DataCalculated, DataRaw, Axis)
+
+
+from pymodaq.extensions.optimizers_base.utils import (
+    GenericAlgorithm, OptimizerModelDefault, StopType, StoppingParameters,
+    OptimizerConfig)
+from pymodaq.extensions.adaptive.loss_function.loss_factory import LossDim, LossFunctionBase, LossFunctionFactory
+
+logger = set_logger(get_module_name(__file__))
+
+
+class AdaptiveConfig(OptimizerConfig):
+    config_name = f"adaptive_settings"
+
+
+class AdaptiveAlgorithm(GenericAlgorithm):
+
+    def __init__(self, ini_random: int, bounds: list[tuple[float, float]],
+                 loss_type: LossDim, kind: str, **kwargs):
+        super().__init__(ini_random)
+        self._algo = loss_type.get_learner_from_enum(
+            bounds=bounds,
+            loss_function=LossFunctionFactory.create(loss_type, kind, **kwargs))
+        self._best = 1
+
+    def set_prediction_function(self, loss_type=LossDim.LOSS_1D, kind='',  **kwargs):
+        self._prediction = LossFunctionFactory.create(loss_type, kind, **kwargs)
+
+    def update_prediction_function(self):
+        pass
+
+    @property
+    def tradeoff(self) -> float:
+        return 0.
+
+    @property
+    def bounds(self) -> List[np.ndarray]:
+        return [np.array(bound) if isinstance(bound, IterableClass) else np.array([bound]) for bound in self._algo.bounds]
+
+    @bounds.setter
+    def bounds(self, bounds: Union[Tuple[float, float], Iterable[np.ndarray]]):
+        #todo check the type
+        self._algo.bounds = bounds
+
+    def prediction_ask(self) -> np.ndarray:
+        """ Ask the prediction function or algo to provide the next point to probe"""
+        return np.atleast_1d(self._algo.ask(1)[0][0])
+
+    def tell(self, function_value: float):
+        next_point = tuple(self._next_point)
+        if len(next_point) == 1:
+            next_point = next_point[0]  #Learner don't have the same tell method signature
+        self._algo.tell(next_point, function_value)
+        
+    @property
+    def best_fitness(self) -> float:
+        """ For adaptive optimization this is only used as a stopping critter"""
+        if 1/self._algo.loss() > self._best:
+            self._best = 1/self._algo.loss()
+        return self._best
+
+    @property
+    def best_individual(self) -> Union[np.ndarray, None]:
+        """ For adaptive optimization this doesn't mean anything"""
+        return np.atleast_1d(self.bounds[0])
+
+    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':
+            try:
+                return self.best_fitness < stopping_parameters.tolerance
+            except IndexError:
+                return False
+        return False
+
+
+
+
+
+

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,71 @@
+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
+    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 NotImplemented
+
+    @tradeoff.setter
+    def tradeoff(self, tradeoff):
+        raise NotImplemented
+
+    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._usual_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.get(key)(**kwargs)
+
+    @classmethod
+    def keys(cls) -> list[str]:
+            return list(cls._builders.keys())

pymodaq/extensions/bayesian/acquisition/base_acquisition_function.py

@@ -0,0 +1,86 @@
+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"
+    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(**kwargs)
+
+    @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"
+    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(**kwargs)
+
+    @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"
+    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(**kwargs)
+
+    @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,121 @@
+
+
+from pymodaq_utils import config as config_mod
+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)
+from pymodaq.extensions.optimizers_base.utils import OptimizerModelDefault, find_key_in_nested_dict
+from pymodaq.extensions.optimizers_base.thread_commands import OptimizerToRunner
+
+logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
+
+
+EXTENSION_NAME = 'BayesianOptimization'
+CLASS_NAME = 'BayesianOptimization'
+
+PREDICTION_NAMES = list(GenericAcquisitionFunctionFactory.keys())
+PREDICTION_PARAMS = [{'title': 'Kind', 'name': 'kind', 'type': 'list',
+                      'value': PREDICTION_NAMES[0],
+                      'limits': PREDICTION_NAMES}
+                     ] + GenericAcquisitionFunctionFactory.get(
+    PREDICTION_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:
+            utility_params = {k: v for k, v in command.attribute.items() if k != "kind" and k != "tradeoff_actual"}
+            self.optimization_algorithm.set_acquisition_function(
+                command.attribute['kind'],
+                **utility_params)
+        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 validate_config(self) -> bool:
+        utility = find_key_in_nested_dict(self.optimizer_config.to_dict(), 'prediction')
+        if utility:
+            try:
+                utility_params = { k : v for k, v in utility.items() \
+                                   if k != "kind" and k != "tradeoff_actual" }
+                GenericAcquisitionFunctionFactory.create(utility['kind'], **utility_params)
+            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':
+            utility_settings = self.settings.child('main_settings', 'prediction')
+            old_children = utility_settings.children()[1:]
+            for child in old_children:
+                utility_settings.removeChild(child)
+            utility_settings.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())
+
+
+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'default_preset_for_scan')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'Bayesian')
+
+    app.exec()
+
+    return dashboard, extension, win
+
+if __name__ == '__main__':
+    main()
+