pymodaq 5.1.6__py3-none-any.whl

pymodaq/extensions/adaptive/adaptive_optimization.py

@@ -0,0 +1,179 @@
+from pymodaq_gui.messenger import messagebox
+from pymodaq_utils import utils
+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.optimizers_base.optimizer import (
+    GenericOptimization, OptimizationRunner, optimizer_params, OptimizerAction, StopType)
+from pymodaq.extensions.optimizers_base.utils import OptimizerModelDefault, find_key_in_nested_dict
+from pymodaq.extensions.optimizers_base.thread_commands import OptimizerToRunner
+
+from pymodaq.extensions.adaptive.loss_function import LossFunctionFactory,LossDim
+from pymodaq.extensions.adaptive.utils import AdaptiveAlgorithm, AdaptiveConfig
+
+
+logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
+
+
+EXTENSION_NAME = 'AdaptiveScan'
+CLASS_NAME = 'AdaptiveOptimization'
+
+STARTING_LOSS_DIM = LossDim.LOSS_1D
+
+PREDICTION_NAMES = list(LossFunctionFactory.keys(STARTING_LOSS_DIM))
+PREDICTION_PARAMS = (
+        [{'title': 'LossDim', 'name': 'lossdim', 'type': 'str',
+          'value': LossDim.LOSS_1D, 'readonly': True},
+         {'title': 'Kind', 'name': 'kind', 'type': 'list',
+          'value': PREDICTION_NAMES[0],
+          'limits': PREDICTION_NAMES}] +
+        [{'title': 'Options', 'name': 'options', 'type': 'group',
+          'children': LossFunctionFactory.get(STARTING_LOSS_DIM, PREDICTION_NAMES[0]).params}]
+)
+
+
+class AdaptiveOptimizationRunner(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')
+            lossdim = command.attribute.pop('lossdim')
+            self.optimization_algorithm.set_prediction_function(lossdim, kind, **command.attribute)
+        else:
+            super().queue_command(command)
+
+
+class AdaptiveOptimisation(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 = AdaptiveOptimizationRunner
+    params = optimizer_params(PREDICTION_PARAMS)
+    config_saver = AdaptiveConfig
+
+    DISPLAY_BEST = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.get_action(OptimizerAction.SAVE).trigger()
+        self.settings.child('main_settings', 'ini_random').hide()
+        self.settings.child('main_settings', 'stopping', 'tolerance').hide()
+        self.settings.child('main_settings', 'stopping', 'npoints').hide()
+        self.settings.child('main_settings', 'stopping', 'stop_type').setLimits(
+            [StopType.NONE.value, StopType.ITER.value])
+
+    def ini_custom_attributes(self):
+        """ Here you can reimplement specific attributes"""
+        self._base_name: str = 'Adaptive'
+
+    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 not in ("kind", "tradeoff_actual", 'lossdim') }
+                LossFunctionFactory.create(utility['lossdim'],
+                                           utility['kind'], **utility_params)
+            except (ValueError, KeyError):
+                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() == 'lossdim':
+            try:
+                self.settings.child('main_settings', 'prediction', 'kind').setLimits(
+                    LossFunctionFactory.keys(param.value())
+                )
+            except Exception as e:
+                logger.debug('Warning: Error while trying to infer the kind of loss, may be because limits just changed')
+        elif param.name() == 'kind':
+            utility_settings = self.settings.child('main_settings', 'prediction')
+            utility_settings.child('options').clearChildren()
+            try:
+                params = LossFunctionFactory.get(utility_settings['lossdim'],
+                                                 param.value()).params
+                utility_settings.child('options').addChildren(params)
+            except (KeyError, ValueError) as e:
+                logger.debug('Warning: Error while trying to populate options for loss, may be because limits for'
+                             ' kind setting just changed')
+
+    def update_prediction_function(self):
+        utility_settings = self.settings.child('main_settings', 'prediction')
+        try:
+            uparams = {child.name() : child.value() for child in utility_settings.child('options').children()}
+            uparams['kind'] = utility_settings['kind']
+            uparams['lossdim'] = utility_settings['lossdim']
+
+            self.command_runner.emit(
+                utils.ThreadCommand(OptimizerToRunner.PREDICTION, uparams))
+        except (KeyError, ValueError, AttributeError) as e:
+            pass
+            print(e)
+
+    def update_after_actuators_changed(self, actuators: list[str]):
+        """ Actions to do after the actuators have been updated
+        """
+        try:#see if there is some registered loss function for the defined type
+            self.settings.child('main_settings', 'prediction',
+                                'lossdim').setValue(LossDim.get_enum_from_dim_as_int(len(actuators)))
+            self.update_prediction_function()
+
+            LossFunctionFactory.create(self.settings['main_settings', 'prediction',
+                                                           'lossdim'],
+                                       self.settings['main_settings', 'prediction',
+                                                           'kind'])
+            self.get_action(OptimizerAction.INI_RUNNER).setEnabled(True)
+
+        except ValueError as e:
+            self.get_action(OptimizerAction.INI_RUNNER).setEnabled(False)
+            messagebox(title='Warning',
+                       text=f'You cannot select [{actuators}] as no corresponding Loss function exists')
+
+    def set_algorithm(self):
+        self.algorithm = AdaptiveAlgorithm(
+            ini_random=1,
+            bounds=self.format_bounds(),
+            actuators=self.modules_manager.selected_actuators_name,
+            loss_type=LossDim(self.settings['main_settings', 'prediction', 'lossdim']),
+            kind=self.settings['main_settings', 'prediction', 'kind'])
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('Adaptive Optimiser')
+    preset_file_name = config('presets', f'default_preset_for_scan')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'AdaptiveScan')
+
+    app.exec()
+
+    return dashboard, extension, win
+
+if __name__ == '__main__':
+    main()
+

pymodaq/extensions/adaptive/loss_function/_1d_loss_functions.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Callable
+
+from .loss_factory import LossFunctionBase, LossFunctionFactory, LossDim
+
+from adaptive.learner.learner1D import (
+    curvature_loss_function,
+    default_loss,
+    uniform_loss,
+    resolution_loss_function,
+    abs_min_log_loss,
+    uses_nth_neighbors,
+
+)
+
+
+def default_loss_function(*args, **kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return default_loss
+
+
+def uniform_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return uniform_loss
+
+
+def abs_min_log_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return abs_min_log_loss
+
+
+
+@LossFunctionFactory.register()
+class DefaultLoss(LossFunctionBase):
+    _loss = staticmethod(default_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Default'
+    params = []
+
+
+@LossFunctionFactory.register()
+class UniformLoss(LossFunctionBase):
+    _loss = staticmethod(uniform_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Uniform'
+    params = []
+
+
+@LossFunctionFactory.register()
+class CurvatureLoss(LossFunctionBase):
+    _loss = staticmethod(curvature_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Curvature'
+    params = [
+        {'title': 'Area', 'name': 'area_factor', 'type': 'float', 'value': 1.},
+        {'title': 'Euclid', 'name': 'euclid_factor', 'type': 'float', 'value': 0.02},
+        {'title': 'Horizontal', 'name': 'horizontal_factor', 'type': 'float', 'value': 0.02}
+    ]
+
+
+@LossFunctionFactory.register()
+class ResolutionLoss(LossFunctionBase):
+    _loss = staticmethod(resolution_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'Resolution'
+    params = [
+        {'title': 'Min:', 'name': 'min_length', 'type': 'float', 'value': 0., 'min': 0., 'max': 1.},
+        {'title': 'Max:', 'name': 'max_length', 'type': 'float', 'value': 1., 'min': 0., 'max': 1.},
+    ]
+
+
+@LossFunctionFactory.register()
+class AbsMinLogLoss(LossFunctionBase):
+    _loss = staticmethod(abs_min_log_loss_function)
+    dim = LossDim.LOSS_1D
+    usual_name = 'AbsMinLog'
+    params = []

pymodaq/extensions/adaptive/loss_function/_2d_loss_functions.py

@@ -0,0 +1,73 @@
+from typing import TYPE_CHECKING, Callable
+
+from .loss_factory import LossFunctionBase, LossFunctionFactory, LossDim
+
+from adaptive.learner.learner2D import (
+    default_loss,
+    uniform_loss,
+    resolution_loss_function,
+    minimize_triangle_surface_loss,
+    thresholded_loss_function,
+)
+
+
+def default_loss_function(*args, **kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return default_loss
+
+
+def uniform_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return uniform_loss
+
+
+def minimize_triangle_surface_loss_function(**kwargs):  #should be wrapped to handle eventual initializing argument, see params attributes below
+    return minimize_triangle_surface_loss
+
+
+@LossFunctionFactory.register()
+class DefaultLoss(LossFunctionBase):
+    _loss = staticmethod(default_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Default'
+    params = []
+
+
+@LossFunctionFactory.register()
+class UniformLoss(LossFunctionBase):
+    _loss = staticmethod(uniform_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Uniform'
+    params = []
+
+
+
+@LossFunctionFactory.register()
+class ResolutionLoss(LossFunctionBase):
+    _loss = staticmethod(resolution_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Resolution'
+    params = [
+        {'title': 'Min:', 'name': 'min_distance', 'type': 'float', 'value': 0., 'min': 0., 'max': 1.},
+        {'title': 'Max:', 'name': 'max_distance', 'type': 'float', 'value': 1., 'min': 0., 'max': 1.},
+    ]
+
+
+@LossFunctionFactory.register()
+class MinTriangleLoss(LossFunctionBase):
+    _loss = staticmethod(minimize_triangle_surface_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'MinTriangle'
+    params = []
+
+
+
+@LossFunctionFactory.register()
+class ThresholdLoss(LossFunctionBase):
+    _loss = staticmethod(thresholded_loss_function)
+    dim = LossDim.LOSS_2D
+    usual_name = 'Threshold'
+    params = [
+        {'title': 'Lower:', 'name': 'lower_threshold', 'type': 'float', 'value': None,},
+        {'title': 'Upper:', 'name': 'upper_threshold', 'type': 'float', 'value': None,},
+        {'title': 'Priority factor:', 'name': 'priority_factor', 'type': 'float', 'value': 0.1,},
+    ]
+

pymodaq/extensions/adaptive/loss_function/__init__.py

@@ -0,0 +1,3 @@
+from .loss_factory import LossFunctionFactory, LossDim
+from . import _1d_loss_functions  # to register inner class
+from . import _2d_loss_functions  # to register inner class

pymodaq/extensions/adaptive/loss_function/loss_factory.py

@@ -0,0 +1,110 @@
+from abc import ABCMeta, abstractmethod
+from collections import OrderedDict
+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: OrderedDict[str, 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.popitem(last=False)[1]
+            return Learner1D(None, bounds, loss_per_interval=loss_function)
+        elif self == self.LOSS_2D:
+            return Learner2D(None, tuple(bounds.values()), loss_per_triangle=loss_function)
+        elif self == self.LOSS_ND:
+            return LearnerND(None, tuple(bounds.values()), 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, {key: None}).get(key)
+        if loss is None:
+            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]:
+        try:
+            return list(cls._builders.get(dim).keys())
+        except (AttributeError, ValueError, KeyError) as e:
+            return []

pymodaq/extensions/adaptive/utils.py

@@ -0,0 +1,123 @@
+# -*- 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: OrderedDict[str, tuple[float, float]],
+                 actuators: list[str],
+                 loss_type: LossDim, kind: str, **kwargs):
+        super().__init__(ini_random, bounds, actuators)
+        self._algo = loss_type.get_learner_from_enum(
+            bounds=bounds,
+            loss_function=LossFunctionFactory.create(loss_type, kind, **kwargs))
+        self._best = 1
+
+    def get_random_point(self) -> dict[str, float]:
+        """ Get a random point coordinates in the defined bounds
+
+        Normally not needed for Adaptive
+        """
+        point = dict()
+        bounds = self.bounds
+        for ind in range(len(bounds)):
+            point[self.actuators[ind]] = ((np.max(bounds[ind]) - np.min(bounds[ind])) * np.random.random_sample() +
+                                          np.min(bounds[ind]))
+        return point
+
+    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) -> Dict[str, Tuple[float, float]]:
+        return dict(zip(self.actuators, self._algo.bounds))
+
+    @bounds.setter
+    def bounds(self, bounds: Dict[str, Tuple[float, float]]):
+        if isinstance(bounds, dict):
+            bounds = [bounds[act] for act in self.actuators]
+            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"""
+        return dict(zip(self.actuators, np.atleast_1d(self._algo.ask(1)[0][0])))
+
+    def tell(self, function_value: float):
+
+        next_point = tuple([self._next_point[act] for act in self.actuators])
+        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[dict[str, float], None]:
+        """ Return the individual coordinates with best fitness"""
+
+        if len(self._algo.data) > 0:
+            individual_array =  np.atleast_1d(list(self._algo.data.keys())[list(self._algo.data.values()).index(max(self._algo.data.values()))])
+        else:
+            individual_array =  np.atleast_1d(self._algo.bounds[0])
+        return dict(zip(self.actuators, individual_array))
+
+    def best_individuals(self, n_best):
+        if len(self._algo.data) > n_best:
+            individual_array =  np.atleast_1d(list(self._algo.data.keys())[list(self._algo.data.values()).index(max(self._algo.data.values()))])
+        else:
+            individual_array =  np.atleast_1d(self._algo.bounds[0])
+        return dict(zip(self.actuators, individual_array))
+
+
+    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
+        return False
+
+
+
+
+
+

pymodaq/extensions/bayesian/__init__.py

@@ -0,0 +1,2 @@
+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]