ivoryos 1.0.9__py3-none-any.whl → 1.4.4__py3-none-any.whl

ivoryos/optimizer/base_optimizer.py

@@ -0,0 +1,84 @@
+### 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,
+                 parameter_constraints:list=None, datapath:str=None):
+        """
+        :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
+        self.datapath = datapath
+
+    @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
+
+    @abstractmethod
+    def get_plots(self, plot_type):
+        pass
+
+    @staticmethod
+    def _create_discrete_search_space(range_with_step=None, value_type ="float"):
+        if range_with_step is None:
+            range_with_step = []
+        import numpy as np
+        low, high, step = range_with_step
+        values = np.arange(low, high + 1e-9 * step, step).tolist()
+        if value_type == "float":
+            values = [float(v) for v in values]
+        if value_type == "int":
+            values = [int(v) for v in values]
+        return values
+
+    @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,193 @@
+### Directory: ivoryos/optimizers/baybe_optimizer.py
+from typing import Dict
+
+from pandas import DataFrame
+
+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,
+                 parameter_constraints:list=None, datapath=None):
+        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, parameter_constraints, )
+        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.experiment.recommend(batch_size=n).to_dict(orient="records")
+
+    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.
+
+        """
+        df = DataFrame(results)
+        self.experiment.add_measurements(df)
+
+    def append_existing_data(self, existing_data: DataFrame):
+        """
+        Append existing data to the Ax experiment.
+        :param existing_data: A dictionary containing existing data.
+        """
+        if existing_data.empty:
+            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(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": "range", "bounds": [1.0, 2.0, 0.5], "value_type": "float"},
+
+            {"name": "param_3", "type": "choice", "bounds": ["a", "b", "c"], "value_type": "str"},
+            {"name": "param_4", "type": "range", "bounds": [0 10], "value_type": "int"},
+            {"name": "param_5", "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 len(p["bounds"]) == 3:
+                    values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                    parameters.append(NumericalDiscreteParameter(name=p["name"], values=values))
+                elif 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", True)
+            weight = obj.get("weight", 1)
+            weights.append(weight)
+            targets.append(NumericalTarget(name=obj_name, minimize=minimize))
+
+        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
+        )
+
+    def get_plots(self, plot_type):
+        return None
+
+    @staticmethod
+    def get_schema():
+        """
+        Returns a template for the optimizer configuration.
+        """
+        return {
+            "parameter_types": ["range", "choice", "substance"],
+            "multiple_objectives": True,
+            "supports_continuous": True,
+            "supports_constraints": False,
+            "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/nimo_optimizer.py

@@ -0,0 +1,173 @@
+### ivoryos/optimizers/nimo_optimizer.py
+import glob
+import itertools
+import os
+
+
+from ivoryos.optimizer.base_optimizer import OptimizerBase
+
+
+class NIMOOptimizer(OptimizerBase):
+    def __init__(self, experiment_name:str, parameter_space: list, objective_config: list, optimizer_config: dict,
+                 parameter_constraints:list=None, datapath:str=None):
+        """
+        :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
+        {
+            "step_1": {"model": "RE", "num_samples": 10},
+            "step_2": {"model": "PDC"}
+        }
+        """
+        self.current_step = 0
+        self.experiment_name = experiment_name
+        self.parameter_space = parameter_space
+        self.objective_config = objective_config
+        self.optimizer_config = optimizer_config
+
+        super().__init__(experiment_name, parameter_space, objective_config, optimizer_config, parameter_constraints, datapath)
+
+        os.makedirs(os.path.join(self.datapath, "nimo_data"), exist_ok=True)
+
+        step_1 = optimizer_config.get("step_1", {})
+        step_2 = optimizer_config.get("step_2", {})
+        self.step_1_generator = step_1.get("model", "RE")
+        self.step_1_batch_num = step_1.get("num_samples", 1)
+        self.step_2_generator = step_2.get("model", "PDC")
+        self.candidates = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_candidates.csv")
+        self.proposals = os.path.join(self.datapath, "nimo_data", f"{self.experiment_name}_proposals.csv")
+        self.n_objectives = len(self.objective_config)
+        self._create_candidates_csv()
+
+
+    def _create_candidates_csv(self):
+        # Extract parameter names and their possible values
+        import pandas as pd
+        import nimo
+        import numpy as np
+        if os.path.exists(self.candidates) and nimo.history(self.candidates, self.n_objectives):
+            return
+        param_names = [p["name"] for p in self.parameter_space]
+
+        param_values = []
+        for p in self.parameter_space:
+            if p["type"] == "choice" and isinstance(p["bounds"], list):
+                param_values.append(p["bounds"])
+            elif p["type"] == "range" and len(p["bounds"]) == 3:
+                values = self._create_discrete_search_space(range_with_step=p["bounds"],value_type=p["value_type"])
+                param_values.append(values)
+            else:
+                raise ValueError(f"Unsupported parameter format: {p}")
+
+        # Generate all possible combinations
+        combos = list(itertools.product(*param_values))
+
+        # Create a DataFrame with parameter columns
+        df = pd.DataFrame(combos, columns=param_names)
+        # Add empty objective columns
+        for obj in self.objective_config:
+            df[obj["name"]] = ""
+
+        # Save to CSV
+        df.to_csv(self.candidates, index=False)
+
+
+    def suggest(self, n=1):
+        import pandas as pd
+        import nimo
+        method = self.step_1_generator if self.current_step <= self.step_1_batch_num else self.step_2_generator
+        nimo.selection(method = method,
+                       input_file = self.candidates,
+                       output_file = self.proposals,
+                       num_objectives = self.n_objectives,
+                       num_proposals = n)
+        self.current_step += 1
+        # Read proposals from CSV file
+        proposals_df = pd.read_csv(self.proposals)
+        # Get parameter names
+        param_names = [p["name"] for p in self.parameter_space]
+        # Convert proposals to list of parameter dictionaries
+        proposals = []
+        for _, row in proposals_df.iterrows():
+            proposal = {name: row[name] for name in param_names}
+            proposals.append(proposal)
+        return proposals
+
+    def _convert_observation_to_list(self, obs: dict) -> list:
+        obj_names = [o["name"] for o in self.objective_config]
+        return [obs.get(name, None) for name in obj_names]
+
+    def observe(self, results: list):
+        """
+        observe single output, nimo obj input is [1,2,3] or [[1, 2], [1, 2], [1, 2]] for MO
+        :param results: [{"objective_name": "value"}, {"objective_name": "value"}]]
+        """
+        import nimo
+        nimo_objective_values = [self._convert_observation_to_list(result) for result in results]
+        nimo.output_update(input_file=self.proposals,
+                           output_file=self.candidates,
+                           num_objectives=self.n_objectives,
+                           objective_values=nimo_objective_values)
+
+    def append_existing_data(self, existing_data):
+        # TODO, history is part of the candidate file, we probably won't need this
+        pass
+
+    def get_plots(self, plot_type):
+        import nimo
+        nimo.visualization.plot_phase_diagram.plot(input_file=self.candidates,
+                                                   fig_folder=os.path.join(self.datapath, "nimo_data"))
+        files = sorted(glob.glob(os.path.join(os.path.join(self.datapath, "nimo_data"), "phase_diagram_*.png")))
+        if not files:
+            return None
+        return files[-1]
+
+    @staticmethod
+    def get_schema():
+        return {
+            "parameter_types": ["choice", "range"],
+            "multiple_objectives": True,
+            "supports_continuous": False,
+            "supports_constraints": False,
+            "optimizer_config": {
+                "step_1": {"model": ["RE", "ES"], "num_samples": 5},
+                "step_2": {"model": ["PHYSBO", "PDC", "BLOX", "PTR", "SLESA", "BOMP", "COMBI"]}
+            },
+        }
+
+
+
+
+if __name__ == "__main__":
+    parameter_space = [
+        {"name": "silica", "type": "choice", "bounds": [100], "value_type": "float"},
+        {"name": "water", "type": "range", "bounds": [500, 900, 50], "value_type": "float"},
+        {"name": "PVA", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
+        {"name": "SDS", "type": "choice", "bounds": [0], "value_type": "float"},
+        {"name": "DTAB", "type": "choice", "bounds": [0, 0.005, 0.0075, 0.01, 0.05, 0.075, 0.1], "value_type": "float"},
+        {"name": "PVP", "type": "choice", "bounds": [0], "value_type": "float"},
+    ]
+    objective_config = [
+        {"name": "objective", "minimize": False, "weight": 1},
+
+    ]
+    optimizer_config = {
+        "step_1": {"model": "RE", "num_samples": 10},
+        "step_2": {"model": "PDC"}
+    }
+
+    nimo_optimizer = NIMOOptimizer(experiment_name="example_experiment", optimizer_config=optimizer_config, parameter_space=parameter_space, objective_config=objective_config)
+    nimo_optimizer.suggest(n=1)
+    nimo_optimizer.observe(
+        results=[{"objective": 1.0}]
+    )

ivoryos/optimizer/registry.py

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

ivoryos/routes/auth/auth.py

@@ -1,29 +1,31 @@
 from flask import Blueprint, redirect, url_for, flash, request, render_template, session
-from flask_login import login_required, login_user, logout_user, LoginManager
+from flask_login import login_required, login_user, logout_user, LoginManager, current_user
 import bcrypt
+from sqlalchemy_utils.types import password
 
 from ivoryos.utils.db_models import Script, User, db
 from ivoryos.utils.utils import post_script_file
 login_manager = LoginManager()
+# from flask import g
 
-auth = Blueprint('auth', __name__, template_folder='templates/auth')
+auth = Blueprint('auth', __name__, template_folder='templates')
 
 
-@auth.route('/auth/login', methods=['GET', 'POST'])
+@auth.route('/login', methods=['GET', 'POST'])
 def login():
     """
     .. :quickref: User; login user
 
-    .. http:get:: /login
+    .. http:get:: /auth/login
 
     load user login form.
 
-    .. http:post:: /login
+    .. http:post:: /auth/login
 
     :form username: username
     :form password: password
     :status 302: and then redirects to homepage
-    :status 401: incorrect password, redirects to :http:get:`/ivoryos/login`
+    :status 401: incorrect password, redirects to :http:get:`/ivoryos/auth/login`
     """
     if request.method == 'POST':
         username = request.form.get('username')
@@ -37,7 +39,8 @@ def login():
             # password.encode("utf-8")
             # user = User(username, password.encode("utf-8"))
             login_user(user)
-            session['user'] = username
+            # g.user = user
+            # session['user'] = username
             script_file = Script(author=username)
             session["script"] = script_file.as_dict()
             session['hidden_functions'], session['card_order'], session['prompt'] = {}, {}, {}
@@ -46,25 +49,25 @@ def login():
             return redirect(url_for('main.index'))
         else:
             flash("Incorrect username or password")
-            return redirect(url_for('auth.login')), 401
+            return redirect(url_for('auth.login'))
     return render_template('login.html')
 
 
-@auth.route('/auth/signup', methods=['GET', 'POST'])
+@auth.route('/signup', methods=['GET', 'POST'])
 def signup():
     """
     .. :quickref: User; signup for a new account
 
-    .. http:get:: /signup
+    .. http:get:: /auth/signup
 
     load user sighup
 
-    .. http:post:: /signup
+    .. http:post:: /auth/signup
 
     :form username: username
     :form password: password
-    :status 302: and then redirects to :http:get:`/ivoryos/login`
-    :status 409: when user already exists, redirects to :http:get:`/ivoryos/signup`
+    :status 302: and then redirects to :http:get:`/ivoryos/auth/login`
+    :status 409: when user already exists, redirects to :http:get:`/ivoryos/auth/signup`
     """
     if request.method == 'POST':
         username = request.form.get('username')
@@ -83,13 +86,39 @@ def signup():
         return redirect(url_for('auth.login'))
     return render_template('signup.html')
 
+@auth.route("/change-password", methods=['GET', 'POST'])
+@login_required
+def change_password():
+    """
+    .. :quickref: User; change password
+
+    .. http:get:: /auth/change-password
+
+    .. http:post:: /auth/change-password
 
-@auth.route("/auth/logout")
+    change password
+    """
+    if request.method == "POST":
+        old_password = request.form.get("old_password")
+        new_password = request.form.get("new_password")
+        # confirm_password = request.form.get("confirm_password")
+        user = User.query.filter_by(username=current_user.get_id()).first()
+        if not bcrypt.checkpw(old_password.encode('utf-8'), user.hashPassword):
+            flash("Incorrect password")
+            return redirect(url_for("auth.change_password"))
+        user.hashPassword = bcrypt.hashpw(new_password.encode('utf-8'), bcrypt.gensalt())
+        db.session.commit()
+        return redirect(url_for("main.index"))
+    return render_template("change_password.html")
+
+@auth.route("/logout")
 @login_required
 def logout():
     """
     .. :quickref: User; logout the user
 
+    .. http:get:: /auth/logout
+
     logout the current user, clear session info, and redirect to the login page.
     """
     logout_user()

ivoryos/routes/auth/templates/change_password.html

@@ -0,0 +1,32 @@
+{% extends 'base.html' %}
+{% block title %}IvoryOS | Change Password{% endblock %}
+
+
+{% block body %}
+<div class= "login">
+    <div class="bg-white rounded shadow-sm flex-fill">
+        <div class="p-4" style="align: center">
+            <h5>Change Password</h5>
+            <form role="form" method='POST' name="signup" action="{{ url_for('auth.change_password') }}">
+
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="old_password">Old Password</label>
+                    <input class="form-control" type="password" id="old_password" name="old_password" required>
+                </div>
+                <div class="input-group mb-3">
+                    <label class="input-group-text" for="new_password">New Password</label>
+                    <input class="form-control" type="password" id="new_password" name="new_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%;">Confirm</button>
+            </form>
+            <p class="message" >Need another account? <a href="{{ url_for('auth.signup') }}">Sign up</a></p>
+        </div>
+    </div>
+</div>
+
+{% endblock %}