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

pymodaq/extensions/bayesian/utils.py

@@ -4,112 +4,75 @@ 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 collections import namedtuple
 
 from bayes_opt import BayesianOptimization
-from bayes_opt import UtilityFunction
 
-from pymodaq_utils.utils import find_dict_in_list_from_key_val, get_entrypoints
+
 from pymodaq_utils.logger import set_logger, get_module_name
-from pymodaq_utils.enums import BaseEnum
-from pymodaq_utils.config import BaseConfig
 
-from pymodaq_gui.parameter import Parameter
-from pymodaq_gui.plotting.data_viewers.viewer import ViewersEnum
 
 from pymodaq_data.data import (DataToExport, DataCalculated,
                                 DataRaw, Axis)
 
-from pymodaq.utils.data import DataActuator, DataToActuators
-from pymodaq.utils.managers.modules_manager import ModulesManager
-
 
-if TYPE_CHECKING:
-    from pymodaq.extensions.bayesian.bayesian_optimisation import BayesianOptimisation
-
-logger = set_logger(get_module_name(__file__))
+from pymodaq.extensions.bayesian.acquisition import GenericAcquisitionFunctionFactory
 
+from pymodaq.extensions.optimizers_base.utils import (
+    GenericAlgorithm, OptimizerModelDefault, StopType, StoppingParameters,
+    OptimizerConfig)
 
-class StopType(BaseEnum):
-    Predict = 0
-
-
-class UtilityKind(BaseEnum):
-    ucb = 'Upper Confidence Bound'
-    ei = 'Expected Improvement'
-    poi = 'Probability of Improvement'
 
+logger = set_logger(get_module_name(__file__))
 
-UtilityParameters = namedtuple('UtilityParameters',
-                               ['kind', 'kappa', 'xi', 'kappa_decay', 'kappa_decay_delay'])
 
+class BayesianConfig(OptimizerConfig):
+    config_name = f"bayesian_settings"
 
-StoppingParameters = namedtuple('StoppingParameters',
-                                ['niter', 'stop_type', 'tolerance', 'npoints'])
 
 
-class BayesianAlgorithm:
+class BayesianAlgorithm(GenericAlgorithm):
 
     def __init__(self, ini_random: int, bounds: dict, **kwargs):
-
+        super().__init__(ini_random)
         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_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()
 
-    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 tradeoff(self):
+        return self._prediction.tradeoff
 
     @property
     def bounds(self) -> List[np.ndarray]:
-        return [bound for bound in self._algo._space.bounds]
+        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
+            self._algo.set_bounds(self._algo.space.array_to_params(np.array(bounds)))
+
+    def prediction_ask(self) -> np.ndarray:
+        """ Ask the prediction function or algo to provide the next point to probe"""
+        return self._prediction.suggest(self._algo._gp, self._algo.space)
 
     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']
@@ -181,226 +144,4 @@ class BayesianAlgorithm:
         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_logger/daq_logger.py

@@ -75,8 +75,6 @@ class DAQ_Logger(CustomExt):
         super().__init__(dockarea, dashboard)
 
         self.wait_time = 1000
-
-        self.logger_thread = None
         self.logger: Union[H5Logger, DataBaseLogger] = None
         self.setup_ui()
 
@@ -293,25 +291,22 @@ class DAQ_Logger(CustomExt):
         res = self.set_logging()
 
         # mandatory to deal with multithreads
-        if self.logger_thread is not None:
+        if self.runner_thread is not None:
             self.command_DAQ_signal.disconnect()
-            if self.logger_thread.isRunning():
-                self.logger_thread.exit()
-                while not self.logger_thread.isFinished():
-                    QThread.msleep(100)
-                self.logger_thread = None
+            self.exit_runner_thread()
+            self.runner_thread = None
 
-        self.logger_thread = QThread()
+        self.runner_thread = QThread()
 
         log_acquisition = DAQ_Logging(self.settings, self.logger, self.modules_manager)
 
-        log_acquisition.moveToThread(self.logger_thread)
+        log_acquisition.moveToThread(self.runner_thread)
 
         self.command_DAQ_signal[list].connect(log_acquisition.queue_command)
         log_acquisition.status_sig[list].connect(self.thread_status)
 
-        self.logger_thread.log_acquisition = log_acquisition
-        self.logger_thread.start()
+        self.runner_thread.log_acquisition = log_acquisition
+        self.runner_thread.start()
 
         self._actions['start'].setEnabled(False)
         QtWidgets.QApplication.processEvents()

pymodaq/extensions/daq_logger/h5logging.py

@@ -45,7 +45,7 @@ class H5Logger(AbstractLogger):
 
         self.module_and_data_saver = module_saving.LoggerSaver(self)
         for det in self.modules_manager.detectors_all:
-            det.module_and_data_saver = module_saving.DetectorEnlargeableSaver(det)
+            det.module_and_data_saver = module_saving.DetectorTimeSaver(det)
         self.module_and_data_saver.h5saver = self.h5saver  # will update its h5saver and all submodules's h5saver
 
     def close(self):

pymodaq/extensions/daq_scan.py

@@ -146,7 +146,7 @@ class DAQScan(QObject, ParameterManager):
         self.curvilinear_values = []
         self.plot_colors = utils.plot_colors
 
-        self.scan_thread: QThread = None
+        self.runner_thread: QThread = None
         self._h5saver: H5Saver = None
         self._module_and_data_saver: module_saving.ScanSaver = None
 
@@ -880,6 +880,13 @@ class DAQScan(QObject, ParameterManager):
         self._metada_dataset_set = True
         return res
 
+    def exit_runner_thread(self, duration : int = 5000):
+        self.runner_thread.quit()
+        terminated = self.runner_thread.wait(duration)
+        if not terminated:
+            self.runner_thread.terminate()
+            self.runner_thread.wait()
+
     def start_scan(self):
         """
             Start an acquisition calling the set_scan function.
@@ -919,27 +926,24 @@ class DAQScan(QObject, ParameterManager):
             self.module_and_data_saver.h5saver = self.h5saver  # force the update as the h5saver ill also be set on each detectors
 
             # mandatory to deal with multithreads
-            if self.scan_thread is not None:
+            if self.runner_thread is not None:
                 self.command_daq_signal.disconnect()
-                if self.scan_thread.isRunning():
-                    self.scan_thread.terminate()
-                    while not self.scan_thread.isFinished():
-                        QThread.msleep(100)
-                    self.scan_thread = None
+                self.exit_runner_thread()
+                self.runner_thread = None
 
-            self.scan_thread = QThread()
+            self.runner_thread = QThread()
 
             scan_acquisition = DAQScanAcquisition(self.settings, self.scanner, self.modules_manager,
                                                   )
 
             if config['scan']['scan_in_thread']:
-                scan_acquisition.moveToThread(self.scan_thread)
+                scan_acquisition.moveToThread(self.runner_thread)
             self.command_daq_signal[utils.ThreadCommand].connect(scan_acquisition.queue_command)
             scan_acquisition.scan_data_tmp[ScanDataTemp].connect(self.save_temp_live_data)
             scan_acquisition.status_sig[utils.ThreadCommand].connect(self.thread_status)
 
-            self.scan_thread.scan_acquisition = scan_acquisition
-            self.scan_thread.start()
+            self.runner_thread.scan_acquisition = scan_acquisition
+            self.runner_thread.start()
 
             self.ui.set_action_enabled('ini_positions', False)
             self.ui.set_action_enabled('start', False)
@@ -992,7 +996,8 @@ class DAQScan(QObject, ParameterManager):
         self.ui.set_permanent_status('Stoping acquisition')
         self.command_daq_signal.emit(utils.ThreadCommand("stop_acquisition"))
         scan_node = self.module_and_data_saver.get_last_node()
-        scan_node.attrs['scan_done'] = True
+        if scan_node is not None:
+            scan_node.attrs['scan_done'] = True
 
         if not self.dashboard.overshoot:
             self.set_ini_positions()  # do not set ini position again in case overshoot fired
@@ -1095,7 +1100,6 @@ class DAQScanAcquisition(QObject):
 
     def start_acquisition(self):
         try:
-            #todo hoaw to apply newlayout to adaptive mode? => cannot has to be a new extension
 
             self.modules_manager.connect_actuators()
             self.modules_manager.connect_detectors()
@@ -1120,20 +1124,6 @@ class DAQScanAcquisition(QObject):
                         positions = self.scanner.positions_at(self.ind_scan)  # get positions
                     else:
                         pass
-                        #todo update for v4
-                        # positions = learner.ask(1)[0][-1]  # next point to probe
-                        # if self.scanner.scan_type == 'Tabular':  # translate normalized curvilinear position to real coordinates
-                        #     self.curvilinear = positions
-                        #     length = 0.
-                        #     for v in self.scanner.vectors:
-                        #         length += v.norm()
-                        #         if length >= self.curvilinear:
-                        #             vec = v
-                        #             frac_curvilinear = (self.curvilinear - (length - v.norm())) / v.norm()
-                        #             break
-                        #
-                        #     position = (vec.vectorize() * frac_curvilinear).translate_to(vec.p1()).p2()
-                        #     positions = [position.x(), position.y()]
 
                     self.status_sig.emit(
                         utils.ThreadCommand("Update_scan_index",
@@ -1148,21 +1138,7 @@ class DAQScanAcquisition(QObject):
                     QThread.msleep(self.scan_settings['time_flow', 'wait_time_between'])
 
                     #grab datas and wait for grab completion
-                    self.det_done(self.modules_manager.grab_datas(positions=positions), positions)
-
-                    if self.isadaptive:
-                        #todo update for v4
-                        # det_channel = self.modules_manager.get_selected_probed_data()
-                        # det, channel = det_channel[0].split('/')
-                        # if self.scanner.scan_type == 'Tabular':
-                        #     self.curvilinear_array.append(np.array([self.curvilinear]))
-                        #     new_positions = self.curvilinear
-                        # elif self.scanner.scan_type == 'Scan1D':
-                        #     new_positions = positions[0]
-                        # else:
-                        #     new_positions = positions[:]
-                        # learner.tell(new_positions, self.modules_manager.det_done_datas[det]['data0D'][channel]['data'])
-                        pass
+                    self.det_done(self.modules_manager.grab_data(positions=positions), positions)
 
                     # daq_scan wait time
                     QThread.msleep(self.scan_settings.child('time_flow', 'wait_time').value())
@@ -1201,11 +1177,6 @@ class DAQScanAcquisition(QObject):
                 utils.ThreadCommand("add_data",
                                     dict(indexes=indexes, distribution=self.scanner.distribution)))
 
-            #todo related to adaptive (solution lies along the Enlargeable data saver)
-            if self.isadaptive:
-                for ind_ax, nav_axis in enumerate(self.navigation_axes):
-                    nav_axis.append(np.array(positions[ind_ax]))
-
             self.det_done_flag = True
 
             full_names: list = self.scan_settings['plot_options', 'plot_0d']['selected'][:]

pymodaq/extensions/h5browser.py

@@ -1,39 +1,8 @@
-import argparse
-from pathlib import Path
-import sys
-import os
-from qtpy import QtWidgets
-os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
-from pymodaq_gui.h5modules.browsing import H5Browser
-from pymodaq.utils.config import Config
+from pymodaq_gui.h5modules.h5browser import main, H5Browser  #backcompat
+from pymodaq_utils.utils import deprecation_msg
 
 
-config = Config()
-
-
-def main(h5file_path: Path = None):
-    from pymodaq_gui.utils.utils import mkQApp
-    import sys
-    app = mkQApp('H5Browser')
-
-    h5file_path_tmp = None
-    parser = argparse.ArgumentParser(description="Opens HDF5 files and navigate their contents")
-    parser.add_argument("-i", "--input", help="specify path to the file to be opened")
-    args = parser.parse_args()
-
-    if args.input:
-        h5file_path_tmp = Path(args.input).resolve()  # Transform to absolute Path in case it is relative
-
-        if not h5file_path_tmp.exists():
-            print(f'Error: {args.input} does not exist. Opening h5browser without input file.')
-            h5file_path_tmp = h5file_path
-
-    win = QtWidgets.QMainWindow()
-    prog = H5Browser(win, h5file_path=h5file_path_tmp)
-    win.show()
-    QtWidgets.QApplication.processEvents()
-
-    app.exec()
+deprecation_msg('H5Browser should now be loaded from the pymodaq_gui.h5modules.h5browser module')
 
 
 if __name__ == '__main__':