Rework of aryl_halides benchmark

Author: AVHopp

benchmarks/domains/__init__.py

@@ -1,23 +1,22 @@
 """Benchmark domains."""
 
 from benchmarks.definition.base import Benchmark
-from benchmarks.domains.arylhalides_tl_substance import (
-    arylhalides_tl_substance_benchmark,
-)
-from benchmarks.domains.direct_arylation_tl_temp import (
+from benchmarks.domains.direct_arylation_tl_temperature import (
     direct_arylation_tl_temp_benchmark,
 )
 from benchmarks.domains.easom_tl_noise import easom_tl_noise_benchmark
 from benchmarks.domains.hartmann_tl_inverted_noise import (
     hartmann_tl_inverted_noise_benchmark,
 )
 from benchmarks.domains.michalewicz_tl_noise import michalewicz_tl_noise_benchmark
-
-# from benchmarks.domains.synthetic_2C1D_1C import synthetic_2C1D_1C_benchmark
+from benchmarks.domains.synthetic_2C1D_1C import synthetic_2C1D_1C_benchmark
+from benchmarks.domains.transfer_learning.aryl_halides.ChlorTrifluour_IodMeth import (
+    arylhalides_1Iodo4Metho_1Chloro4Trifluour_benchmark,
+)
 
 BENCHMARKS: list[Benchmark] = [
-    # synthetic_2C1D_1C_benchmark,
-    arylhalides_tl_substance_benchmark,
+    synthetic_2C1D_1C_benchmark,
+    arylhalides_1Iodo4Metho_1Chloro4Trifluour_benchmark,
     direct_arylation_tl_temp_benchmark,
     hartmann_tl_inverted_noise_benchmark,
     easom_tl_noise_benchmark,

benchmarks/domains/transfer_learning/aryl_halides/ChlorTrifluour_IodMeth.py

@@ -0,0 +1,42 @@
+"""Aryl-Halide benchmark for transfer learning.
+
+As source parameter, this benchmark uses 1-chloro-4-(trifluoromethyl)benzene.
+As target parameter, this benchmark uses 1-iodo-4-methoxybenzene.
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from benchmarks.definition import (
+    ConvergenceBenchmark,
+    ConvergenceBenchmarkSettings,
+)
+from benchmarks.domains.transfer_learning.aryl_halides.base import (
+    abstract_arylhalides_tl_substance_benchmark,
+)
+
+
+def arylhalides_ChloroTrifluour_IodoMetho(
+    settings: ConvergenceBenchmarkSettings,
+) -> pd.DataFrame:
+    """Actual benchmark function."""
+    return abstract_arylhalides_tl_substance_benchmark(
+        settings=settings,
+        source_tasks=["1-chloro-4-(trifluoromethyl)benzene"],
+        target_tasks=["1-iodo-4-methoxybenzene"],
+        percentages=[0.01, 0.02, 0.05, 0.1, 0.2],
+    )
+
+
+benchmark_config = ConvergenceBenchmarkSettings(
+    batch_size=2,
+    n_doe_iterations=10,
+    n_mc_iterations=30,
+)
+
+arylhalides_1Iodo4Metho_1Chloro4Trifluour_benchmark = ConvergenceBenchmark(
+    function=arylhalides_ChloroTrifluour_IodoMetho,
+    optimal_target_values={"yield": 68.24812709999999},
+    settings=benchmark_config,
+)

benchmarks/domains/transfer_learning/aryl_halides/__init__.py

@@ -0,0 +1,7 @@
+"""Aryl halides transfer learning benchmarks."""
+
+from benchmarks.domains.transfer_learning.aryl_halides.ChlorTrifluour_IodMeth import (
+    arylhalides_ChloroTrifluour_IodoMetho,
+)
+
+__all__ = ["arylhalides_ChloroTrifluour_IodoMetho"]

benchmarks/domains/transfer_learning/aryl_halides/base.py

@@ -0,0 +1,169 @@
+"""Benchmark on ArylHalides data with two distinct arylhalides as TL tasks.
+
+This file provides the basic structure such that one can easily create different
+benchmarks by changing the source and target tasks. The benchmark compares TL and
+non-TL campaigns.
+
+By convention, the benchmarks are named in the format "SourceHalides-TargetHalides.py"
+where SourceHalides and TargetHalides are abbreviations of the used source and target
+tasks respectively.
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from baybe.campaign import Campaign
+from baybe.objectives import SingleTargetObjective
+from baybe.parameters import SubstanceParameter, TaskParameter
+from baybe.searchspace import SearchSpace
+from baybe.simulation import simulate_scenarios
+from baybe.targets import NumericalTarget
+from benchmarks.data.utils import DATA_PATH
+from benchmarks.definition import (
+    ConvergenceBenchmarkSettings,
+)
+
+
+def get_data() -> pd.DataFrame:
+    """Load the data for the benchmark."""
+    data_path = DATA_PATH / "ArylHalides"
+    data = pd.read_table(data_path / "data.csv", sep=",").dropna(
+        subset=["base", "ligand", "additive", "aryl_halide"]
+    )
+    # Only keep relevant columns
+    data = data[
+        [
+            "base",
+            "ligand",
+            "additive",
+            "ligand_smiles",
+            "base_smiles",
+            "additive_smiles",
+            "aryl_halide",
+            "yield",
+        ]
+    ]
+    return data
+
+
+def create_searchspace(
+    data: pd.DataFrame,
+    use_task_parameter: bool,
+    target_tasks: list[str],
+    source_tasks: list[str],
+) -> SearchSpace:
+    """Create the search space for the benchmark."""
+    params = [
+        SubstanceParameter(
+            name=substance,
+            data=dict(zip(data[substance], data[f"{substance}_smiles"])),
+            encoding="MORDRED",
+        )
+        for substance in ["base", "ligand", "additive"]
+    ]
+    if use_task_parameter:
+        params.append(
+            TaskParameter(
+                name="aryl_halide",
+                values=target_tasks + source_tasks,
+                active_values=target_tasks,
+            )
+        )
+    return SearchSpace.from_product(parameters=params)
+
+
+def create_objective() -> SingleTargetObjective:
+    """Create the objective for the benchmark."""
+    return SingleTargetObjective(NumericalTarget(name="yield", mode="MAX"))
+
+
+def create_lookup(data: pd.DataFrame, target_tasks: list[str]) -> pd.DataFrame:
+    """Create the lookup for the benchmark."""
+    return data[data["aryl_halide"].isin(target_tasks)]
+
+
+def create_initial_data(data: pd.DataFrame, source_tasks: list[str]) -> pd.DataFrame:
+    """Create the initial data for the benchmark."""
+    return data[data["aryl_halide"].isin(source_tasks)]
+
+
+def abstract_arylhalides_tl_substance_benchmark(
+    settings: ConvergenceBenchmarkSettings,
+    source_tasks: list[str],
+    target_tasks: list[str],
+    percentages: list[float],
+) -> pd.DataFrame:
+    """Benchmark function comparing TL and non-TL campaigns.
+
+    Inputs:
+        base:           Substance with MORDRED encoding
+        ligand:         Substance with MORDRED encoding
+        additive:       Substance with MORDRED encoding
+        aryl_halide:    Task parameter
+    Output:             Continuous (yield)
+    Objective:          Maximization
+    Optimal Inputs:
+        base: "MTBD",
+        ligand: "AdBrettPhos",
+        additive: "N,N-dibenzylisoxazol-3-amine"
+    Optimal Output:     68.24812709999999
+    """
+    data = get_data()
+
+    # target_tasks = ["1-iodo-4-methoxybenzene"]
+    # source_tasks = [
+    #    # Dissimilar source task
+    #    "1-chloro-4-(trifluoromethyl)benzene"
+    # ]
+    searchspace = create_searchspace(
+        data=data,
+        use_task_parameter=True,
+        source_tasks=source_tasks,
+        target_tasks=target_tasks,
+    )
+    searchspace_nontl = create_searchspace(
+        data=data,
+        use_task_parameter=False,
+        source_tasks=source_tasks,
+        target_tasks=target_tasks,
+    )
+
+    lookup = create_lookup(data, target_tasks)
+    initial_data = create_initial_data(data, source_tasks)
+
+    tl_campaign = Campaign(
+        searchspace=searchspace,
+        objective=create_objective(),
+    )
+    non_tl_campaign = Campaign(
+        searchspace=searchspace_nontl, objective=create_objective()
+    )
+
+    results = []
+    for p in percentages:
+        results.append(
+            simulate_scenarios(
+                {f"{int(100 * p)}": tl_campaign},
+                lookup,
+                initial_data=[
+                    initial_data.sample(frac=p) for _ in range(settings.n_mc_iterations)
+                ],
+                batch_size=settings.batch_size,
+                n_doe_iterations=settings.n_doe_iterations,
+                impute_mode="error",
+            )
+        )
+    # No training data and non-TL campaign
+    results.append(
+        simulate_scenarios(
+            {"0": tl_campaign, "non_TL": non_tl_campaign},
+            lookup,
+            batch_size=settings.batch_size,
+            n_doe_iterations=settings.n_doe_iterations,
+            n_mc_iterations=settings.n_mc_iterations,
+            impute_mode="error",
+        )
+    )
+    results = pd.concat(results)
+    return results