ivoryos 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

ivoryos/optimizer/ax_optimizer.py

@@ -0,0 +1,164 @@
+# optimizers/ax_optimizer.py
+from typing import Dict
+
+
+
+from ivoryos.optimizer.base_optimizer import OptimizerBase
+from ivoryos.utils.utils import install_and_import
+
+class AxOptimizer(OptimizerBase):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config=None):
+        try:
+            from ax.api.client import Client
+        except ImportError as e:
+            install_and_import("ax", "ax-platform")
+            raise ImportError("Please install Ax with pip install ax-platform to use AxOptimizer. Attempting to install Ax...")
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+
+        self.client = Client()
+        # 2. Configure where Ax will search.
+        self.client.configure_experiment(
+            name=experiment_name,
+            parameters=self._convert_parameter_to_ax_format(parameter_space)
+        )
+        # 3. Configure the objective function.
+        self.client.configure_optimization(objective=self._convert_objective_to_ax_format(objective_config))
+        if optimizer_config:
+            self.client.set_generation_strategy(self._convert_generator_to_ax_format(optimizer_config))
+        self.generators = self._create_generator_mapping()
+
+    @staticmethod
+    def _create_generator_mapping():
+        """Create a mapping from string values to Generator enum members."""
+        from ax.modelbridge import Generators
+        return {member.value: member for member in Generators}
+
+    def _convert_parameter_to_ax_format(self, parameter_space):
+        """
+        Converts the parameter space configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
+        ]
+        :return: A list of Baybe parameters.
+        """
+        from ax import RangeParameterConfig, ChoiceParameterConfig
+        ax_params = []
+        for p in parameter_space:
+            if p["type"] == "range":
+                ax_params.append(
+                    RangeParameterConfig(
+                        name=p["name"],
+                        bounds=tuple(p["bounds"]),
+                        parameter_type=p["value_type"]
+                    ))
+            elif p["type"] == "choice":
+                ax_params.append(
+                    ChoiceParameterConfig(
+                        name=p["name"],
+                        values=p["bounds"],
+                        parameter_type=p["value_type"],
+                    )
+                )
+        return ax_params
+
+    def _convert_objective_to_ax_format(self, objective_config: list):
+        """
+        Converts the objective configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "obj_1", "minimize": True, "weight": 1},
+            {"name": "obj_2", "minimize": False, "weight": 2}
+        ]
+        :return: Ax objective configuration. "-cost, utility"
+        """
+        objectives = []
+        for obj in objective_config:
+            obj_name = obj.get("name")
+            minimize = obj.get("minimize", True)
+            weight = obj.get("weight", 1)
+            sign = "-" if minimize else ""
+            objectives.append(f"{sign}{weight} * {obj_name}")
+        return ", ".join(objectives)
+
+    def _convert_generator_to_ax_format(self, optimizer_config):
+        """
+        Converts the optimizer configuration to Ax format.
+        :param optimizer_config: The optimizer configuration.
+        :return: Ax generator configuration.
+        """
+        from ax.generation_strategy.generation_node import GenerationStep
+        from ax.generation_strategy.generation_strategy import GenerationStrategy
+        generators = self._create_generator_mapping()
+        step_1 = optimizer_config.get("step_1", {})
+        step_2 = optimizer_config.get("step_2", {})
+        step_1_generator = step_1.get("model", "Sobol")
+        step_2_generator = step_2.get("model", "BOTorch")
+        generator_1 = GenerationStep(model=generators.get(step_1_generator), num_trials=step_1.get("num_samples", 5))
+        generator_2 = GenerationStep(model=generators.get(step_2_generator), num_trials=step_2.get("num_samples", -1))
+        return GenerationStrategy(steps=[generator_1, generator_2])
+
+    def suggest(self, n=1):
+        trial_index, params = self.client.get_next_trials(1).popitem()
+        self.trial_index = trial_index
+        return params
+
+    def observe(self, results):
+        self.client.complete_trial(
+            trial_index=self.trial_index,
+            raw_data=results
+        )
+
+    @staticmethod
+    def get_schema():
+        return {
+            "parameter_types": ["range", "choice"],
+            "multiple_objectives": True,
+            # "objective_weights": True,
+            "optimizer_config": {
+                "step_1": {"model": ["Sobol", "Uniform", "Factorial", "Thompson"], "num_samples": 5},
+                "step_2": {"model": ["BoTorch", "SAASBO", "SAAS_MTGP", "Legacy_GPEI", "EB", "EB_Ashr", "ST_MTGP", "BO_MIXED", "Contextual_SACBO"]}
+            },
+        }
+
+    def append_existing_data(self, existing_data):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+        from pandas import DataFrame
+        if not existing_data:
+            return
+        if isinstance(existing_data, DataFrame):
+            existing_data = existing_data.to_dict(orient="records")
+        parameter_names = [i.get("name") for i in self.parameter_space]
+        objective_names = [i.get("name") for i in self.objective_config]
+        for name, value in existing_data.items():
+            # First attach the trial and note the trial index
+            parameters = {name: value for name in existing_data if name in parameter_names}
+            trial_index = self.client.attach_trial(parameters=parameters)
+            raw_data = {name: value for name in existing_data if name in objective_names}
+            # Then complete the trial with the existing data
+            self.client.complete_trial(trial_index=trial_index, raw_data=raw_data)
+
+
+if __name__ == "__main__":
+    # Example usage
+    optimizer = AxOptimizer(
+        experiment_name="example_experiment",
+        parameter_space=[
+            {"name": "param_1", "type": "range", "bounds": [0.0, 1.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"}
+        ],
+        objective_config=[
+            {"name": "objective_1", "minimize": True},
+            {"name": "objective_2", "minimize": False}
+        ],
+        optimizer_config={
+            "step_1": {"model": "Sobol", "num_samples": 5},
+            "step_2": {"model": "BoTorch"}
+        }
+    )
+    print(optimizer._create_generator_mapping())

ivoryos/optimizer/base_optimizer.py

@@ -0,0 +1,65 @@
+### ivoryos/optimizers/base.py
+
+from abc import ABC, abstractmethod
+
+
+
+class OptimizerBase(ABC):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: dict, optimizer_config: dict):
+        """
+        :param experiment_name: arbitrary name
+        :param parameter_space: list of parameter names
+        [
+            {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
+        ]
+        :param objective_config: objective configuration
+                [
+            {"name": "obj_1", "minimize": True, "weight": 1},
+            {"name": "obj_2", "minimize": False, "weight": 1}
+        ]
+        :param optimizer_config: optimizer configuration
+        optimizer_config={
+            "step_1": {"model": "Random", "num_samples": 10},
+            "step_2": {"model": "BOTorch"}
+        }
+        """
+        self.experiment_name = experiment_name
+        self.parameter_space = parameter_space
+        self.objective_config = objective_config
+        self.optimizer_config = optimizer_config
+
+    @abstractmethod
+    def suggest(self, n=1):
+        pass
+
+    @abstractmethod
+    def observe(self, results: dict):
+        """
+        observe
+        :param results: {"objective_name": "value"}
+        """
+        pass
+
+    @abstractmethod
+    def append_existing_data(self, existing_data):
+        pass
+
+    @staticmethod
+    def get_schema():
+        """
+        Returns a template for the optimizer configuration.
+        """
+        return {
+            "parameter_types": ["range", "choice"],
+            "multiple_objectives": True,
+            # "objective_weights": True,
+            "optimizer_config": {
+                "step_1": {"model": [], "num_samples": 10},
+                "step_2": {"model": []}
+            },
+        }
+
+
+

ivoryos/optimizer/baybe_optimizer.py

@@ -0,0 +1,183 @@
+### Directory: ivoryos/optimizers/baybe_optimizer.py
+from typing import Dict
+
+
+from ivoryos.utils.utils import install_and_import
+from ivoryos.optimizer.base_optimizer import OptimizerBase
+
+class BaybeOptimizer(OptimizerBase):
+    def __init__(self, experiment_name, parameter_space, objective_config, optimizer_config):
+        try:
+            from baybe import Campaign
+        except ImportError:
+            install_and_import("baybe")
+            print("Please install Baybe with pip install baybe to before register BaybeOptimizer.")
+
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config)
+        self._trial_id = 0
+        self._trials = {}
+
+        self.experiment = Campaign(
+            searchspace=self._convert_parameter_to_searchspace(parameter_space),
+            objective=self._convert_objective_to_baybe_format(objective_config),
+            recommender=self._convert_recommender_to_baybe_format(optimizer_config),
+        )
+
+
+    def suggest(self, n=1):
+        self.df = self.experiment.recommend(batch_size=n)
+        return self.df.to_dict(orient="records")[0]
+
+    def observe(self, results, index=None):
+        """
+        Observes the results of a trial and updates the experiment.
+        :param results: A dictionary containing the results of the trial.
+        :param index: The index of the trial in the DataFrame, if applicable.
+
+        """
+        for name, value in results.items():
+            self.df[name] = [value]
+        self.experiment.add_measurements(self.df)
+
+    def append_existing_data(self, existing_data: Dict):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+        import pandas as pd
+        if not existing_data:
+            return
+        # parameter_names = [i.get("name") for i in self.parameter_space]
+        # objective_names = [i.get("name") for i in self.objective_config]
+        self.experiment.add_measurements(pd.DataFrame(existing_data))
+        # for name, value in existing_data.items():
+        #     # First attach the trial and note the trial index
+        #     parameters = {name: value for name in existing_data if name in parameter_names}
+        #     trial_index = self.client.attach_trial(parameters=parameters)
+        #     raw_data = {name: value for name in existing_data if name in objective_names}
+        #     # Then complete the trial with the existing data
+        #     self.client.complete_trial(trial_index=trial_index, raw_data=raw_data)
+
+
+    def _convert_parameter_to_searchspace(self, parameter_space):
+        """
+        Converts the parameter space configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_3", "type": "range", "bounds": [0 10], "value_type": "int"},
+            {"name": "param_4", "type": "substance", "bounds": ["methanol", "water", "toluene"], "value_type": "str"} #TODO
+        ]
+        :return: A list of Baybe parameters.
+        """
+        from baybe.parameters.categorical import CategoricalParameter
+        from baybe.parameters.numerical import NumericalContinuousParameter, NumericalDiscreteParameter
+        from baybe.searchspace import SearchSpace
+        parameters = []
+        for p in parameter_space:
+            if p["type"] == "range":
+                if p["value_type"] == "float":
+                    parameters.append(NumericalContinuousParameter(name=p["name"], bounds=p["bounds"]))
+                elif p["value_type"] == "int":
+                    values = tuple([int(v) for v in range(p["bounds"][0], p["bounds"][1] + 1)])
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=values))
+
+            elif p["type"] == "choice":
+                if p["value_type"] == "str":
+                    parameters.append(CategoricalParameter(name=p["name"], values=p["bounds"]))
+                elif p["value_type"] in ["int", "float"]:
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=p["bounds"]))
+        return SearchSpace.from_product(parameters)
+
+    def _convert_objective_to_baybe_format(self, objective_config):
+        """
+        Converts the objective configuration to Baybe format.
+        :param parameter_space: The parameter space configuration.
+        [
+            {"name": "obj_1", "minimize": True},
+            {"name": "obj_2", "minimize": False}
+        ]
+        :return: A Baybe objective configuration.
+        """
+        from baybe.targets import NumericalTarget
+        from baybe.objectives import SingleTargetObjective, DesirabilityObjective, ParetoObjective
+        targets = []
+        weights = []
+        for obj in objective_config:
+            obj_name = obj.get("name")
+            minimize = obj.get("minimize", False)
+            weight = obj.get("weight", 1)
+            weights.append(weight)
+            targets.append(NumericalTarget(name=obj_name, mode="MAX" if minimize else "MIN"))
+
+        if len(targets) == 1:
+            return SingleTargetObjective(target=targets[0])
+        else:
+            # Handle multiple objectives
+            return ParetoObjective(targets=targets)
+
+
+    def _convert_recommender_to_baybe_format(self, recommender_config):
+        """
+        Converts the recommender configuration to Baybe format.
+        :param recommender_config: The recommender configuration.
+        :return: A Baybe recommender configuration.
+        """
+        from baybe.recommenders import (
+            BotorchRecommender,
+            FPSRecommender,
+            TwoPhaseMetaRecommender,
+            RandomRecommender,
+            NaiveHybridSpaceRecommender
+        )
+        step_1 = recommender_config.get("step_1", {})
+        step_2 = recommender_config.get("step_2", {})
+        step_1_recommender = step_1.get("model", "Random")
+        step_2_recommender = step_2.get("model", "BOTorch")
+        if step_1.get("model") == "Random":
+            step_1_recommender = RandomRecommender()
+        elif step_1.get("model") == "FPS":
+            step_1_recommender = FPSRecommender()
+        if step_2.get("model") == "Naive Hybrid Space":
+            step_2_recommender = NaiveHybridSpaceRecommender()
+        elif step_2.get("model") == "BOTorch":
+            step_2_recommender = BotorchRecommender()
+        return TwoPhaseMetaRecommender(
+            initial_recommender=step_1_recommender,
+            recommender=step_2_recommender
+        )
+
+    @staticmethod
+    def get_schema():
+        """
+        Returns a template for the optimizer configuration.
+        """
+        return {
+            "parameter_types": ["range", "choice", "substance"],
+            "multiple_objectives": True,
+            "optimizer_config": {
+                "step_1": {"model": ["Random", "FPS"], "num_samples": 10},
+                "step_2": {"model": ["BOTorch", "Naive Hybrid Space"]}
+            },
+        }
+
+if __name__ == "__main__":
+    # Example usage
+    baybe_optimizer = BaybeOptimizer(
+        experiment_name="example_experiment",
+        parameter_space=[
+            {"name": "param_1", "type": "range", "bounds": [1.0, 2.0], "value_type": "float"},
+            {"name": "param_2", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_3", "type": "range", "bounds": [0, 10], "value_type": "int"}
+        ],
+        objective_config=[
+            {"name": "obj_1", "minimize": True},
+            {"name": "obj_2", "minimize": False}
+        ],
+        optimizer_config={
+            "step_1": {"model": "Random", "num_samples": 10},
+            "step_2": {"model": "BOTorch"}
+        }
+    )
+    print(baybe_optimizer.suggest(5))

ivoryos/optimizer/registry.py

@@ -0,0 +1,9 @@
+# optimizers/registry.py
+
+from ivoryos.optimizer.ax_optimizer import AxOptimizer
+from ivoryos.optimizer.baybe_optimizer import BaybeOptimizer
+
+OPTIMIZER_REGISTRY = {
+    "ax": AxOptimizer,
+    "baybe": BaybeOptimizer
+}

ivoryos/routes/api/api.py

@@ -0,0 +1,56 @@
+import os
+from flask import Blueprint, jsonify, request, current_app
+
+from ivoryos.routes.control.control import find_instrument_by_name
+from ivoryos.utils.form import create_form_from_module
+from ivoryos.utils.global_config import GlobalConfig
+from ivoryos.utils.db_models import Script, WorkflowRun, SingleStep, WorkflowStep
+
+from ivoryos.socket_handlers import abort_pending, abort_current, pause, retry, runner
+from ivoryos.utils.task_runner import TaskRunner
+
+api = Blueprint('api', __name__)
+global_config = GlobalConfig()
+task_runner = TaskRunner()
+
+#TODO: add authentication and authorization to the API endpoints
+
+
+@api.route("/control/", strict_slashes=False, methods=['GET'])
+@api.route("/control/<string:instrument>", methods=['POST'])
+def backend_control(instrument: str=None):
+    """
+    .. :quickref: Backend Control; backend control
+
+    backend control through http requests
+
+    .. http:get:: /api/control/
+
+    :param instrument: instrument name
+    :type instrument: str
+
+    .. http:post:: /api/control/
+
+    """
+    if instrument:
+        inst_object = find_instrument_by_name(instrument)
+        forms = create_form_from_module(sdl_module=inst_object, autofill=False, design=False)
+
+    if request.method == 'POST':
+        method_name = request.form.get("hidden_name", None)
+        form = forms.get(method_name, None)
+        if form:
+            kwargs = {field.name: field.data for field in form if field.name not in ['csrf_token', 'hidden_name']}
+            wait = request.form.get("hidden_wait", "true") == "true"
+            output = task_runner.run_single_step(component=instrument, method=method_name, kwargs=kwargs, wait=wait,
+                                            current_app=current_app._get_current_object())
+            return jsonify(output), 200
+
+    snapshot = global_config.deck_snapshot.copy()
+    # Iterate through each instrument in the snapshot
+    for instrument_key, instrument_data in snapshot.items():
+        # Iterate through each function associated with the current instrument
+        for function_key, function_data in instrument_data.items():
+            # Convert the function signature to a string representation
+            function_data['signature'] = str(function_data['signature'])
+    return jsonify(snapshot), 200

ivoryos/routes/auth/templates/login.html

@@ -0,0 +1,25 @@
+{% extends 'base.html' %}
+{% block title %}IvoryOS | Login{% endblock %}
+
+
+{% block body %}
+    <div class= "login">
+        <div class="bg-white rounded shadow-sm flex-fill">
+            <div class="p-4" style="align-items: center">
+                <h5>Log in</h5>
+                <form role="form" method='POST' name="login" action="{{ url_for('auth.login') }}">
+                    <div class="input-group mb-3">
+                        <label class="input-group-text" for="username">Username</label>
+                        <input class="form-control" type="text" id="username" name="username">
+                    </div>
+                    <div class="input-group mb-3">
+                        <label class="input-group-text" for="password">Password</label>
+                        <input class="form-control" type="password" id="password" name="password">
+                    </div>
+                    <button type="submit" class="btn btn-secondary" name="login" style="width: 100%;">login</button>
+                </form>
+                <p class="message">Not registered? <a href="{{ url_for('auth.signup') }}">Create a new account</a>
+            </div>
+        </div>
+    </div>
+{% endblock %}

ivoryos/routes/auth/templates/signup.html

@@ -0,0 +1,32 @@
+{% extends 'base.html' %}
+{% block title %}IvoryOS | Signup{% endblock %}
+
+
+{% block body %}
+<div class= "login">
+    <div class="bg-white rounded shadow-sm flex-fill">
+        <div class="p-4" style="align: center">
+            <h5>Create a new account</h5>
+            <form role="form" method='POST' name="signup" action="{{ url_for('auth.signup') }}">
+
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="username">Username</label>
+                    <input class="form-control" type="text" id="username" name="username" required>
+                </div>
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="password">Password</label>
+                    <input class="form-control" type="password" id="password" name="password" required>
+                </div>
+{#                <div class="input-group mb-3">#}
+{#                    <label class="input-group-text" for="confirm_password">Confirm Password</label>#}
+{#                    <input class="form-control" type="confirm_password" id="confirm_password" name="confirm_password">#}
+{#                </div>#}
+
+                <button type="submit" class="btn btn-secondary" name="login" style="width: 100%;">Sign up</button>
+            </form>
+            <p class="message" >Already registered? <a href="{{ url_for('auth.login') }}">Sign In</a></p>
+        </div>
+    </div>
+</div>
+
+{% endblock %}