From bf35b3255c1860d2d292df34f5b8fca585016115 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 2 Feb 2026 13:39:29 +0100 Subject: [PATCH 1/9] Update Reaction_Optimization notebook --- notebooks/Reaction_Optimization.py | 63 +++++++++++++++--------------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index 94cb548..e799b05 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -18,11 +18,19 @@ def _(mo): mo.md(r""" # Using BayBE to optimize Reaction Conditions - This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). + This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of BayBE. In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use BayBE to model and optimize such a campaign. - **Note:** We assume basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of BayBE. + # Chemical encodings + + This notebook demonstrates the power and usefulness of BayBE's chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables BayBE to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process. + + This notebook assumes some basic familiarity with using BayBE, and that it does not explain all of the core concepts. If you are interested in those, we recommend to first check out the `Reation_Optimization` example. + + /// caution + This notebook was developed for BayBE version 0.14.2. Although we do our best in keeping our breaking changes minimal and support outdated versions for a long time, this notebook might not be immediately applicable for other BayBE versions. If you install BayBE via the instructions in this repository, version 0.14.2 will thus be installed. + /// """) return @@ -33,7 +41,6 @@ def _(mo): ## Introduction In this notebook, we consider a reaction described in the supporting material of a 2020 paper by [Shields et al.](https://www.nature.com/articles/s41586-021-03213-y), in which the following reaction should be optimized: - ` """) return @@ -57,9 +64,7 @@ def _(mo): 4. **Concentration:** We can choose from one of 3 available concentrations. 5. **Temperature:** We can chose from one of 3 available temperatures. - Consequently, this means that we have **1728** different potential experiments that we could run. However, we sould like to identify the optimal conditions with only a small number of experiments. Fortunately, Shields and coworkers have investigated all 1728 combinations and provided a table with the conditions and corresponding yields. - - Note that only 18 out of the 1728 potential experiments have a yield within the top 10 percent! + Consequently, this means that we have **1728** different potential experiments that we could run. Fortunately, Shields and coworkers have investigated all 1728 combinations and provided a table with the conditions and corresponding yields. Note that only 18 out of the 1728 potential experiments have a yield within the top 10 percent! """) return @@ -76,6 +81,8 @@ def _(): @app.cell(hide_code=True) def _(mo): mo.md(r""" + Our goal is to identify one of the top candidates, that is, one of the 18 experiments with a yield larger than 90 using only a few experiments. + We will begin by identifying 10 initial reaction conditions. In practice, we would then run experiments to evaluate these conditions and record the corresponding reaction yields. However, in this case, we will look up the yields in a table. With the conditions and yields in hand, we can build a Bayesian model and use this model to select another 5 reaction conditions. We will then look up the yields for the 5 conditions and use this information to update the model. We will repeat this process through 5 rounds of optimization and examine the reaction yields for each optimization cycle. """) return @@ -88,10 +95,10 @@ def _(mo): Setting up an experimentation campaign with `BayBE` requires us to set up the main components individually. In this notebook, we will set up the following components one after another. - 1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): We start by defining the reaction parameters to be optimized. Each of the 5 parameters described earlier will correspond to exactly one of BayBE's `Parameter`s. - 2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters. - 3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and hence stick to single target optimization. - 4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses Farthest Point Sampling to select a diverse set of initial conditions. If the recommender has data, it uses the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions. + 1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of BayBE's `Parameter`s. + 2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters. + 3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and we hence stick to single target optimization. + 4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`].(https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions. 5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements', which adds a set of experiments and updates the underlying Bayesian model. """) return @@ -108,6 +115,10 @@ def _(mo): The `CategoricalParameter` has a `name` field as well as a `values` field. The `name` is used to describe the parameter, while the `values` are the collection of values that the parameter can take. In addition, one can choose a specific `encoding`. For the sake of this tutorial, we use the `One-Hot-Encoding`, `BayBE`'s default choice for `CategoricalParameter`s. In this tutorial, we model the three different chemical parameters, that is, the solvent, the ligand, and the base as `CategoricalParameters`. Since we have access to the data, we extract the values for the parameters from there, and create the corresponding `CategoricalParameters`. + + /// admonition | Note + As ligand, solvent and base are chmical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. + /// """) return @@ -169,7 +180,7 @@ def _(mo): mo.md(r""" ## Define the [`Target`](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html) & objective - In this example, we want to maximize the yield of the reaction. Since we are only optimizing a single objective, we use the [`SingleTargetObjective`](https://emdgroup.github.io/baybe/0.14.2/userguide/objectives.html#singletargetobjective) and set the `mode` to `"MAX"`. + In this example, we want to maximize the yield of the reaction. Since we are only optimizing a single objective, we use the [`SingleTargetObjective`](https://emdgroup.github.io/baybe/0.14.2/userguide/objectives.html#singletargetobjective) which assumes a maximization of the target as default. """) return @@ -190,25 +201,15 @@ def _(mo): ## Define the [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html) The [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html) selects the next set of experiments to try. - There are many different recommenders offered by `BayBE`, and a lot of ways of combining them. For the sake of this example, we do not use the default initial recommender, but use the [`FPSRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.nonpredictive.sampling.FPSRecommender.html#baybe.recommenders.pure.nonpredictive.sampling.FPSRecommender). This choice ensures that if there is no data available, the recommender uses farthest point sampling to select a diverse set of conditions. If data is available, the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html#baybe.recommenders.pure.bayesian.botorch.BotorchRecommender) is used to balance exploration and exploitation and select the next set of reaction conditions. + There are many different recommenders offered by `BayBE`, and a lot of ways of combining them. For this example, we use the default initial recommender, the [`RandomRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.nonpredictive.sampling.RandomRecommender.html). This recommender samples initial points from the search space randomly. Once it has data available, BayBE will automatically switch to the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html). + + /// admonition | Task + Instead of using the default recommender, use the [`FPSRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.nonpredictive.sampling.FPSRecommender.html). Also, think about which of the two recommenders should be used in this example, and under which circumstances which recommender might be more favourable. + /// """) return -@app.cell -def _(): - from baybe.recommenders import ( - TwoPhaseMetaRecommender, - FPSRecommender, - BotorchRecommender, - ) - - recommender = TwoPhaseMetaRecommender( - initial_recommender=FPSRecommender(), recommender=BotorchRecommender() - ) - return (recommender,) - - @app.cell(hide_code=True) def _(mo): mo.md(r""" @@ -220,11 +221,11 @@ def _(mo): @app.cell -def _(objective, recommender, searchspace): +def _(objective, searchspace): from baybe.campaign import Campaign campaign = Campaign( - searchspace=searchspace, objective=objective, recommender=recommender + searchspace=searchspace, objective=objective ) return (campaign,) @@ -232,9 +233,9 @@ def _(objective, recommender, searchspace): @app.cell(hide_code=True) def _(mo): mo.md(r""" - ## Starting [`the recommendation loop`](https://emdgroup.github.io/baybe/0.14.2/userguide/getting_recommendations.html) + ## Starting [the recommendation loop](https://emdgroup.github.io/baybe/0.14.2/userguide/getting_recommendations.html) - Now that the `campaign` is defined, we can ask it for recommendations. So far, we haven't done any experiments. As such, the `campaign` will use the farthest point sampling to select a diverse set of initial experiments. + Now that the `campaign` is defined, we can ask it for recommendations. So far, we haven't done any experiments. As such, the `campaign` will use random sampling to select a diverse set of initial experiments. """) return @@ -254,7 +255,7 @@ def _(mo): return -@app.cell +@app.cell(hide_code=True) def _(df, initial_rec, pd): merge_columns = [ "Ligand_Name", From 24fdb43a13a3fa7a8b5b1ca5b4bf8a1865a0aa74 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 2 Feb 2026 13:51:49 +0100 Subject: [PATCH 2/9] Fix typo in `chmical` Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- notebooks/Reaction_Optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index e799b05..9e91e1a 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -117,7 +117,7 @@ def _(mo): In this tutorial, we model the three different chemical parameters, that is, the solvent, the ligand, and the base as `CategoricalParameters`. Since we have access to the data, we extract the values for the parameters from there, and create the corresponding `CategoricalParameters`. /// admonition | Note - As ligand, solvent and base are chmical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. + As ligand, solvent and base are chemical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. /// """) return From 066091fa0c9718c8952a686d6e5ecb3e73b78143 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 2 Feb 2026 13:55:06 +0100 Subject: [PATCH 3/9] Remove additional space --- notebooks/Reaction_Optimization.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index 9e91e1a..4063eb7 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -117,7 +117,7 @@ def _(mo): In this tutorial, we model the three different chemical parameters, that is, the solvent, the ligand, and the base as `CategoricalParameters`. Since we have access to the data, we extract the values for the parameters from there, and create the corresponding `CategoricalParameters`. /// admonition | Note - As ligand, solvent and base are chemical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. + As ligand, solvent and base are chemical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. /// """) return From 5674b2043c33cde2bc259866e12004b0ae0d1bcc Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 13:44:49 +0100 Subject: [PATCH 4/9] Include section on chemical encodings --- notebooks/Chemical_Encodings.py | 253 ------------------------- notebooks/Reaction_Optimization.py | 287 +++++++++++++++++++++++++---- 2 files changed, 248 insertions(+), 292 deletions(-) delete mode 100644 notebooks/Chemical_Encodings.py diff --git a/notebooks/Chemical_Encodings.py b/notebooks/Chemical_Encodings.py deleted file mode 100644 index 85a5048..0000000 --- a/notebooks/Chemical_Encodings.py +++ /dev/null @@ -1,253 +0,0 @@ -import marimo - -__generated_with = "0.19.7" -app = marimo.App(width="medium", app_title="Chemical encodings") - - -@app.cell -def _(): - import marimo as mo - import warnings - - warnings.filterwarnings("ignore") - return (mo,) - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - # Chemical encodings - - This file contains some examples related to chemical encodings. - - Note that this example assumes some basic familiarity with using `BayBE`, and that it does not explain all of the core concepts. If you are interested in those, we recommend to first check out the `Reation_Optimization` example. - """) - return - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - ## Setup - - We begin this example by defining a suitable recommender. We use a `TwoPhaseMetaRecommender` equipped with a `BotorchRecommender`. We also use use a specific kernel that is suited particularly well for chemical problems - the [`EDBOKernel`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.surrogates.gaussian_process.presets.edbo.EDBOKernelFactory.html#baybe.surrogates.gaussian_process.presets.edbo.EDBOKernelFactory). - """) - return - - -@app.cell -def _(): - from baybe.surrogates.gaussian_process.presets.edbo import EDBOKernelFactory - from baybe.recommenders import TwoPhaseMetaRecommender, BotorchRecommender - from baybe.surrogates import GaussianProcessSurrogate - - recommender = TwoPhaseMetaRecommender( - recommender=BotorchRecommender( - surrogate_model=GaussianProcessSurrogate( - kernel_or_factory=EDBOKernelFactory() - ) - ) - ) - return (recommender,) - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - This examples uses the same basic example like the `Reaction_Optimization` notebook. However, we now use different encodings of the chemical parameters. The encoding that should be used can be described by the `encoding` field. We investigate three different encodings here and create one campaign per chemical encoding. - """) - return - - -@app.cell -def _(): - import pandas as pd - - from utils import create_dict_from_columns - - df = pd.read_csv("data/shields.csv") - - substances = { - "bases": create_dict_from_columns(df, "Base_Name", "Base_SMILES"), - "ligands": create_dict_from_columns(df, "Ligand_Name", "Ligand_SMILES"), - "solvents": create_dict_from_columns(df, "Solvent_Name", "Solvent_SMILES"), - } - return df, substances - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - Now that we have the data collected, we can create different campaigns that we want to compare against each other. To facilitate the usage of `BayBE`'s simulation capabilities, we collect the different campaigns in a `dict`. - """) - return - - -@app.cell -def _(df, recommender, substances): - from baybe import Campaign - from baybe.parameters import ( - CategoricalParameter, - NumericalDiscreteParameter, - SubstanceParameter, - ) - from baybe.parameters import CategoricalParameter - from baybe.searchspace import SearchSpace - from baybe.targets import NumericalTarget - - objective = NumericalTarget(name="yield").to_objective() - - substance_encodings = ["MORDRED", "ECFP", "RDKIT2DDESCRIPTORS"] - scenarios = { - encoding: Campaign( - searchspace=SearchSpace.from_product( - parameters=[ - SubstanceParameter( - name="Solvent_Name", - data=substances["solvents"], - encoding=encoding, - ), - SubstanceParameter( - name="Base_Name", data=substances["bases"], encoding=encoding - ), - SubstanceParameter( - name="Ligand_Name", - data=substances["ligands"], - encoding=encoding, - ), - NumericalDiscreteParameter( - values=df["Concentration"].unique(), name="Concentration" - ), - NumericalDiscreteParameter( - values=df["Temp_C"].unique(), name="Temp_C" - ), - ] - ), - objective=objective, - recommender=recommender, - ) - for encoding in substance_encodings - } - return ( - Campaign, - CategoricalParameter, - NumericalDiscreteParameter, - SearchSpace, - objective, - scenarios, - ) - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - Of course, we also want to compare the campaigns using the chemical encodings to other campaigns not using the special encoding. - """) - return - - -@app.cell -def _( - Campaign, - CategoricalParameter, - NumericalDiscreteParameter, - SearchSpace, - objective, - scenarios, - substances, -): - ohe_parameters = [ - CategoricalParameter( - name="Solvent_Name", values=substances["solvents"], encoding="OHE" - ), - CategoricalParameter( - name="Base_Name", values=substances["bases"], encoding="OHE" - ), - CategoricalParameter( - name="Ligand_Name", values=substances["ligands"], encoding="OHE" - ), - NumericalDiscreteParameter(name="Temp_C", values=[90, 105, 120]), - NumericalDiscreteParameter(name="Concentration", values=[0.057, 0.1, 0.153]), - ] - campaign_ohe = Campaign( - searchspace=SearchSpace.from_product(parameters=ohe_parameters), - objective=objective, - ) - scenarios["OHE"] = campaign_ohe - return - - -@app.cell(hide_code=True) -def _(mo): - mo.md(r""" - ## Using `BayBE`'s [simulation capabilities](https://emdgroup.github.io/baybe/0.14.2/userguide/simulation.html) - - `BayBE` offers multiple functionalities to “simulate” experimental campaigns with a given lookup mechanism. `BayBE`’s simulation package enables a wide range of use cases and can even be used for “oracle predictions”. This is made possible through the flexible use of lookup mechanisms, which act as the loop-closing element of an optimization loop. - - Lookups can be provided in a variety of ways, by using fixed data sets, analytical functions, or any other form of black-box callable. In all cases, their role is the same: to retrieve target values for parameter configurations suggested by the recommendation engine. - - In our case, we can directly use the data that we stored in the `df` dataframe and do the simulation. - """) - return - - -@app.cell -def _(df, scenarios): - from baybe.simulation import simulate_scenarios - - BATCH_SIZE = 2 - N_DOE_ITERATIONS = 10 # Change to ~15 for better plots - N_MC_ITERATIONS = 15 # Change to ~25 for better plots - - results = simulate_scenarios( - scenarios, - df, - batch_size=BATCH_SIZE, - n_doe_iterations=N_DOE_ITERATIONS, - n_mc_iterations=N_MC_ITERATIONS, - ) - - results.rename( - columns={ - "Scenario": "Substance encoding", - "Num_Experiments": "Number of experiments", - "yield_CumBest": "Running best yield", - }, - inplace=True, - ) - return (results,) - - -@app.cell(hide_code=True) -def _(mo): - mo.md(""" - We now visualize the results using the `backtest_plot` utility. This utility "averages" the individual Monte Carlo iterations and shows the mean and a confidence interval. It can also be used to give visual guidance on the performance of individual scenarios. - """) - return - - -@app.cell -def _(mo, results): - from utils import backtest_plot - import matplotlib.pyplot as plt - - backtest_plot( - df=results, - x="Number of experiments", - y="Running best yield", - hue="Substance encoding", - indicator_y=90, - indicator_labels=["MORDRED"], - ) - mo.mpl.interactive(plt.gcf()) - return (plt,) - - -@app.cell -def _(plt): - plt.close() - return - - -if __name__ == "__main__": - app.run() diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index 4063eb7..ff0895f 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -16,20 +16,16 @@ def _(): @app.cell(hide_code=True) def _(mo): mo.md(r""" - # Using BayBE to optimize Reaction Conditions + # Using `BayBE` to optimize Reaction Conditions - This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of BayBE. + This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of `BayBE`. - In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use BayBE to model and optimize such a campaign. + In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use `BayBE` to model and optimize such a campaign. + In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process. - # Chemical encodings - - This notebook demonstrates the power and usefulness of BayBE's chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables BayBE to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process. - - This notebook assumes some basic familiarity with using BayBE, and that it does not explain all of the core concepts. If you are interested in those, we recommend to first check out the `Reation_Optimization` example. /// caution - This notebook was developed for BayBE version 0.14.2. Although we do our best in keeping our breaking changes minimal and support outdated versions for a long time, this notebook might not be immediately applicable for other BayBE versions. If you install BayBE via the instructions in this repository, version 0.14.2 will thus be installed. + This notebook was developed for `BayBE` version 0.14.2. Although we do our best in keeping our breaking changes minimal and support outdated versions for a long time, this notebook might not be immediately applicable for other `BayBE` versions. If you install `BayBE` via the instructions in this repository, version 0.14.2 will thus be installed. /// """) return @@ -72,10 +68,17 @@ def _(mo): @app.cell(hide_code=True) def _(): import pandas as pd + from utils import create_dict_from_columns df = pd.read_csv("data/shields.csv") + + # Extract SMILES data for all chemical substances + solvents_dict = create_dict_from_columns(df, "Solvent_Name", "Solvent_SMILES") + ligands_dict = create_dict_from_columns(df, "Ligand_Name", "Ligand_SMILES") + bases_dict = create_dict_from_columns(df, "Base_Name", "Base_SMILES") + df - return df, pd + return bases_dict, df, ligands_dict, pd, solvents_dict @app.cell(hide_code=True) @@ -95,11 +98,11 @@ def _(mo): Setting up an experimentation campaign with `BayBE` requires us to set up the main components individually. In this notebook, we will set up the following components one after another. - 1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of BayBE's `Parameter`s. + 1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of `BayBE`'s `Parameter`s. 2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters. 3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and we hence stick to single target optimization. - 4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`].(https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions. - 5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements', which adds a set of experiments and updates the underlying Bayesian model. + 4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions. + 5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model. """) return @@ -109,30 +112,35 @@ def _(mo): mo.md(""" ## Defining the [`Parameters`](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html) - In this section, we introduce two different parameter types: The [`CategoricalParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.categorical.CategoricalParameter.html) and the [`NumericalDiscreteParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.numerical.NumericalDiscreteParameter.html). - - - The `CategoricalParameter` has a `name` field as well as a `values` field. The `name` is used to describe the parameter, while the `values` are the collection of values that the parameter can take. In addition, one can choose a specific `encoding`. For the sake of this tutorial, we use the `One-Hot-Encoding`, `BayBE`'s default choice for `CategoricalParameter`s. + In this section, we introduce two different parameter types: The [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html) and the [`NumericalDiscreteParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.numerical.NumericalDiscreteParameter.html). - In this tutorial, we model the three different chemical parameters, that is, the solvent, the ligand, and the base as `CategoricalParameters`. Since we have access to the data, we extract the values for the parameters from there, and create the corresponding `CategoricalParameters`. + The `SubstanceParameter` is specifically designed for chemical substances and can automatically use meaningful chemical descriptors. It takes a `name` field and a `data` dictionary mapping substance names to their SMILES representations. One can also choose a specific chemical `encoding` such as MORDRED, ECFP, or RDKIT2DDESCRIPTORS. - /// admonition | Note - As ligand, solvent and base are chemical substances, they should preferably be modeled using the [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html). This is not done in this example for simplicity. We refer to the `Chemical_Encodings` example for a tutorial on using `SubstanceParameter`s and a demonstration of its effect. - /// + In this tutorial, we model all three chemical parameters (ligand, solvent, and base) as `SubstanceParameter`s to leverage chemical knowledge in the optimization process. Since we have access to the SMILES data, we extract the mappings from the data and create the corresponding `SubstanceParameter`s. """) return @app.cell -def _(df): - from baybe.parameters import CategoricalParameter +def _(bases_dict, ligands_dict, solvents_dict): + from baybe.parameters import SubstanceParameter - ligand = CategoricalParameter(values=df["Ligand_Name"].unique(), name="Ligand_Name") - solvent = CategoricalParameter( - values=df["Solvent_Name"].unique(), name="Solvent_Name" + ligand = SubstanceParameter( + name="Ligand_Name", + data=ligands_dict, + encoding="MORDRED" + ) + solvent = SubstanceParameter( + name="Solvent_Name", + data=solvents_dict, + encoding="MORDRED" + ) + base = SubstanceParameter( + name="Base_Name", + data=bases_dict, + encoding="MORDRED" ) - base = CategoricalParameter(values=df["Base_Name"].unique(), name="Base_Name") - return base, ligand, solvent + return SubstanceParameter, base, ligand, solvent @app.cell(hide_code=True) @@ -153,7 +161,7 @@ def _(df): temperature = NumericalDiscreteParameter( values=df["Temp_C"].unique(), name="Temp_C" ) - return concentration, temperature + return NumericalDiscreteParameter, concentration, temperature @app.cell(hide_code=True) @@ -172,7 +180,7 @@ def _(base, concentration, ligand, solvent, temperature): parameters = [ligand, solvent, base, concentration, temperature] searchspace = SearchSpace.from_product(parameters=parameters) - return (searchspace,) + return SearchSpace, searchspace @app.cell(hide_code=True) @@ -201,15 +209,27 @@ def _(mo): ## Define the [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html) The [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html) selects the next set of experiments to try. - There are many different recommenders offered by `BayBE`, and a lot of ways of combining them. For this example, we use the default initial recommender, the [`RandomRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.nonpredictive.sampling.RandomRecommender.html). This recommender samples initial points from the search space randomly. Once it has data available, BayBE will automatically switch to the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html). - - /// admonition | Task - Instead of using the default recommender, use the [`FPSRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.nonpredictive.sampling.FPSRecommender.html). Also, think about which of the two recommenders should be used in this example, and under which circumstances which recommender might be more favourable. - /// + There are many different recommenders offered by `BayBE`, and a lot of ways of combining them. For this example, we use a [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html) equipped with a [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html) that uses the [`EDBOKernel`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.surrogates.gaussian_process.presets.edbo.EDBOKernelFactory.html). The EDBO kernel is particularly well-suited for chemical optimization problems as it was specifically designed to handle chemical descriptors effectively. """) return +@app.cell +def _(): + from baybe.surrogates.gaussian_process.presets.edbo import EDBOKernelFactory + from baybe.recommenders import TwoPhaseMetaRecommender, BotorchRecommender + from baybe.surrogates import GaussianProcessSurrogate + + recommender = TwoPhaseMetaRecommender( + recommender=BotorchRecommender( + surrogate_model=GaussianProcessSurrogate( + kernel_or_factory=EDBOKernelFactory() + ) + ) + ) + return (recommender,) + + @app.cell(hide_code=True) def _(mo): mo.md(r""" @@ -221,13 +241,13 @@ def _(mo): @app.cell -def _(objective, searchspace): +def _(objective, recommender, searchspace): from baybe.campaign import Campaign campaign = Campaign( - searchspace=searchspace, objective=objective + searchspace=searchspace, objective=objective, recommender=recommender ) - return (campaign,) + return Campaign, campaign @app.cell(hide_code=True) @@ -331,10 +351,199 @@ def _(campaign): @app.cell(hide_code=True) def _(mo): mo.md(""" - As we can see, we found a very good candidate, and only needed to evaluate a fraction of the search space! This insight concludes this basic BayBE tutorial. + As we can see, we found a very good candidate, and only needed to evaluate a fraction of the search space! + """) + return + + +@app.cell(hide_code=True) +def _(mo): + mo.md(r""" + ## Investigating Different Chemical Encodings + + Now that we've seen how to use `BayBE` for reaction optimization with chemical encodings, let's investigate how different chemical encodings affect the optimization performance. BayBE supports multiple chemical encodings for `SubstanceParameter`s, each capturing different aspects of molecular structure. + + We'll compare three different chemical encodings as well as the One-Hot-Encoding by running simulated optimization campaigns and visualizing their performance. + """) + return + + +@app.cell(hide_code=True) +def _(mo): + mo.md(""" + We create multiple campaigns, one for each encoding we want to compare. Each campaign will use `SubstanceParameter`s for all three chemical parameters (solvent, ligand, and base) with the specified encoding: + """) + return + + +@app.cell +def _( + Campaign, + NumericalDiscreteParameter, + SearchSpace, + SubstanceParameter, + bases_dict, + df, + ligands_dict, + objective, + recommender, + solvents_dict, +): + substance_encodings = ["MORDRED", "ECFP", "RDKIT2DDESCRIPTORS"] + scenarios = { + encoding: Campaign( + searchspace=SearchSpace.from_product( + parameters=[ + SubstanceParameter( + name="Solvent_Name", + data=solvents_dict, + encoding=encoding, + ), + SubstanceParameter( + name="Base_Name", + data=bases_dict, + encoding=encoding, + ), + SubstanceParameter( + name="Ligand_Name", + data=ligands_dict, + encoding=encoding, + ), + NumericalDiscreteParameter( + values=df["Concentration"].unique(), name="Concentration" + ), + NumericalDiscreteParameter( + values=df["Temp_C"].unique(), name="Temp_C" + ), + ] + ), + objective=objective, + recommender=recommender, + ) + for encoding in substance_encodings + } + return (scenarios,) + + +@app.cell(hide_code=True) +def _(mo): + mo.md(""" + We also want to compare the campaigns using chemical encodings to a baseline campaign that uses One-Hot Encoding (OHE) with `CategoricalParameter`s for all chemical parameters: + """) + return + + +@app.cell +def _( + Campaign, + NumericalDiscreteParameter, + SearchSpace, + df, + objective, + recommender, + scenarios, +): + from baybe.parameters import CategoricalParameter + + ohe_parameters = [ + CategoricalParameter( + name="Solvent_Name", values=df["Solvent_Name"].unique(), encoding="OHE" + ), + CategoricalParameter( + name="Base_Name", values=df["Base_Name"].unique(), encoding="OHE" + ), + CategoricalParameter( + name="Ligand_Name", values=df["Ligand_Name"].unique(), encoding="OHE" + ), + NumericalDiscreteParameter(name="Temp_C", values=[90, 105, 120]), + NumericalDiscreteParameter(name="Concentration", values=[0.057, 0.1, 0.153]), + ] + campaign_ohe = Campaign( + searchspace=SearchSpace.from_product(parameters=ohe_parameters), + objective=objective, + recommender=recommender, + ) + scenarios["OHE"] = campaign_ohe + return + + +@app.cell(hide_code=True) +def _(mo): + mo.md(r""" + ### Using BayBE's [simulation capabilities](https://emdgroup.github.io/baybe/0.14.2/userguide/simulation.html) + + BayBE offers powerful simulation capabilities that allow us to compare different optimization strategies without running actual experiments. The simulation uses a lookup mechanism to retrieve target values from our dataset, effectively simulating multiple optimization campaigns with different random seeds (Monte Carlo iterations). + + Let's run the simulation with multiple Monte Carlo iterations to get statistically meaningful results: + """) + return + + +@app.cell +def _(df, scenarios): + from baybe.simulation import simulate_scenarios + + BATCH_SIZE = 2 + N_DOE_ITERATIONS = 5 # Change to ~20 for better plots + N_MC_ITERATIONS = 10 # Change to ~30 for better plots + + results = simulate_scenarios( + scenarios, + df, + batch_size=BATCH_SIZE, + n_doe_iterations=N_DOE_ITERATIONS, + n_mc_iterations=N_MC_ITERATIONS, + ) + + results.rename( + columns={ + "Scenario": "Substance encoding", + "Num_Experiments": "Number of experiments", + "yield_CumBest": "Running best yield", + }, + inplace=True, + ) + return (results,) + + +@app.cell(hide_code=True) +def _(mo): + mo.md(""" + ### Visualizing the Results + + Now let's visualize the results using the `backtest_plot` utility. This plot shows: + - The mean performance across Monte Carlo iterations (solid line) + - Confidence intervals (shaded regions) + - A horizontal guideline at 90% yield (our target threshold) + - Vertical guidelines showing when the `MORDRED` and `OHE` encoding reach the target. + + The plot shows that using the `SubstanceParameter` and hence equipping `BayBE` with chemical knowledge significantly improves the performance. """) return +@app.cell +def _(mo, results): + from utils import backtest_plot + import matplotlib.pyplot as plt + + backtest_plot( + df=results, + x="Number of experiments", + y="Running best yield", + hue="Substance encoding", + indicator_y=90, + indicator_labels=["MORDRED", "OHE"], + ) + mo.mpl.interactive(plt.gcf()) + return (plt,) + + +@app.cell +def _(plt): + plt.close() + return + + if __name__ == "__main__": app.run() From d7aedd1a9659c6018a1931fe9995f168a23bcc09 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 13:53:23 +0100 Subject: [PATCH 5/9] Add jupyter notebook version --- notebooks/Reaction_Optimization.ipynb | 2159 +++++++++++++++++++++++++ 1 file changed, 2159 insertions(+) create mode 100644 notebooks/Reaction_Optimization.ipynb diff --git a/notebooks/Reaction_Optimization.ipynb b/notebooks/Reaction_Optimization.ipynb new file mode 100644 index 0000000..81f936a --- /dev/null +++ b/notebooks/Reaction_Optimization.ipynb @@ -0,0 +1,2159 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "MJUe", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "# Using `BayBE` to optimize Reaction Conditions\n", + "\n", + "This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of `BayBE`.\n", + "\n", + "In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use `BayBE` to model and optimize such a campaign.\n", + "In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process.\n", + "\n", + "**Caution**\n", + "This notebook was developed for `BayBE` version 0.14.2. Although we do our best in keeping our breaking changes minimal and support outdated versions for a long time, this notebook might not be immediately applicable for other `BayBE` versions. If you install `BayBE` via the instructions in this repository, version 0.14.2 will thus be installed." + ] + }, + { + "cell_type": "markdown", + "id": "4d8fa07a", + "metadata": {}, + "source": [ + "## Installation\n", + "\n", + "To install `BayBE` in AWS SageMaker, make sure that you have the `conda_python3` kernel activated. Then, run the following cell to install all required packagages.\n", + "Note that this might take some minutes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2cd7003e", + "metadata": {}, + "outputs": [], + "source": [ + "%mamba install h5py\n", + "%pip install baybe[chem,simulation]==0.14.2 seaborn" + ] + }, + { + "cell_type": "markdown", + "id": "vblA", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Introduction\n", + "\n", + "In this notebook, we consider a reaction described in the supporting material of a 2020 paper by [Shields et al.](https://www.nature.com/articles/s41586-021-03213-y), in which the following reaction should be optimized:" + ] + }, + { + "cell_type": "markdown", + "id": "bkHC", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + }, + "vscode": { + "languageId": "bat" + } + }, + "source": [ + "![Optimized Reaction](../images/reaction.svg)" + ] + }, + { + "cell_type": "markdown", + "id": "lEQa", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "We can vary 5 different parameters in this experiment:\n", + "\n", + "1. **Ligand**: We are given a list of 12 different ligands that we can choose from.\n", + "2. **Base:** We have 4 different bases available for our experiment.\n", + "3. **Solvent**: We can use one of 4 available solvents.\n", + "4. **Concentration:** We can choose from one of 3 available concentrations.\n", + "5. **Temperature:** We can chose from one of 3 available temperatures.\n", + "\n", + "Consequently, this means that we have **1728** different potential experiments that we could run. Fortunately, Shields and coworkers have investigated all 1728 combinations and provided a table with the conditions and corresponding yields. Note that only 18 out of the 1728 potential experiments have a yield within the top 10 percent!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "PKri", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
entryBase_SMILESLigand_SMILESSolvent_SMILESConcentrationTemp_CyieldBase_NameLigand_NameSolvent_Name
00O=C([O-])C.[K+]CC(C)C1=CC(C(C)C)=C(C(C(C)C)=C1)C2=C(P(C3CCCCC...CC(N(C)C)=O0.1001055.47Potassium acetateBrettPhosDMAc
11O=C([O-])C.[K+]CC(C)(C)P(C1=CC=CC=C1)C(C)(C)CCC(N(C)C)=O0.1001050.00Potassium acetateDi-tert-butylphenylphosphineDMAc
22O=C([O-])C.[K+]CN(C)C1=CC=CC(N(C)C)=C1C2=CC=CC=C2P(C(C)(C)C)C...CC(N(C)C)=O0.10010578.95Potassium acetate(t-Bu)PhCPhosDMAc
33O=C([O-])C.[K+]P(C1CCCCC1)(C2CCCCC2)C3CCCCC3CC(N(C)C)=O0.1001057.26Potassium acetateTricyclohexylphosphineDMAc
44O=C([O-])C.[K+]P(C1=CC=CC=C1)(C2=CC=CC=C2)C3=CC=CC=C3CC(N(C)C)=O0.10010528.15Potassium acetatePPh3DMAc
.................................
17231723O=C([O-])C(C)(C)C.[Cs+]CP(C1=CC=CC=C1)C2=CC=CC=C2CC1=CC=C(C)C=C10.1531201.60Cesium pivalateMethyldiphenylphosphinep-Xylene
17241724O=C([O-])C(C)(C)C.[Cs+]CC(OC1=C(P(C2CCCCC2)C3CCCCC3)C(OC(C)C)=CC=C1)CCC1=CC=C(C)C=C10.1531208.39Cesium pivalate1268824-69-6p-Xylene
17251725O=C([O-])C(C)(C)C.[Cs+]FC(F)(F)C1=CC(P(C2=C(C3=C(C(C)C)C=C(C(C)C)C=C3...CC1=CC=C(C)C=C10.15312013.34Cesium pivalateJackiePhosp-Xylene
17261726O=C([O-])C(C)(C)C.[Cs+]C[C@]1(O2)O[C@](C[C@]2(C)P3C4=CC=CC=C4)(C)O[C@...CC1=CC=C(C)C=C10.15312019.13Cesium pivalateSCHEMBL15068049p-Xylene
17271727O=C([O-])C(C)(C)C.[Cs+]CP(C)C1=CC=CC=C1CC1=CC=C(C)C=C10.1531200.00Cesium pivalateMe2PPhp-Xylene
\n", + "

1728 rows × 10 columns

\n", + "
" + ], + "text/plain": [ + " entry Base_SMILES \\\n", + "0 0 O=C([O-])C.[K+] \n", + "1 1 O=C([O-])C.[K+] \n", + "2 2 O=C([O-])C.[K+] \n", + "3 3 O=C([O-])C.[K+] \n", + "4 4 O=C([O-])C.[K+] \n", + "... ... ... \n", + "1723 1723 O=C([O-])C(C)(C)C.[Cs+] \n", + "1724 1724 O=C([O-])C(C)(C)C.[Cs+] \n", + "1725 1725 O=C([O-])C(C)(C)C.[Cs+] \n", + "1726 1726 O=C([O-])C(C)(C)C.[Cs+] \n", + "1727 1727 O=C([O-])C(C)(C)C.[Cs+] \n", + "\n", + " Ligand_SMILES Solvent_SMILES \\\n", + "0 CC(C)C1=CC(C(C)C)=C(C(C(C)C)=C1)C2=C(P(C3CCCCC... CC(N(C)C)=O \n", + "1 CC(C)(C)P(C1=CC=CC=C1)C(C)(C)C CC(N(C)C)=O \n", + "2 CN(C)C1=CC=CC(N(C)C)=C1C2=CC=CC=C2P(C(C)(C)C)C... CC(N(C)C)=O \n", + "3 P(C1CCCCC1)(C2CCCCC2)C3CCCCC3 CC(N(C)C)=O \n", + "4 P(C1=CC=CC=C1)(C2=CC=CC=C2)C3=CC=CC=C3 CC(N(C)C)=O \n", + "... ... ... \n", + "1723 CP(C1=CC=CC=C1)C2=CC=CC=C2 CC1=CC=C(C)C=C1 \n", + "1724 CC(OC1=C(P(C2CCCCC2)C3CCCCC3)C(OC(C)C)=CC=C1)C CC1=CC=C(C)C=C1 \n", + "1725 FC(F)(F)C1=CC(P(C2=C(C3=C(C(C)C)C=C(C(C)C)C=C3... CC1=CC=C(C)C=C1 \n", + "1726 C[C@]1(O2)O[C@](C[C@]2(C)P3C4=CC=CC=C4)(C)O[C@... CC1=CC=C(C)C=C1 \n", + "1727 CP(C)C1=CC=CC=C1 CC1=CC=C(C)C=C1 \n", + "\n", + " Concentration Temp_C yield Base_Name \\\n", + "0 0.100 105 5.47 Potassium acetate \n", + "1 0.100 105 0.00 Potassium acetate \n", + "2 0.100 105 78.95 Potassium acetate \n", + "3 0.100 105 7.26 Potassium acetate \n", + "4 0.100 105 28.15 Potassium acetate \n", + "... ... ... ... ... \n", + "1723 0.153 120 1.60 Cesium pivalate \n", + "1724 0.153 120 8.39 Cesium pivalate \n", + "1725 0.153 120 13.34 Cesium pivalate \n", + "1726 0.153 120 19.13 Cesium pivalate \n", + "1727 0.153 120 0.00 Cesium pivalate \n", + "\n", + " Ligand_Name Solvent_Name \n", + "0 BrettPhos DMAc \n", + "1 Di-tert-butylphenylphosphine DMAc \n", + "2 (t-Bu)PhCPhos DMAc \n", + "3 Tricyclohexylphosphine DMAc \n", + "4 PPh3 DMAc \n", + "... ... ... \n", + "1723 Methyldiphenylphosphine p-Xylene \n", + "1724 1268824-69-6 p-Xylene \n", + "1725 JackiePhos p-Xylene \n", + "1726 SCHEMBL15068049 p-Xylene \n", + "1727 Me2PPh p-Xylene \n", + "\n", + "[1728 rows x 10 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "from utils import create_dict_from_columns\n", + "\n", + "df = pd.read_csv(\"../data/shields.csv\")\n", + "\n", + "# Extract SMILES data for all chemical substances\n", + "solvents_dict = create_dict_from_columns(df, \"Solvent_Name\", \"Solvent_SMILES\")\n", + "ligands_dict = create_dict_from_columns(df, \"Ligand_Name\", \"Ligand_SMILES\")\n", + "bases_dict = create_dict_from_columns(df, \"Base_Name\", \"Base_SMILES\")\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "Xref", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "Our goal is to identify one of the top candidates, that is, one of the 18 experiments with a yield larger than 90 using only a few experiments.\n", + "\n", + "We will begin by identifying 10 initial reaction conditions. In practice, we would then run experiments to evaluate these conditions and record the corresponding reaction yields. However, in this case, we will look up the yields in a table. With the conditions and yields in hand, we can build a Bayesian model and use this model to select another 5 reaction conditions. We will then look up the yields for the 5 conditions and use this information to update the model. We will repeat this process through 5 rounds of optimization and examine the reaction yields for each optimization cycle." + ] + }, + { + "cell_type": "markdown", + "id": "SFPL", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Overview\n", + "\n", + "Setting up an experimentation campaign with `BayBE` requires us to set up the main components individually. In this notebook, we will set up the following components one after another.\n", + "\n", + "1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of `BayBE`'s `Parameter`s.\n", + "2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters.\n", + "3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and we hence stick to single target optimization.\n", + "4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions.\n", + "5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model." + ] + }, + { + "cell_type": "markdown", + "id": "BYtC", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Defining the [`Parameters`](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html)\n", + "\n", + "In this section, we introduce two different parameter types: The [`SubstanceParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.substance.SubstanceParameter.html) and the [`NumericalDiscreteParameter`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.parameters.numerical.NumericalDiscreteParameter.html).\n", + "\n", + "The `SubstanceParameter` is specifically designed for chemical substances and can automatically use meaningful chemical descriptors. It takes a `name` field and a `data` dictionary mapping substance names to their SMILES representations. One can also choose a specific chemical `encoding` such as MORDRED, ECFP, or RDKIT2DDESCRIPTORS.\n", + "\n", + "In this tutorial, we model all three chemical parameters (ligand, solvent, and base) as `SubstanceParameter`s to leverage chemical knowledge in the optimization process. Since we have access to the SMILES data, we extract the mappings from the data and create the corresponding `SubstanceParameter`s." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "RGSE", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.parameters import SubstanceParameter\n", + "\n", + "ligand = SubstanceParameter(\n", + " name=\"Ligand_Name\",\n", + " data=ligands_dict,\n", + " encoding=\"MORDRED\"\n", + ")\n", + "solvent = SubstanceParameter(\n", + " name=\"Solvent_Name\",\n", + " data=solvents_dict,\n", + " encoding=\"MORDRED\"\n", + ")\n", + "base = SubstanceParameter(\n", + " name=\"Base_Name\",\n", + " data=bases_dict,\n", + " encoding=\"MORDRED\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "Kclp", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "The `NumericalDiscreteParameter` is another `DiscreteParameter` and is intended to be used for parameters that have numerical values." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "emfo", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.parameters import NumericalDiscreteParameter\n", + "\n", + "concentration = NumericalDiscreteParameter(\n", + " values=df[\"Concentration\"].unique(), name=\"Concentration\"\n", + ")\n", + "temperature = NumericalDiscreteParameter(\n", + " values=df[\"Temp_C\"].unique(), name=\"Temp_C\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "Hstk", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Define the [`SearchSpace`](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html)\n", + "\n", + "The parameters are now combined into a [`SearchSpace`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.searchspace.html) object. Using the [`SearchSpace.from_product`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.searchspace.core.SearchSpace.html#baybe.searchspace.core.SearchSpace.from_product) constructor, we construct the cartesian product of the parameters that we defined previously." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "nWHF", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.searchspace import SearchSpace\n", + "\n", + "parameters = [ligand, solvent, base, concentration, temperature]\n", + "searchspace = SearchSpace.from_product(parameters=parameters)" + ] + }, + { + "cell_type": "markdown", + "id": "iLit", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Define the [`Target`](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html) & objective\n", + "\n", + "In this example, we want to maximize the yield of the reaction. Since we are only optimizing a single objective, we use the [`SingleTargetObjective`](https://emdgroup.github.io/baybe/0.14.2/userguide/objectives.html#singletargetobjective) which assumes a maximization of the target as default." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ZHCJ", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.targets import NumericalTarget\n", + "from baybe.objectives import SingleTargetObjective\n", + "\n", + "target = NumericalTarget(name=\"yield\")\n", + "objective = SingleTargetObjective(target=target)" + ] + }, + { + "cell_type": "markdown", + "id": "ROlb", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Define the [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html)\n", + "\n", + "The [`Recommender`](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html) selects the next set of experiments to try.\n", + "There are many different recommenders offered by `BayBE`, and a lot of ways of combining them. For this example, we use a [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html) equipped with a [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html) that uses the [`EDBOKernel`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.surrogates.gaussian_process.presets.edbo.EDBOKernelFactory.html). The EDBO kernel is particularly well-suited for chemical optimization problems as it was specifically designed to handle chemical descriptors effectively." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "qnkX", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.surrogates.gaussian_process.presets.edbo import EDBOKernelFactory\n", + "from baybe.recommenders import TwoPhaseMetaRecommender, BotorchRecommender\n", + "from baybe.surrogates import GaussianProcessSurrogate\n", + "\n", + "recommender = TwoPhaseMetaRecommender(\n", + " recommender=BotorchRecommender(\n", + " surrogate_model=GaussianProcessSurrogate(\n", + " kernel_or_factory=EDBOKernelFactory()\n", + " )\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "TqIu", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Define the [`Campaign`](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html)\n", + "\n", + "Now, we combine all of the individual pieces into one of the core concepts of `BayBE` - the `campaign` object. This object is responsible for organizing and managing an experimental campaign." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "Vxnm", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.campaign import Campaign\n", + "\n", + "campaign = Campaign(\n", + " searchspace=searchspace, objective=objective, recommender=recommender\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "DnEU", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Starting [the recommendation loop](https://emdgroup.github.io/baybe/0.14.2/userguide/getting_recommendations.html)\n", + "\n", + "Now that the `campaign` is defined, we can ask it for recommendations. So far, we haven't done any experiments. As such, the `campaign` will use random sampling to select a diverse set of initial experiments." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ulZA", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_C
1304SCHEMBL15068049Butyl EsterCesium acetate0.153120.0
2681268824-69-6p-XyleneCesium pivalate0.153105.0
1370SCHEMBL15068049DMAcCesium acetate0.057120.0
1459TricyclohexylphosphineButyl EsterPotassium acetate0.057105.0
381BrettPhosDMAcPotassium acetate0.10090.0
561Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.0
70(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.0
1085P(2-furyl)3DMAcCesium acetate0.100120.0
68(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.0
97(t-Bu)PhCPhosDMAcPotassium acetate0.153105.0
\n", + "
" + ], + "text/plain": [ + " Ligand_Name Solvent_Name Base_Name \\\n", + "1304 SCHEMBL15068049 Butyl Ester Cesium acetate \n", + "268 1268824-69-6 p-Xylene Cesium pivalate \n", + "1370 SCHEMBL15068049 DMAc Cesium acetate \n", + "1459 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", + "381 BrettPhos DMAc Potassium acetate \n", + "561 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", + "70 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "1085 P(2-furyl)3 DMAc Cesium acetate \n", + "68 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "97 (t-Bu)PhCPhos DMAc Potassium acetate \n", + "\n", + " Concentration Temp_C \n", + "1304 0.153 120.0 \n", + "268 0.153 105.0 \n", + "1370 0.057 120.0 \n", + "1459 0.057 105.0 \n", + "381 0.100 90.0 \n", + "561 0.100 90.0 \n", + "70 0.153 105.0 \n", + "1085 0.100 120.0 \n", + "68 0.100 120.0 \n", + "97 0.153 105.0 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_rec = campaign.recommend(batch_size=10)\n", + "initial_rec" + ] + }, + { + "cell_type": "markdown", + "id": "ecfG", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "At this point, we would typically perform a set of experiments using the 10 recommendations provided by the `campaign`. In this tutorial, we simply grab the yield from the data." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "Pvdt", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_Cyield
0SCHEMBL15068049Butyl EsterCesium acetate0.153120.062.33
11268824-69-6p-XyleneCesium pivalate0.153105.04.53
2SCHEMBL15068049DMAcCesium acetate0.057120.095.48
3TricyclohexylphosphineButyl EsterPotassium acetate0.057105.00.00
4BrettPhosDMAcPotassium acetate0.10090.05.22
5Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.00.00
6(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.010.05
7P(2-furyl)3DMAcCesium acetate0.100120.029.06
8(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.06.44
9(t-Bu)PhCPhosDMAcPotassium acetate0.153105.057.33
\n", + "
" + ], + "text/plain": [ + " Ligand_Name Solvent_Name Base_Name \\\n", + "0 SCHEMBL15068049 Butyl Ester Cesium acetate \n", + "1 1268824-69-6 p-Xylene Cesium pivalate \n", + "2 SCHEMBL15068049 DMAc Cesium acetate \n", + "3 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", + "4 BrettPhos DMAc Potassium acetate \n", + "5 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", + "6 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "7 P(2-furyl)3 DMAc Cesium acetate \n", + "8 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "9 (t-Bu)PhCPhos DMAc Potassium acetate \n", + "\n", + " Concentration Temp_C yield \n", + "0 0.153 120.0 62.33 \n", + "1 0.153 105.0 4.53 \n", + "2 0.057 120.0 95.48 \n", + "3 0.057 105.0 0.00 \n", + "4 0.100 90.0 5.22 \n", + "5 0.100 90.0 0.00 \n", + "6 0.153 105.0 10.05 \n", + "7 0.100 120.0 29.06 \n", + "8 0.100 120.0 6.44 \n", + "9 0.153 105.0 57.33 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merge_columns = [\n", + " \"Ligand_Name\",\n", + " \"Solvent_Name\",\n", + " \"Base_Name\",\n", + " \"Concentration\",\n", + " \"Temp_C\",\n", + "]\n", + "initial_rec_results = pd.merge(\n", + " initial_rec, df[merge_columns + [\"yield\"]], on=merge_columns, how=\"left\"\n", + ")\n", + "\n", + "initial_rec_results" + ] + }, + { + "cell_type": "markdown", + "id": "ZBYS", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "Now that we've performed experiments, we need to add the data from the experiments to the Campaign. We do this with the [`add_measurements`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.campaign.Campaign.html#baybe.campaign.Campaign.add_measurements) method." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "aLJB", + "metadata": {}, + "outputs": [], + "source": [ + "campaign.add_measurements(initial_rec_results)" + ] + }, + { + "cell_type": "markdown", + "id": "nHfw", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "Now let's simulate what we would do in practice.\n", + "\n", + "1. Ask the `campaign` for another set of 5 recommendations. Now that we've added measurements, the Campaign uses the underlying Bayesian model to select the next set of reaction conditions.\n", + "2. Next we will look up the yield for that set of conditions and use the yield data to update the Bayesian model.\n", + "\n", + "We'll repeat this process 5 times and examine the distribution of yields at each iteration." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "xXTn", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(10):\n", + " rec = campaign.recommend(5)\n", + " rec_results = rec.merge(\n", + " df[merge_columns + [\"yield\"]], on=merge_columns, how=\"left\"\n", + " )\n", + " campaign.add_measurements(rec_results)" + ] + }, + { + "cell_type": "markdown", + "id": "AjVT", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "Now, let's have a look at the results which are stored in the `campaign` object and compare them to the optimal value. Note how much `marimo`helps here with the inspection!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "pHFh", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_CyieldBatchNrFitNr
0SCHEMBL15068049Butyl EsterCesium acetate0.153120.062.3311.0
11268824-69-6p-XyleneCesium pivalate0.153105.04.5311.0
2SCHEMBL15068049DMAcCesium acetate0.057120.095.4811.0
3TricyclohexylphosphineButyl EsterPotassium acetate0.057105.00.0011.0
4BrettPhosDMAcPotassium acetate0.10090.05.2211.0
5Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.00.0011.0
6(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.010.0511.0
7P(2-furyl)3DMAcCesium acetate0.100120.029.0611.0
8(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.06.4411.0
9(t-Bu)PhCPhosDMAcPotassium acetate0.153105.057.3311.0
10SCHEMBL15068049DMAcCesium pivalate0.057120.092.0322.0
11SCHEMBL15068049DMAcCesium acetate0.15390.043.8422.0
12SCHEMBL15068049DMAcPotassium acetate0.057120.096.6422.0
13SCHEMBL15068049p-XyleneCesium acetate0.057120.059.8222.0
14JackiePhosDMAcCesium acetate0.153120.039.5722.0
15SCHEMBL15068049DMAcPotassium pivalate0.057120.089.9533.0
16SCHEMBL15068049DMAcPotassium acetate0.153120.098.3833.0
17SCHEMBL15068049DMAcPotassium pivalate0.153120.099.8133.0
18Me2PPhDMAcCesium acetate0.057120.05.9033.0
19SCHEMBL15068049DMAcCesium acetate0.153120.099.2233.0
20SCHEMBL15068049DMAcCesium pivalate0.153120.092.1944.0
21Di-tert-butylphenylphosphineDMAcCesium pivalate0.153120.00.0044.0
22Di-tert-butylphenylphosphineDMAcPotassium pivalate0.153120.00.0044.0
23Di-tert-butylphenylphosphineDMAcPotassium acetate0.153120.04.3044.0
24PPh3DMAcPotassium pivalate0.153120.079.1044.0
25SCHEMBL15068049DMAcPotassium acetate0.100120.083.2255.0
26MethyldiphenylphosphineDMAcCesium acetate0.153120.02.3355.0
27PPh3DMAcCesium acetate0.057120.089.7155.0
28XPhosDMAcPotassium pivalate0.153120.080.3955.0
29XPhosDMAcCesium acetate0.153120.084.4955.0
30SCHEMBL15068049DMAcCesium acetate0.100120.081.6366.0
31PPh3p-XyleneCesium acetate0.153120.011.8366.0
32PPh3DMAcCesium acetate0.15390.031.8566.0
33PPh3Butyl EsterCesium acetate0.057120.03.5166.0
34SCHEMBL15068049DMAcPotassium pivalate0.100120.087.5966.0
35SCHEMBL15068049DMAcCesium pivalate0.100120.083.8577.0
36(t-Bu)PhCPhosDMAcCesium acetate0.057120.066.8477.0
37PPh3DMAcCesium pivalate0.057120.084.6477.0
38(t-Bu)PhCPhosDMAcCesium pivalate0.153120.09.9677.0
39XPhosDMAcPotassium acetate0.057120.077.5877.0
40SCHEMBL15068049ButyornitrilePotassium pivalate0.153120.080.6588.0
41XPhosDMAcCesium pivalate0.057120.038.4888.0
421268824-69-6DMAcCesium acetate0.057120.016.7788.0
43SCHEMBL15068049ButyornitrileCesium pivalate0.153120.071.8188.0
44PPh3DMAcPotassium acetate0.057120.045.8588.0
45PPh3DMAcCesium pivalate0.153120.058.4099.0
46SCHEMBL15068049p-XylenePotassium pivalate0.153120.044.4799.0
47SCHEMBL15068049ButyornitrileCesium acetate0.153120.099.9899.0
48SCHEMBL15068049p-XyleneCesium pivalate0.153120.019.1399.0
49SCHEMBL15068049DMAcPotassium pivalate0.153105.098.4999.0
50SCHEMBL15068049ButyornitrileCesium acetate0.057120.050.741010.0
51SCHEMBL15068049ButyornitrilePotassium acetate0.153120.080.861010.0
52SCHEMBL15068049DMAcPotassium pivalate0.057105.090.391010.0
53SCHEMBL15068049ButyornitrilePotassium acetate0.057120.076.661010.0
54XPhosButyornitrileCesium acetate0.153120.077.011010.0
55SCHEMBL15068049DMAcPotassium pivalate0.100105.089.7611NaN
56TricyclohexylphosphineDMAcPotassium pivalate0.057120.029.5111NaN
57XPhosDMAcPotassium acetate0.153120.084.6711NaN
58JackiePhosDMAcPotassium pivalate0.057120.082.1311NaN
59PPh3DMAcPotassium pivalate0.05790.046.4611NaN
\n", + "
" + ], + "text/plain": [ + " Ligand_Name Solvent_Name Base_Name \\\n", + "0 SCHEMBL15068049 Butyl Ester Cesium acetate \n", + "1 1268824-69-6 p-Xylene Cesium pivalate \n", + "2 SCHEMBL15068049 DMAc Cesium acetate \n", + "3 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", + "4 BrettPhos DMAc Potassium acetate \n", + "5 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", + "6 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "7 P(2-furyl)3 DMAc Cesium acetate \n", + "8 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", + "9 (t-Bu)PhCPhos DMAc Potassium acetate \n", + "10 SCHEMBL15068049 DMAc Cesium pivalate \n", + "11 SCHEMBL15068049 DMAc Cesium acetate \n", + "12 SCHEMBL15068049 DMAc Potassium acetate \n", + "13 SCHEMBL15068049 p-Xylene Cesium acetate \n", + "14 JackiePhos DMAc Cesium acetate \n", + "15 SCHEMBL15068049 DMAc Potassium pivalate \n", + "16 SCHEMBL15068049 DMAc Potassium acetate \n", + "17 SCHEMBL15068049 DMAc Potassium pivalate \n", + "18 Me2PPh DMAc Cesium acetate \n", + "19 SCHEMBL15068049 DMAc Cesium acetate \n", + "20 SCHEMBL15068049 DMAc Cesium pivalate \n", + "21 Di-tert-butylphenylphosphine DMAc Cesium pivalate \n", + "22 Di-tert-butylphenylphosphine DMAc Potassium pivalate \n", + "23 Di-tert-butylphenylphosphine DMAc Potassium acetate \n", + "24 PPh3 DMAc Potassium pivalate \n", + "25 SCHEMBL15068049 DMAc Potassium acetate \n", + "26 Methyldiphenylphosphine DMAc Cesium acetate \n", + "27 PPh3 DMAc Cesium acetate \n", + "28 XPhos DMAc Potassium pivalate \n", + "29 XPhos DMAc Cesium acetate \n", + "30 SCHEMBL15068049 DMAc Cesium acetate \n", + "31 PPh3 p-Xylene Cesium acetate \n", + "32 PPh3 DMAc Cesium acetate \n", + "33 PPh3 Butyl Ester Cesium acetate \n", + "34 SCHEMBL15068049 DMAc Potassium pivalate \n", + "35 SCHEMBL15068049 DMAc Cesium pivalate \n", + "36 (t-Bu)PhCPhos DMAc Cesium acetate \n", + "37 PPh3 DMAc Cesium pivalate \n", + "38 (t-Bu)PhCPhos DMAc Cesium pivalate \n", + "39 XPhos DMAc Potassium acetate \n", + "40 SCHEMBL15068049 Butyornitrile Potassium pivalate \n", + "41 XPhos DMAc Cesium pivalate \n", + "42 1268824-69-6 DMAc Cesium acetate \n", + "43 SCHEMBL15068049 Butyornitrile Cesium pivalate \n", + "44 PPh3 DMAc Potassium acetate \n", + "45 PPh3 DMAc Cesium pivalate \n", + "46 SCHEMBL15068049 p-Xylene Potassium pivalate \n", + "47 SCHEMBL15068049 Butyornitrile Cesium acetate \n", + "48 SCHEMBL15068049 p-Xylene Cesium pivalate \n", + "49 SCHEMBL15068049 DMAc Potassium pivalate \n", + "50 SCHEMBL15068049 Butyornitrile Cesium acetate \n", + "51 SCHEMBL15068049 Butyornitrile Potassium acetate \n", + "52 SCHEMBL15068049 DMAc Potassium pivalate \n", + "53 SCHEMBL15068049 Butyornitrile Potassium acetate \n", + "54 XPhos Butyornitrile Cesium acetate \n", + "55 SCHEMBL15068049 DMAc Potassium pivalate \n", + "56 Tricyclohexylphosphine DMAc Potassium pivalate \n", + "57 XPhos DMAc Potassium acetate \n", + "58 JackiePhos DMAc Potassium pivalate \n", + "59 PPh3 DMAc Potassium pivalate \n", + "\n", + " Concentration Temp_C yield BatchNr FitNr \n", + "0 0.153 120.0 62.33 1 1.0 \n", + "1 0.153 105.0 4.53 1 1.0 \n", + "2 0.057 120.0 95.48 1 1.0 \n", + "3 0.057 105.0 0.00 1 1.0 \n", + "4 0.100 90.0 5.22 1 1.0 \n", + "5 0.100 90.0 0.00 1 1.0 \n", + "6 0.153 105.0 10.05 1 1.0 \n", + "7 0.100 120.0 29.06 1 1.0 \n", + "8 0.100 120.0 6.44 1 1.0 \n", + "9 0.153 105.0 57.33 1 1.0 \n", + "10 0.057 120.0 92.03 2 2.0 \n", + "11 0.153 90.0 43.84 2 2.0 \n", + "12 0.057 120.0 96.64 2 2.0 \n", + "13 0.057 120.0 59.82 2 2.0 \n", + "14 0.153 120.0 39.57 2 2.0 \n", + "15 0.057 120.0 89.95 3 3.0 \n", + "16 0.153 120.0 98.38 3 3.0 \n", + "17 0.153 120.0 99.81 3 3.0 \n", + "18 0.057 120.0 5.90 3 3.0 \n", + "19 0.153 120.0 99.22 3 3.0 \n", + "20 0.153 120.0 92.19 4 4.0 \n", + "21 0.153 120.0 0.00 4 4.0 \n", + "22 0.153 120.0 0.00 4 4.0 \n", + "23 0.153 120.0 4.30 4 4.0 \n", + "24 0.153 120.0 79.10 4 4.0 \n", + "25 0.100 120.0 83.22 5 5.0 \n", + "26 0.153 120.0 2.33 5 5.0 \n", + "27 0.057 120.0 89.71 5 5.0 \n", + "28 0.153 120.0 80.39 5 5.0 \n", + "29 0.153 120.0 84.49 5 5.0 \n", + "30 0.100 120.0 81.63 6 6.0 \n", + "31 0.153 120.0 11.83 6 6.0 \n", + "32 0.153 90.0 31.85 6 6.0 \n", + "33 0.057 120.0 3.51 6 6.0 \n", + "34 0.100 120.0 87.59 6 6.0 \n", + "35 0.100 120.0 83.85 7 7.0 \n", + "36 0.057 120.0 66.84 7 7.0 \n", + "37 0.057 120.0 84.64 7 7.0 \n", + "38 0.153 120.0 9.96 7 7.0 \n", + "39 0.057 120.0 77.58 7 7.0 \n", + "40 0.153 120.0 80.65 8 8.0 \n", + "41 0.057 120.0 38.48 8 8.0 \n", + "42 0.057 120.0 16.77 8 8.0 \n", + "43 0.153 120.0 71.81 8 8.0 \n", + "44 0.057 120.0 45.85 8 8.0 \n", + "45 0.153 120.0 58.40 9 9.0 \n", + "46 0.153 120.0 44.47 9 9.0 \n", + "47 0.153 120.0 99.98 9 9.0 \n", + "48 0.153 120.0 19.13 9 9.0 \n", + "49 0.153 105.0 98.49 9 9.0 \n", + "50 0.057 120.0 50.74 10 10.0 \n", + "51 0.153 120.0 80.86 10 10.0 \n", + "52 0.057 105.0 90.39 10 10.0 \n", + "53 0.057 120.0 76.66 10 10.0 \n", + "54 0.153 120.0 77.01 10 10.0 \n", + "55 0.100 105.0 89.76 11 NaN \n", + "56 0.057 120.0 29.51 11 NaN \n", + "57 0.153 120.0 84.67 11 NaN \n", + "58 0.057 120.0 82.13 11 NaN \n", + "59 0.057 90.0 46.46 11 NaN " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "measurements = campaign.measurements\n", + "measurements" + ] + }, + { + "cell_type": "markdown", + "id": "NCOB", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "As we can see, we found a very good candidate, and only needed to evaluate a fraction of the search space!" + ] + }, + { + "cell_type": "markdown", + "id": "aqbW", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "## Investigating Different Chemical Encodings\n", + "\n", + "Now that we've seen how to use `BayBE` for reaction optimization with chemical encodings, let's investigate how different chemical encodings affect the optimization performance. BayBE supports multiple chemical encodings for `SubstanceParameter`s, each capturing different aspects of molecular structure.\n", + "\n", + "We'll compare three different chemical encodings as well as the One-Hot-Encoding by running simulated optimization campaigns and visualizing their performance." + ] + }, + { + "cell_type": "markdown", + "id": "TRpd", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "We create multiple campaigns, one for each encoding we want to compare. Each campaign will use `SubstanceParameter`s for all three chemical parameters (solvent, ligand, and base) with the specified encoding:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "TXez", + "metadata": {}, + "outputs": [], + "source": [ + "substance_encodings = [\"MORDRED\", \"ECFP\", \"RDKIT2DDESCRIPTORS\"]\n", + "scenarios = {\n", + " encoding: Campaign(\n", + " searchspace=SearchSpace.from_product(\n", + " parameters=[\n", + " SubstanceParameter(\n", + " name=\"Solvent_Name\",\n", + " data=solvents_dict,\n", + " encoding=encoding,\n", + " ),\n", + " SubstanceParameter(\n", + " name=\"Base_Name\",\n", + " data=bases_dict,\n", + " encoding=encoding,\n", + " ),\n", + " SubstanceParameter(\n", + " name=\"Ligand_Name\",\n", + " data=ligands_dict,\n", + " encoding=encoding,\n", + " ),\n", + " NumericalDiscreteParameter(\n", + " values=df[\"Concentration\"].unique(), name=\"Concentration\"\n", + " ),\n", + " NumericalDiscreteParameter(\n", + " values=df[\"Temp_C\"].unique(), name=\"Temp_C\"\n", + " ),\n", + " ]\n", + " ),\n", + " objective=objective,\n", + " recommender=recommender,\n", + " )\n", + " for encoding in substance_encodings\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "dNNg", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "We also want to compare the campaigns using chemical encodings to a baseline campaign that uses One-Hot Encoding (OHE) with `CategoricalParameter`s for all chemical parameters:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "yCnT", + "metadata": {}, + "outputs": [], + "source": [ + "from baybe.parameters import CategoricalParameter\n", + "\n", + "ohe_parameters = [\n", + " CategoricalParameter(\n", + " name=\"Solvent_Name\", values=df[\"Solvent_Name\"].unique(), encoding=\"OHE\"\n", + " ),\n", + " CategoricalParameter(\n", + " name=\"Base_Name\", values=df[\"Base_Name\"].unique(), encoding=\"OHE\"\n", + " ),\n", + " CategoricalParameter(\n", + " name=\"Ligand_Name\", values=df[\"Ligand_Name\"].unique(), encoding=\"OHE\"\n", + " ),\n", + " NumericalDiscreteParameter(name=\"Temp_C\", values=[90, 105, 120]),\n", + " NumericalDiscreteParameter(name=\"Concentration\", values=[0.057, 0.1, 0.153]),\n", + "]\n", + "campaign_ohe = Campaign(\n", + " searchspace=SearchSpace.from_product(parameters=ohe_parameters),\n", + " objective=objective,\n", + " recommender=recommender,\n", + ")\n", + "scenarios[\"OHE\"] = campaign_ohe" + ] + }, + { + "cell_type": "markdown", + "id": "wlCL", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "### Using BayBE's [simulation capabilities](https://emdgroup.github.io/baybe/0.14.2/userguide/simulation.html)\n", + "\n", + "BayBE offers powerful simulation capabilities that allow us to compare different optimization strategies without running actual experiments. The simulation uses a lookup mechanism to retrieve target values from our dataset, effectively simulating multiple optimization campaigns with different random seeds (Monte Carlo iterations).\n", + "\n", + "Let's run the simulation with multiple Monte Carlo iterations to get statistically meaningful results:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "kqZH", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|##########| 40/40 [00:11<00:00, 3.42it/s]\n" + ] + } + ], + "source": [ + "from baybe.simulation import simulate_scenarios\n", + "\n", + "BATCH_SIZE = 2\n", + "N_DOE_ITERATIONS = 5 # Change to ~20 for better plots\n", + "N_MC_ITERATIONS = 10 # Change to ~30 for better plots\n", + "\n", + "results = simulate_scenarios(\n", + " scenarios,\n", + " df,\n", + " batch_size=BATCH_SIZE,\n", + " n_doe_iterations=N_DOE_ITERATIONS,\n", + " n_mc_iterations=N_MC_ITERATIONS,\n", + ")\n", + "\n", + "results.rename(\n", + " columns={\n", + " \"Scenario\": \"Substance encoding\",\n", + " \"Num_Experiments\": \"Number of experiments\",\n", + " \"yield_CumBest\": \"Running best yield\",\n", + " },\n", + " inplace=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "wAgl", + "metadata": { + "marimo": { + "config": { + "hide_code": true + } + } + }, + "source": [ + "### Visualizing the Results\n", + "\n", + "Now let's visualize the results using the `backtest_plot` utility. This plot shows:\n", + "- The mean performance across Monte Carlo iterations (solid line)\n", + "- Confidence intervals (shaded regions)\n", + "- A horizontal guideline at 90% yield (our target threshold)\n", + "- Vertical guidelines showing when the `MORDRED` and `OHE` encoding reach the target.\n", + "\n", + "The plot shows that using the `SubstanceParameter` and hence equipping `BayBE` with chemical knowledge significantly improves the performance." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "rEll", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from utils import backtest_plot\n", + "\n", + "backtest_plot(\n", + " df=results,\n", + " x=\"Number of experiments\",\n", + " y=\"Running best yield\",\n", + " hue=\"Substance encoding\",\n", + " indicator_y=90,\n", + " indicator_labels=[\"MORDRED\", \"OHE\"],\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "baybe-resources (3.13.3)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + }, + "marimo": { + "app_config": { + "app_title": "Reaction Optimization", + "width": "full" + }, + "marimo_version": "0.19.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a42c24436cce13f8da925c36db38bae4a8e8f721 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 13:55:19 +0100 Subject: [PATCH 6/9] Update CHANGELOG --- CHANGELOG.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b50e2b5..409b0a7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,11 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Unreleased ### Added - Notebook on transfer learning -- Notebook on chemical encodings +- ~~Notebook on chemical encodings~~ See **Removed** - CODEOWNERS file - Notebook on reaction optimization - CI tests for execution of notebooks and changes in CHANGELOG - Basic description and infrastructure +- Jupyter notebook version of the reaction optimization notebook ### Changed - Update from BayBE version 0.13.0 to 0.14.2 + +### Removed +- Notebook on chemical encodings was merged with notebook on reaction optimization From 1925207da7f75d31ddc5e0e40682bac79a7be914 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 14:10:09 +0100 Subject: [PATCH 7/9] Clean notebook output --- notebooks/Reaction_Optimization.ipynb | 1430 +------------------------ 1 file changed, 21 insertions(+), 1409 deletions(-) diff --git a/notebooks/Reaction_Optimization.ipynb b/notebooks/Reaction_Optimization.ipynb index 81f936a..5cafcb4 100644 --- a/notebooks/Reaction_Optimization.ipynb +++ b/notebooks/Reaction_Optimization.ipynb @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "PKri", "metadata": { "marimo": { @@ -110,250 +110,7 @@ } } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
entryBase_SMILESLigand_SMILESSolvent_SMILESConcentrationTemp_CyieldBase_NameLigand_NameSolvent_Name
00O=C([O-])C.[K+]CC(C)C1=CC(C(C)C)=C(C(C(C)C)=C1)C2=C(P(C3CCCCC...CC(N(C)C)=O0.1001055.47Potassium acetateBrettPhosDMAc
11O=C([O-])C.[K+]CC(C)(C)P(C1=CC=CC=C1)C(C)(C)CCC(N(C)C)=O0.1001050.00Potassium acetateDi-tert-butylphenylphosphineDMAc
22O=C([O-])C.[K+]CN(C)C1=CC=CC(N(C)C)=C1C2=CC=CC=C2P(C(C)(C)C)C...CC(N(C)C)=O0.10010578.95Potassium acetate(t-Bu)PhCPhosDMAc
33O=C([O-])C.[K+]P(C1CCCCC1)(C2CCCCC2)C3CCCCC3CC(N(C)C)=O0.1001057.26Potassium acetateTricyclohexylphosphineDMAc
44O=C([O-])C.[K+]P(C1=CC=CC=C1)(C2=CC=CC=C2)C3=CC=CC=C3CC(N(C)C)=O0.10010528.15Potassium acetatePPh3DMAc
.................................
17231723O=C([O-])C(C)(C)C.[Cs+]CP(C1=CC=CC=C1)C2=CC=CC=C2CC1=CC=C(C)C=C10.1531201.60Cesium pivalateMethyldiphenylphosphinep-Xylene
17241724O=C([O-])C(C)(C)C.[Cs+]CC(OC1=C(P(C2CCCCC2)C3CCCCC3)C(OC(C)C)=CC=C1)CCC1=CC=C(C)C=C10.1531208.39Cesium pivalate1268824-69-6p-Xylene
17251725O=C([O-])C(C)(C)C.[Cs+]FC(F)(F)C1=CC(P(C2=C(C3=C(C(C)C)C=C(C(C)C)C=C3...CC1=CC=C(C)C=C10.15312013.34Cesium pivalateJackiePhosp-Xylene
17261726O=C([O-])C(C)(C)C.[Cs+]C[C@]1(O2)O[C@](C[C@]2(C)P3C4=CC=CC=C4)(C)O[C@...CC1=CC=C(C)C=C10.15312019.13Cesium pivalateSCHEMBL15068049p-Xylene
17271727O=C([O-])C(C)(C)C.[Cs+]CP(C)C1=CC=CC=C1CC1=CC=C(C)C=C10.1531200.00Cesium pivalateMe2PPhp-Xylene
\n", - "

1728 rows × 10 columns

\n", - "
" - ], - "text/plain": [ - " entry Base_SMILES \\\n", - "0 0 O=C([O-])C.[K+] \n", - "1 1 O=C([O-])C.[K+] \n", - "2 2 O=C([O-])C.[K+] \n", - "3 3 O=C([O-])C.[K+] \n", - "4 4 O=C([O-])C.[K+] \n", - "... ... ... \n", - "1723 1723 O=C([O-])C(C)(C)C.[Cs+] \n", - "1724 1724 O=C([O-])C(C)(C)C.[Cs+] \n", - "1725 1725 O=C([O-])C(C)(C)C.[Cs+] \n", - "1726 1726 O=C([O-])C(C)(C)C.[Cs+] \n", - "1727 1727 O=C([O-])C(C)(C)C.[Cs+] \n", - "\n", - " Ligand_SMILES Solvent_SMILES \\\n", - "0 CC(C)C1=CC(C(C)C)=C(C(C(C)C)=C1)C2=C(P(C3CCCCC... CC(N(C)C)=O \n", - "1 CC(C)(C)P(C1=CC=CC=C1)C(C)(C)C CC(N(C)C)=O \n", - "2 CN(C)C1=CC=CC(N(C)C)=C1C2=CC=CC=C2P(C(C)(C)C)C... CC(N(C)C)=O \n", - "3 P(C1CCCCC1)(C2CCCCC2)C3CCCCC3 CC(N(C)C)=O \n", - "4 P(C1=CC=CC=C1)(C2=CC=CC=C2)C3=CC=CC=C3 CC(N(C)C)=O \n", - "... ... ... \n", - "1723 CP(C1=CC=CC=C1)C2=CC=CC=C2 CC1=CC=C(C)C=C1 \n", - "1724 CC(OC1=C(P(C2CCCCC2)C3CCCCC3)C(OC(C)C)=CC=C1)C CC1=CC=C(C)C=C1 \n", - "1725 FC(F)(F)C1=CC(P(C2=C(C3=C(C(C)C)C=C(C(C)C)C=C3... CC1=CC=C(C)C=C1 \n", - "1726 C[C@]1(O2)O[C@](C[C@]2(C)P3C4=CC=CC=C4)(C)O[C@... CC1=CC=C(C)C=C1 \n", - "1727 CP(C)C1=CC=CC=C1 CC1=CC=C(C)C=C1 \n", - "\n", - " Concentration Temp_C yield Base_Name \\\n", - "0 0.100 105 5.47 Potassium acetate \n", - "1 0.100 105 0.00 Potassium acetate \n", - "2 0.100 105 78.95 Potassium acetate \n", - "3 0.100 105 7.26 Potassium acetate \n", - "4 0.100 105 28.15 Potassium acetate \n", - "... ... ... ... ... \n", - "1723 0.153 120 1.60 Cesium pivalate \n", - "1724 0.153 120 8.39 Cesium pivalate \n", - "1725 0.153 120 13.34 Cesium pivalate \n", - "1726 0.153 120 19.13 Cesium pivalate \n", - "1727 0.153 120 0.00 Cesium pivalate \n", - "\n", - " Ligand_Name Solvent_Name \n", - "0 BrettPhos DMAc \n", - "1 Di-tert-butylphenylphosphine DMAc \n", - "2 (t-Bu)PhCPhos DMAc \n", - "3 Tricyclohexylphosphine DMAc \n", - "4 PPh3 DMAc \n", - "... ... ... \n", - "1723 Methyldiphenylphosphine p-Xylene \n", - "1724 1268824-69-6 p-Xylene \n", - "1725 JackiePhos p-Xylene \n", - "1726 SCHEMBL15068049 p-Xylene \n", - "1727 Me2PPh p-Xylene \n", - "\n", - "[1728 rows x 10 columns]" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import pandas as pd\n", "from utils import create_dict_from_columns\n", @@ -428,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "RGSE", "metadata": {}, "outputs": [], @@ -468,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "emfo", "metadata": {}, "outputs": [], @@ -501,7 +258,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "nWHF", "metadata": {}, "outputs": [], @@ -530,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "ZHCJ", "metadata": {}, "outputs": [], @@ -561,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "qnkX", "metadata": {}, "outputs": [], @@ -597,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "Vxnm", "metadata": {}, "outputs": [], @@ -627,154 +384,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "ulZA", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_C
1304SCHEMBL15068049Butyl EsterCesium acetate0.153120.0
2681268824-69-6p-XyleneCesium pivalate0.153105.0
1370SCHEMBL15068049DMAcCesium acetate0.057120.0
1459TricyclohexylphosphineButyl EsterPotassium acetate0.057105.0
381BrettPhosDMAcPotassium acetate0.10090.0
561Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.0
70(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.0
1085P(2-furyl)3DMAcCesium acetate0.100120.0
68(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.0
97(t-Bu)PhCPhosDMAcPotassium acetate0.153105.0
\n", - "
" - ], - "text/plain": [ - " Ligand_Name Solvent_Name Base_Name \\\n", - "1304 SCHEMBL15068049 Butyl Ester Cesium acetate \n", - "268 1268824-69-6 p-Xylene Cesium pivalate \n", - "1370 SCHEMBL15068049 DMAc Cesium acetate \n", - "1459 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", - "381 BrettPhos DMAc Potassium acetate \n", - "561 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", - "70 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "1085 P(2-furyl)3 DMAc Cesium acetate \n", - "68 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "97 (t-Bu)PhCPhos DMAc Potassium acetate \n", - "\n", - " Concentration Temp_C \n", - "1304 0.153 120.0 \n", - "268 0.153 105.0 \n", - "1370 0.057 120.0 \n", - "1459 0.057 105.0 \n", - "381 0.100 90.0 \n", - "561 0.100 90.0 \n", - "70 0.153 105.0 \n", - "1085 0.100 120.0 \n", - "68 0.100 120.0 \n", - "97 0.153 105.0 " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "initial_rec = campaign.recommend(batch_size=10)\n", "initial_rec" @@ -796,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "Pvdt", "metadata": { "marimo": { @@ -805,162 +418,7 @@ } } }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_Cyield
0SCHEMBL15068049Butyl EsterCesium acetate0.153120.062.33
11268824-69-6p-XyleneCesium pivalate0.153105.04.53
2SCHEMBL15068049DMAcCesium acetate0.057120.095.48
3TricyclohexylphosphineButyl EsterPotassium acetate0.057105.00.00
4BrettPhosDMAcPotassium acetate0.10090.05.22
5Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.00.00
6(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.010.05
7P(2-furyl)3DMAcCesium acetate0.100120.029.06
8(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.06.44
9(t-Bu)PhCPhosDMAcPotassium acetate0.153105.057.33
\n", - "
" - ], - "text/plain": [ - " Ligand_Name Solvent_Name Base_Name \\\n", - "0 SCHEMBL15068049 Butyl Ester Cesium acetate \n", - "1 1268824-69-6 p-Xylene Cesium pivalate \n", - "2 SCHEMBL15068049 DMAc Cesium acetate \n", - "3 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", - "4 BrettPhos DMAc Potassium acetate \n", - "5 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", - "6 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "7 P(2-furyl)3 DMAc Cesium acetate \n", - "8 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "9 (t-Bu)PhCPhos DMAc Potassium acetate \n", - "\n", - " Concentration Temp_C yield \n", - "0 0.153 120.0 62.33 \n", - "1 0.153 105.0 4.53 \n", - "2 0.057 120.0 95.48 \n", - "3 0.057 105.0 0.00 \n", - "4 0.100 90.0 5.22 \n", - "5 0.100 90.0 0.00 \n", - "6 0.153 105.0 10.05 \n", - "7 0.100 120.0 29.06 \n", - "8 0.100 120.0 6.44 \n", - "9 0.153 105.0 57.33 " - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "merge_columns = [\n", " \"Ligand_Name\",\n", @@ -992,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "aLJB", "metadata": {}, "outputs": [], @@ -1021,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "xXTn", "metadata": {}, "outputs": [], @@ -1050,837 +508,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "pHFh", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Ligand_NameSolvent_NameBase_NameConcentrationTemp_CyieldBatchNrFitNr
0SCHEMBL15068049Butyl EsterCesium acetate0.153120.062.3311.0
11268824-69-6p-XyleneCesium pivalate0.153105.04.5311.0
2SCHEMBL15068049DMAcCesium acetate0.057120.095.4811.0
3TricyclohexylphosphineButyl EsterPotassium acetate0.057105.00.0011.0
4BrettPhosDMAcPotassium acetate0.10090.05.2211.0
5Di-tert-butylphenylphosphinep-XylenePotassium acetate0.10090.00.0011.0
6(t-Bu)PhCPhosButyornitrilePotassium pivalate0.153105.010.0511.0
7P(2-furyl)3DMAcCesium acetate0.100120.029.0611.0
8(t-Bu)PhCPhosButyornitrilePotassium pivalate0.100120.06.4411.0
9(t-Bu)PhCPhosDMAcPotassium acetate0.153105.057.3311.0
10SCHEMBL15068049DMAcCesium pivalate0.057120.092.0322.0
11SCHEMBL15068049DMAcCesium acetate0.15390.043.8422.0
12SCHEMBL15068049DMAcPotassium acetate0.057120.096.6422.0
13SCHEMBL15068049p-XyleneCesium acetate0.057120.059.8222.0
14JackiePhosDMAcCesium acetate0.153120.039.5722.0
15SCHEMBL15068049DMAcPotassium pivalate0.057120.089.9533.0
16SCHEMBL15068049DMAcPotassium acetate0.153120.098.3833.0
17SCHEMBL15068049DMAcPotassium pivalate0.153120.099.8133.0
18Me2PPhDMAcCesium acetate0.057120.05.9033.0
19SCHEMBL15068049DMAcCesium acetate0.153120.099.2233.0
20SCHEMBL15068049DMAcCesium pivalate0.153120.092.1944.0
21Di-tert-butylphenylphosphineDMAcCesium pivalate0.153120.00.0044.0
22Di-tert-butylphenylphosphineDMAcPotassium pivalate0.153120.00.0044.0
23Di-tert-butylphenylphosphineDMAcPotassium acetate0.153120.04.3044.0
24PPh3DMAcPotassium pivalate0.153120.079.1044.0
25SCHEMBL15068049DMAcPotassium acetate0.100120.083.2255.0
26MethyldiphenylphosphineDMAcCesium acetate0.153120.02.3355.0
27PPh3DMAcCesium acetate0.057120.089.7155.0
28XPhosDMAcPotassium pivalate0.153120.080.3955.0
29XPhosDMAcCesium acetate0.153120.084.4955.0
30SCHEMBL15068049DMAcCesium acetate0.100120.081.6366.0
31PPh3p-XyleneCesium acetate0.153120.011.8366.0
32PPh3DMAcCesium acetate0.15390.031.8566.0
33PPh3Butyl EsterCesium acetate0.057120.03.5166.0
34SCHEMBL15068049DMAcPotassium pivalate0.100120.087.5966.0
35SCHEMBL15068049DMAcCesium pivalate0.100120.083.8577.0
36(t-Bu)PhCPhosDMAcCesium acetate0.057120.066.8477.0
37PPh3DMAcCesium pivalate0.057120.084.6477.0
38(t-Bu)PhCPhosDMAcCesium pivalate0.153120.09.9677.0
39XPhosDMAcPotassium acetate0.057120.077.5877.0
40SCHEMBL15068049ButyornitrilePotassium pivalate0.153120.080.6588.0
41XPhosDMAcCesium pivalate0.057120.038.4888.0
421268824-69-6DMAcCesium acetate0.057120.016.7788.0
43SCHEMBL15068049ButyornitrileCesium pivalate0.153120.071.8188.0
44PPh3DMAcPotassium acetate0.057120.045.8588.0
45PPh3DMAcCesium pivalate0.153120.058.4099.0
46SCHEMBL15068049p-XylenePotassium pivalate0.153120.044.4799.0
47SCHEMBL15068049ButyornitrileCesium acetate0.153120.099.9899.0
48SCHEMBL15068049p-XyleneCesium pivalate0.153120.019.1399.0
49SCHEMBL15068049DMAcPotassium pivalate0.153105.098.4999.0
50SCHEMBL15068049ButyornitrileCesium acetate0.057120.050.741010.0
51SCHEMBL15068049ButyornitrilePotassium acetate0.153120.080.861010.0
52SCHEMBL15068049DMAcPotassium pivalate0.057105.090.391010.0
53SCHEMBL15068049ButyornitrilePotassium acetate0.057120.076.661010.0
54XPhosButyornitrileCesium acetate0.153120.077.011010.0
55SCHEMBL15068049DMAcPotassium pivalate0.100105.089.7611NaN
56TricyclohexylphosphineDMAcPotassium pivalate0.057120.029.5111NaN
57XPhosDMAcPotassium acetate0.153120.084.6711NaN
58JackiePhosDMAcPotassium pivalate0.057120.082.1311NaN
59PPh3DMAcPotassium pivalate0.05790.046.4611NaN
\n", - "
" - ], - "text/plain": [ - " Ligand_Name Solvent_Name Base_Name \\\n", - "0 SCHEMBL15068049 Butyl Ester Cesium acetate \n", - "1 1268824-69-6 p-Xylene Cesium pivalate \n", - "2 SCHEMBL15068049 DMAc Cesium acetate \n", - "3 Tricyclohexylphosphine Butyl Ester Potassium acetate \n", - "4 BrettPhos DMAc Potassium acetate \n", - "5 Di-tert-butylphenylphosphine p-Xylene Potassium acetate \n", - "6 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "7 P(2-furyl)3 DMAc Cesium acetate \n", - "8 (t-Bu)PhCPhos Butyornitrile Potassium pivalate \n", - "9 (t-Bu)PhCPhos DMAc Potassium acetate \n", - "10 SCHEMBL15068049 DMAc Cesium pivalate \n", - "11 SCHEMBL15068049 DMAc Cesium acetate \n", - "12 SCHEMBL15068049 DMAc Potassium acetate \n", - "13 SCHEMBL15068049 p-Xylene Cesium acetate \n", - "14 JackiePhos DMAc Cesium acetate \n", - "15 SCHEMBL15068049 DMAc Potassium pivalate \n", - "16 SCHEMBL15068049 DMAc Potassium acetate \n", - "17 SCHEMBL15068049 DMAc Potassium pivalate \n", - "18 Me2PPh DMAc Cesium acetate \n", - "19 SCHEMBL15068049 DMAc Cesium acetate \n", - "20 SCHEMBL15068049 DMAc Cesium pivalate \n", - "21 Di-tert-butylphenylphosphine DMAc Cesium pivalate \n", - "22 Di-tert-butylphenylphosphine DMAc Potassium pivalate \n", - "23 Di-tert-butylphenylphosphine DMAc Potassium acetate \n", - "24 PPh3 DMAc Potassium pivalate \n", - "25 SCHEMBL15068049 DMAc Potassium acetate \n", - "26 Methyldiphenylphosphine DMAc Cesium acetate \n", - "27 PPh3 DMAc Cesium acetate \n", - "28 XPhos DMAc Potassium pivalate \n", - "29 XPhos DMAc Cesium acetate \n", - "30 SCHEMBL15068049 DMAc Cesium acetate \n", - "31 PPh3 p-Xylene Cesium acetate \n", - "32 PPh3 DMAc Cesium acetate \n", - "33 PPh3 Butyl Ester Cesium acetate \n", - "34 SCHEMBL15068049 DMAc Potassium pivalate \n", - "35 SCHEMBL15068049 DMAc Cesium pivalate \n", - "36 (t-Bu)PhCPhos DMAc Cesium acetate \n", - "37 PPh3 DMAc Cesium pivalate \n", - "38 (t-Bu)PhCPhos DMAc Cesium pivalate \n", - "39 XPhos DMAc Potassium acetate \n", - "40 SCHEMBL15068049 Butyornitrile Potassium pivalate \n", - "41 XPhos DMAc Cesium pivalate \n", - "42 1268824-69-6 DMAc Cesium acetate \n", - "43 SCHEMBL15068049 Butyornitrile Cesium pivalate \n", - "44 PPh3 DMAc Potassium acetate \n", - "45 PPh3 DMAc Cesium pivalate \n", - "46 SCHEMBL15068049 p-Xylene Potassium pivalate \n", - "47 SCHEMBL15068049 Butyornitrile Cesium acetate \n", - "48 SCHEMBL15068049 p-Xylene Cesium pivalate \n", - "49 SCHEMBL15068049 DMAc Potassium pivalate \n", - "50 SCHEMBL15068049 Butyornitrile Cesium acetate \n", - "51 SCHEMBL15068049 Butyornitrile Potassium acetate \n", - "52 SCHEMBL15068049 DMAc Potassium pivalate \n", - "53 SCHEMBL15068049 Butyornitrile Potassium acetate \n", - "54 XPhos Butyornitrile Cesium acetate \n", - "55 SCHEMBL15068049 DMAc Potassium pivalate \n", - "56 Tricyclohexylphosphine DMAc Potassium pivalate \n", - "57 XPhos DMAc Potassium acetate \n", - "58 JackiePhos DMAc Potassium pivalate \n", - "59 PPh3 DMAc Potassium pivalate \n", - "\n", - " Concentration Temp_C yield BatchNr FitNr \n", - "0 0.153 120.0 62.33 1 1.0 \n", - "1 0.153 105.0 4.53 1 1.0 \n", - "2 0.057 120.0 95.48 1 1.0 \n", - "3 0.057 105.0 0.00 1 1.0 \n", - "4 0.100 90.0 5.22 1 1.0 \n", - "5 0.100 90.0 0.00 1 1.0 \n", - "6 0.153 105.0 10.05 1 1.0 \n", - "7 0.100 120.0 29.06 1 1.0 \n", - "8 0.100 120.0 6.44 1 1.0 \n", - "9 0.153 105.0 57.33 1 1.0 \n", - "10 0.057 120.0 92.03 2 2.0 \n", - "11 0.153 90.0 43.84 2 2.0 \n", - "12 0.057 120.0 96.64 2 2.0 \n", - "13 0.057 120.0 59.82 2 2.0 \n", - "14 0.153 120.0 39.57 2 2.0 \n", - "15 0.057 120.0 89.95 3 3.0 \n", - "16 0.153 120.0 98.38 3 3.0 \n", - "17 0.153 120.0 99.81 3 3.0 \n", - "18 0.057 120.0 5.90 3 3.0 \n", - "19 0.153 120.0 99.22 3 3.0 \n", - "20 0.153 120.0 92.19 4 4.0 \n", - "21 0.153 120.0 0.00 4 4.0 \n", - "22 0.153 120.0 0.00 4 4.0 \n", - "23 0.153 120.0 4.30 4 4.0 \n", - "24 0.153 120.0 79.10 4 4.0 \n", - "25 0.100 120.0 83.22 5 5.0 \n", - "26 0.153 120.0 2.33 5 5.0 \n", - "27 0.057 120.0 89.71 5 5.0 \n", - "28 0.153 120.0 80.39 5 5.0 \n", - "29 0.153 120.0 84.49 5 5.0 \n", - "30 0.100 120.0 81.63 6 6.0 \n", - "31 0.153 120.0 11.83 6 6.0 \n", - "32 0.153 90.0 31.85 6 6.0 \n", - "33 0.057 120.0 3.51 6 6.0 \n", - "34 0.100 120.0 87.59 6 6.0 \n", - "35 0.100 120.0 83.85 7 7.0 \n", - "36 0.057 120.0 66.84 7 7.0 \n", - "37 0.057 120.0 84.64 7 7.0 \n", - "38 0.153 120.0 9.96 7 7.0 \n", - "39 0.057 120.0 77.58 7 7.0 \n", - "40 0.153 120.0 80.65 8 8.0 \n", - "41 0.057 120.0 38.48 8 8.0 \n", - "42 0.057 120.0 16.77 8 8.0 \n", - "43 0.153 120.0 71.81 8 8.0 \n", - "44 0.057 120.0 45.85 8 8.0 \n", - "45 0.153 120.0 58.40 9 9.0 \n", - "46 0.153 120.0 44.47 9 9.0 \n", - "47 0.153 120.0 99.98 9 9.0 \n", - "48 0.153 120.0 19.13 9 9.0 \n", - "49 0.153 105.0 98.49 9 9.0 \n", - "50 0.057 120.0 50.74 10 10.0 \n", - "51 0.153 120.0 80.86 10 10.0 \n", - "52 0.057 105.0 90.39 10 10.0 \n", - "53 0.057 120.0 76.66 10 10.0 \n", - "54 0.153 120.0 77.01 10 10.0 \n", - "55 0.100 105.0 89.76 11 NaN \n", - "56 0.057 120.0 29.51 11 NaN \n", - "57 0.153 120.0 84.67 11 NaN \n", - "58 0.057 120.0 82.13 11 NaN \n", - "59 0.057 90.0 46.46 11 NaN " - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "measurements = campaign.measurements\n", "measurements" @@ -1934,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "TXez", "metadata": {}, "outputs": [], @@ -1990,7 +621,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "yCnT", "metadata": {}, "outputs": [], @@ -2038,18 +669,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "kqZH", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|##########| 40/40 [00:11<00:00, 3.42it/s]\n" - ] - } - ], + "outputs": [], "source": [ "from baybe.simulation import simulate_scenarios\n", "\n", @@ -2102,18 +725,7 @@ "execution_count": null, "id": "rEll", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from utils import backtest_plot\n", "\n", From 0b26257326bf5aea1390ed05a8263c460bce4955 Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 14:22:30 +0100 Subject: [PATCH 8/9] Fix typos Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- notebooks/Reaction_Optimization.ipynb | 18 +++++++++++------- notebooks/Reaction_Optimization.py | 6 +++--- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/notebooks/Reaction_Optimization.ipynb b/notebooks/Reaction_Optimization.ipynb index 5cafcb4..3c98002 100644 --- a/notebooks/Reaction_Optimization.ipynb +++ b/notebooks/Reaction_Optimization.ipynb @@ -16,7 +16,7 @@ "This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of `BayBE`.\n", "\n", "In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use `BayBE` to model and optimize such a campaign.\n", - "In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process.\n", + "In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chemical knowledge for the optimization process.\n", "\n", "**Caution**\n", "This notebook was developed for `BayBE` version 0.14.2. Although we do our best in keeping our breaking changes minimal and support outdated versions for a long time, this notebook might not be immediately applicable for other `BayBE` versions. If you install `BayBE` via the instructions in this repository, version 0.14.2 will thus be installed." @@ -29,7 +29,7 @@ "source": [ "## Installation\n", "\n", - "To install `BayBE` in AWS SageMaker, make sure that you have the `conda_python3` kernel activated. Then, run the following cell to install all required packagages.\n", + "To install `BayBE` in AWS SageMaker, make sure that you have the `conda_python3` kernel activated. Then, run the following cell to install all required packages.\n", "Note that this might take some minutes." ] }, @@ -115,7 +115,7 @@ "import pandas as pd\n", "from utils import create_dict_from_columns\n", "\n", - "df = pd.read_csv(\"../data/shields.csv\")\n", + "df = pd.read_csv(\"data/shields.csv\")\n", "\n", "# Extract SMILES data for all chemical substances\n", "solvents_dict = create_dict_from_columns(df, \"Solvent_Name\", \"Solvent_SMILES\")\n", @@ -157,10 +157,10 @@ "Setting up an experimentation campaign with `BayBE` requires us to set up the main components individually. In this notebook, we will set up the following components one after another.\n", "\n", "1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of `BayBE`'s `Parameter`s.\n", - "2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters.\n", + "2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `SearchSpace.from_product`, which creates a search space as the Cartesian product of the parameters.\n", "3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and we hence stick to single target optimization.\n", "4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions.\n", - "5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model." + "5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into a `Campaign` object. The `Campaign` has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model." ] }, { @@ -638,8 +638,12 @@ " CategoricalParameter(\n", " name=\"Ligand_Name\", values=df[\"Ligand_Name\"].unique(), encoding=\"OHE\"\n", " ),\n", - " NumericalDiscreteParameter(name=\"Temp_C\", values=[90, 105, 120]),\n", - " NumericalDiscreteParameter(name=\"Concentration\", values=[0.057, 0.1, 0.153]),\n", + " NumericalDiscreteParameter(\n", + " name=\"Temp_C\", values=df[\"Temp_C\"].unique()\n", + " ),\n", + " NumericalDiscreteParameter(\n", + " name=\"Concentration\", values=df[\"Concentration\"].unique()\n", + " ),\n", "]\n", "campaign_ohe = Campaign(\n", " searchspace=SearchSpace.from_product(parameters=ohe_parameters),\n", diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index ff0895f..71dce25 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -21,7 +21,7 @@ def _(mo): This notebook contains an example on how to use BayBE for the optimization of reaction conditions. It is inspired by the corresponding notebook developed by Pat Walters as part of his [Practical Cheminformatics Tutorial](https://github.com/PatWalters/practical_cheminformatics_tutorials). This notebook assumes basic familiarity with the core concepts of Bayesian Optimization. The intention of this notebook is *not* to introduce and explain all aspects of Bayesian Optimization, but to focus on the usage of `BayBE`. In drug discovery, we frequently encounter situations where we need to modify a set of reaction conditions to optimize the yield. This notebook shows how to use `BayBE` to model and optimize such a campaign. - In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chamical knowledge for the optimization process. + In particular, it demonstrates the power and usefulness of `BayBE`'s chemical encodings. If parameters in a process to be optimized are chemicals, this feature enables `BayBE` to automatically use meaningful chemical descriptors, automatically leveraging chemical knowledge for the optimization process. /// caution @@ -99,10 +99,10 @@ def _(mo): Setting up an experimentation campaign with `BayBE` requires us to set up the main components individually. In this notebook, we will set up the following components one after another. 1. [**Parameters**](https://emdgroup.github.io/baybe/0.14.2/userguide/parameters.html): In our setting, a _parameter_ is something that we can control directly. An example of this is which ligand to choose, or at which of the available temperatures to run the experiment. Each of the 5 parameters described earlier will correspond to exactly one of `BayBE`'s `Parameter`s. - 2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `Searchspace.from_product`, which creates a search space as the Cartesian product of the parameters. + 2. [**Search space**](https://emdgroup.github.io/baybe/0.14.2/userguide/searchspace.html): The search space defines the combination of parameters to be searched. It thus contains all possible experiments that we could conduct. The search space is typically defined using the function `SearchSpace.from_product`, which creates a search space as the Cartesian product of the parameters. 3. [**Target**](https://emdgroup.github.io/baybe/0.14.2/userguide/targets.html): The target is the quantity we are optimizing. In the case of reaction optimization, this is typically the yield. `BayBE` can optimize a single parameter or multiple parameters at once. In this notebook, we'll focus on single parameter optimization, where we are only optimizing the yield, and we hence stick to single target optimization. 4. [**Recommender**](https://emdgroup.github.io/baybe/0.14.2/userguide/recommenders.html): The recommender selects the next set of experiments to be performed. In this case, we use the default [`TwoPhaseMetaRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.meta.sequential.TwoPhaseMetaRecommender.html). This recommender behaves differently depending on whether it has experimental data. At the beginning of an optimization process, we typically don't have experimental data and want to find a diverse set of conditions to gather some initial data. If the `TwoPhaseMetaRecommender` has no data available, it uses random sampling to select a set of initial experiments. If the recommender has data, it uses the [`BotorchRecommender`](https://emdgroup.github.io/baybe/0.14.2/_autosummary/baybe.recommenders.pure.bayesian.botorch.BotorchRecommender.html), a Bayesian optimizer that balances exploration and exploitation when selecting sets of reaction conditions. - 5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into an `campaign` object. The Campaign has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model. + 5. [**Campaign**](https://emdgroup.github.io/baybe/0.14.2/userguide/campaigns.html): In `BayBE`, the search space, objective, and recommender are combined into a `Campaign` object. The `Campaign` has two important methods: `recommend`, which recommends the next set of experiments, and `add_measurements`, which adds a set of experiments and updates the underlying Bayesian model. """) return From 1c217eb26706ebfe12aadc0b7f6966518db9749d Mon Sep 17 00:00:00 2001 From: "Alexander V. Hopp" Date: Mon, 9 Feb 2026 14:29:15 +0100 Subject: [PATCH 9/9] Use values from data instead of hardcoding Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- notebooks/Reaction_Optimization.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/notebooks/Reaction_Optimization.py b/notebooks/Reaction_Optimization.py index 71dce25..412ea05 100644 --- a/notebooks/Reaction_Optimization.py +++ b/notebooks/Reaction_Optimization.py @@ -455,8 +455,12 @@ def _( CategoricalParameter( name="Ligand_Name", values=df["Ligand_Name"].unique(), encoding="OHE" ), - NumericalDiscreteParameter(name="Temp_C", values=[90, 105, 120]), - NumericalDiscreteParameter(name="Concentration", values=[0.057, 0.1, 0.153]), + NumericalDiscreteParameter( + name="Temp_C", values=df["Temp_C"].unique() + ), + NumericalDiscreteParameter( + name="Concentration", values=df["Concentration"].unique() + ), ] campaign_ohe = Campaign( searchspace=SearchSpace.from_product(parameters=ohe_parameters),