xopt 2.4.2__tar.gz → 2.4.4__tar.gz

{xopt-2.4.2 → xopt-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xopt
-Version: 2.4.2
+Version: 2.4.4
 Summary: Flexible optimization of arbitrary problems in Python.
 Author: Christopher Mayes, Ryan Roussel
 License:                                  Apache License

{xopt-2.4.2 → xopt-2.4.4}/xopt/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.4.2'
-__version_tuple__ = version_tuple = (2, 4, 2)
+__version__ = version = '2.4.4'
+__version_tuple__ = version_tuple = (2, 4, 4)

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/bax/visualize.py

@@ -103,7 +103,7 @@ def visualize_virtual_objective(
     bounds = generator._get_optimization_bounds()
     kwargs = kwargs if kwargs else {}
     objective_values = generator.algorithm.evaluate_virtual_objective(
-        bax_model, x, bounds, tkwargs=generator._tkwargs, n_samples=n_samples, **kwargs
+        bax_model, x, bounds, tkwargs=generator.tkwargs, n_samples=n_samples, **kwargs
     )
 
     # get sample stats

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/bayesian_generator.py

@@ -4,13 +4,14 @@ import time
 import warnings
 from abc import ABC, abstractmethod
 from copy import deepcopy
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
 import pandas as pd
 import torch
 from botorch.acquisition import FixedFeatureAcquisitionFunction, qUpperConfidenceBound
 from botorch.models.model import Model
 from botorch.sampling import get_sampler
+from botorch.utils.multi_objective import is_non_dominated
 from botorch.utils.multi_objective.box_decompositions import DominatedPartitioning
 from gpytorch import Module
 from pydantic import Field, field_validator, PositiveInt, SerializeAsAny
@@ -384,7 +385,7 @@ class BayesianGenerator(Generator, ABC):
             self.vocs.output_names,
             data,
             {name: variable_bounds[name] for name in self.model_input_names},
-            **self._tkwargs,
+            **self.tkwargs,
         )
 
         if update_internal:
@@ -407,8 +408,18 @@ class BayesianGenerator(Generator, ABC):
         # get acquisition function
         acq_funct = self.get_acquisition(model)
 
-        # get candidates
-        candidates = self.numerical_optimizer.optimize(acq_funct, bounds, n_candidates)
+        # get initial candidates to start acquisition function optimization
+        initial_points = self._get_initial_conditions(n_candidates)
+
+        # get candidates -- grid optimizer does not support batch_initial_conditions
+        if isinstance(self.numerical_optimizer, GridOptimizer):
+            candidates = self.numerical_optimizer.optimize(
+                acq_funct, bounds, n_candidates
+            )
+        else:
+            candidates = self.numerical_optimizer.optimize(
+                acq_funct, bounds, n_candidates, batch_initial_conditions=initial_points
+            )
         return candidates
 
     def get_training_data(self, data: pd.DataFrame) -> pd.DataFrame:
@@ -456,7 +467,7 @@ class BayesianGenerator(Generator, ABC):
         input names (variables), and the resulting tensor is configured with the data
         type and device settings from the generator.
         """
-        return torch.tensor(data[self.model_input_names].to_numpy(), **self._tkwargs)
+        return torch.tensor(data[self.model_input_names].to_numpy(), **self.tkwargs)
 
     def get_acquisition(self, model):
         """
@@ -536,6 +547,11 @@ class BayesianGenerator(Generator, ABC):
         """displays the GP models"""
         return visualize_generator_model(self, **kwargs)
 
+    def _get_initial_conditions(self, n_candidates=1) -> Union[Tensor, None]:
+        """overwrite if algorithm should specifiy initial candidates for optimizing
+        the acquisition function"""
+        return None
+
     def _process_candidates(self, candidates: Tensor):
         """process pytorch candidates from optimizing the acquisition function"""
         logger.debug(f"Best candidate from optimize {candidates}")
@@ -581,7 +597,7 @@ class BayesianGenerator(Generator, ABC):
 
             return self.custom_objective
         else:
-            return create_mc_objective(self.vocs, self._tkwargs)
+            return create_mc_objective(self.vocs, self.tkwargs)
 
     def _get_constraint_callables(self):
         """return constratint callable determined by vocs"""
@@ -591,7 +607,7 @@ class BayesianGenerator(Generator, ABC):
         return constraint_callables
 
     @property
-    def _tkwargs(self):
+    def tkwargs(self):
         # set device and data type for generator
         device = "cpu"
         if self.use_cuda:
@@ -627,7 +643,7 @@ class BayesianGenerator(Generator, ABC):
 
     def _get_bounds(self):
         """convert bounds from vocs to torch tensors"""
-        return torch.tensor(self.vocs.bounds, **self._tkwargs)
+        return torch.tensor(self.vocs.bounds, **self.tkwargs)
 
     def _get_optimization_bounds(self):
         """
@@ -720,7 +736,7 @@ class BayesianGenerator(Generator, ABC):
                 "from, add data first to use during BO"
             )
         last_point = torch.tensor(
-            self.data[self.vocs.variable_names].iloc[-1].to_numpy(), **self._tkwargs
+            self.data[self.vocs.variable_names].iloc[-1].to_numpy(), **self.tkwargs
         )
 
         # bound lengths based on vocs for normalization
@@ -728,8 +744,8 @@ class BayesianGenerator(Generator, ABC):
 
         # get maximum travel distances
         max_travel_distances = torch.tensor(
-            self.max_travel_distances, **self._tkwargs
-        ) * torch.tensor(lengths, **self._tkwargs)
+            self.max_travel_distances, **self.tkwargs
+        ) * torch.tensor(lengths, **self.tkwargs)
         max_travel_bounds = torch.stack(
             (last_point - max_travel_distances, last_point + max_travel_distances)
         )
@@ -774,33 +790,54 @@ class MultiObjectiveBayesianGenerator(BayesianGenerator, ABC):
                     supported"
                 )
 
-        return torch.tensor(pt, **self._tkwargs)
+        return torch.tensor(pt, **self.tkwargs)
 
-    def calculate_hypervolume(self):
-        """compute hypervolume given data"""
-        objective_data = torch.tensor(
-            self.vocs.objective_data(self.data, return_raw=True).to_numpy()
+    def _get_scaled_data(self):
+        """get scaled input/objective data for use with botorch logic which assumes
+        maximization for each objective"""
+        var_df, obj_df, _, _ = self.vocs.extract_data(
+            self.data, return_valid=True, return_raw=True
         )
 
-        # hypervolume must only take into account feasible data points
-        if self.vocs.n_constraints > 0:
-            objective_data = objective_data[
-                self.vocs.feasibility_data(self.data)["feasible"].to_list()
-            ]
+        variable_data = torch.tensor(var_df[self.vocs.variable_names].to_numpy())
+        objective_data = torch.tensor(obj_df[self.vocs.objective_names].to_numpy())
+        weights = set_botorch_weights(self.vocs).to(**self.tkwargs)[
+            : self.vocs.n_objectives
+        ]
+        return variable_data, objective_data * weights, weights
 
-        n_objectives = self.vocs.n_objectives
-        weights = torch.zeros(n_objectives)
-        weights = set_botorch_weights(self.vocs).to(**self._tkwargs)
-        objective_data = objective_data * weights
+    def calculate_hypervolume(self):
+        """compute hypervolume given data"""
 
         # compute hypervolume
         bd = DominatedPartitioning(
-            ref_point=self.torch_reference_point, Y=objective_data
+            ref_point=self.torch_reference_point, Y=self._get_scaled_data()[1]
         )
         volume = bd.compute_hypervolume().item()
 
         return volume
 
+    def get_pareto_front(self):
+        """compute the pareto front x/y values given data"""
+        variable_data, objective_data, weights = self._get_scaled_data()
+        obj_data = torch.vstack(
+            (self.torch_reference_point.unsqueeze(0), objective_data)
+        )
+        var_data = torch.vstack(
+            (
+                torch.full_like(variable_data[0], float("Nan")).unsqueeze(0),
+                variable_data,
+            )
+        )
+        non_dominated = is_non_dominated(obj_data)
+
+        # note need to undo weights for real number output
+        # only return values if non nan values exist
+        if torch.all(torch.isnan(var_data[non_dominated])):
+            return None, None
+        else:
+            return var_data[non_dominated], obj_data[non_dominated] / weights
+
 
 def formatted_base_docstring():
     return "\nBase Generator\n---------------\n" + BayesianGenerator.__doc__

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/expected_improvement.py

@@ -40,7 +40,7 @@ class ExpectedImprovementGenerator(BayesianGenerator):
             # analytic acquisition function for single candidate generation with
             # basic objective
             # note that the analytic version cannot handle custom objectives
-            weights = set_botorch_weights(self.vocs).to(**self._tkwargs)
+            weights = set_botorch_weights(self.vocs).to(**self.tkwargs)
             posterior_transform = ScalarizedPosteriorTransform(weights)
             acq = ExpectedImprovement(
                 model, best_f=best_f, posterior_transform=posterior_transform
@@ -52,14 +52,12 @@ class ExpectedImprovementGenerator(BayesianGenerator):
         """get best function value for EI based on the objective"""
         if isinstance(objective, CustomXoptObjective):
             best_f = objective(
-                torch.tensor(
-                    self.vocs.observable_data(data).to_numpy(), **self._tkwargs
-                )
+                torch.tensor(self.vocs.observable_data(data).to_numpy(), **self.tkwargs)
             ).max()
         else:
             # analytic acquisition function for single candidate generation
             best_f = -torch.tensor(
-                self.vocs.objective_data(data).min().values, **self._tkwargs
+                self.vocs.objective_data(data).min().values, **self.tkwargs
             )
 
         return best_f

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/mggpo.py

@@ -32,7 +32,7 @@ class MGGPOGenerator(MultiObjectiveBayesianGenerator):
         ga_candidates = self.ga_generator.generate(n_candidates * 10)
         ga_candidates = pd.DataFrame(ga_candidates)[self.vocs.variable_names].to_numpy()
         ga_candidates = torch.unique(
-            torch.tensor(ga_candidates, **self._tkwargs), dim=0
+            torch.tensor(ga_candidates, **self.tkwargs), dim=0
         ).reshape(-1, 1, self.vocs.n_variables)
 
         if ga_candidates.shape[0] < n_candidates:

xopt-2.4.4/xopt/generators/bayesian/mobo.py

@@ -0,0 +1,135 @@
+from typing import Union
+
+import torch
+from botorch.acquisition import FixedFeatureAcquisitionFunction
+from botorch.acquisition.multi_objective import qNoisyExpectedHypervolumeImprovement
+from botorch.acquisition.multi_objective.logei import (
+    qLogNoisyExpectedHypervolumeImprovement,
+)
+from botorch.utils import draw_sobol_samples
+from pydantic import Field
+from torch import Tensor
+
+from xopt.generators.bayesian.bayesian_generator import MultiObjectiveBayesianGenerator
+
+from xopt.generators.bayesian.objectives import create_mobo_objective
+from xopt.numerical_optimizer import LBFGSOptimizer
+
+
+class MOBOGenerator(MultiObjectiveBayesianGenerator):
+    name = "mobo"
+    supports_batch_generation: bool = True
+    use_pf_as_initial_points: bool = Field(
+        False,
+        description="flag to specify if pareto front points are to be used during "
+        "optimization of the acquisition function",
+    )
+    __doc__ = """Implements Multi-Objective Bayesian Optimization using the Expected
+            Hypervolume Improvement acquisition function"""
+
+    def _get_objective(self):
+        return create_mobo_objective(self.vocs)
+
+    def get_acquisition(self, model):
+        """
+        Returns a function that can be used to evaluate the acquisition function
+        """
+        if model is None:
+            raise ValueError("model cannot be None")
+
+        # get base acquisition function
+        acq = self._get_acquisition(model)
+
+        # apply fixed features if specified in the generator
+        if self.fixed_features is not None:
+            # get input dim
+            dim = len(self.model_input_names)
+            columns = []
+            values = []
+            for name, value in self.fixed_features.items():
+                columns += [self.model_input_names.index(name)]
+                values += [value]
+
+            acq = FixedFeatureAcquisitionFunction(
+                acq_function=acq, d=dim, columns=columns, values=values
+            )
+
+        return acq
+
+    def _get_acquisition(self, model):
+        inputs = self.get_input_data(self.data)
+        sampler = self._get_sampler(model)
+
+        if self.log_transform_acquisition_function:
+            acqclass = qLogNoisyExpectedHypervolumeImprovement
+        else:
+            acqclass = qNoisyExpectedHypervolumeImprovement
+
+        acq = acqclass(
+            model,
+            X_baseline=inputs,
+            constraints=self._get_constraint_callables(),
+            ref_point=self.torch_reference_point,
+            sampler=sampler,
+            objective=self._get_objective(),
+            cache_root=False,
+            prune_baseline=True,
+        )
+
+        return acq
+
+    def _get_initial_conditions(self, n_candidates=1) -> Union[Tensor, None]:
+        """
+        generate initial candidates for optimizing the acquisition function based on
+        the pareto front
+
+        If `use_pf_as_initial_points` flag is set to true then the current
+        Pareto-optimal set is used as initial points for optimizing the acquisition
+        function instead of randomly selected points (random points fill in the set
+        if `num_restarts` is greater than the number of points in the Pareto set).
+
+        Returns:
+            A `num_restarts x q x d` tensor of initial conditions.
+
+        """
+        if self.use_pf_as_initial_points:
+            if isinstance(self.numerical_optimizer, LBFGSOptimizer):
+                bounds = self._get_optimization_bounds()
+                num_restarts = self.numerical_optimizer.n_restarts
+
+                pf_locations, _ = self.get_pareto_front()
+
+                # if there is no pareto front just return None to revert back to
+                # default behavior
+                if pf_locations is None:
+                    return None
+
+                initial_points = torch.clone(pf_locations)
+
+                # add the q dimension
+                initial_points = initial_points.unsqueeze(1)
+                initial_points = initial_points.expand([-1, n_candidates, -1])
+
+                # initial_points must equal the number of restarts
+                if len(initial_points) < num_restarts:
+                    # add random points to the list inside the bounds
+                    sobol_samples = draw_sobol_samples(
+                        bounds, num_restarts - len(initial_points), n_candidates
+                    )
+
+                    initial_points = torch.cat([initial_points, sobol_samples])
+                elif len(initial_points) > num_restarts:
+                    # if there are too many select the first `num_restarts` points at
+                    # random
+                    initial_points = initial_points[
+                        torch.randperm(len(initial_points))
+                    ][:num_restarts]
+
+                return initial_points
+            else:
+                raise RuntimeWarning(
+                    "cannot use PF as initial optimization points "
+                    "for non-LBFGS optimizers, ignoring flag"
+                )
+
+        return None

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/multi_fidelity.py

@@ -155,7 +155,7 @@ class MultiFidelityGenerator(MOBOGenerator):
         """select the best point at the maximum fidelity"""
 
         # define single objective based on vocs
-        weights = torch.zeros(self.vocs.n_outputs, **self._tkwargs)
+        weights = torch.zeros(self.vocs.n_outputs, **self.tkwargs)
         for idx, ele in enumerate(self.vocs.objective_names):
             if self.vocs.objectives[ele] == "MINIMIZE":
                 weights[idx] = -1.0

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/time_dependent.py

@@ -95,7 +95,7 @@ class TimeDependentBayesianGenerator(BayesianGenerator, ABC):
         type and device settings from the generator.
         """
         return torch.tensor(
-            data[self.model_input_names + ["time"]].to_numpy(), **self._tkwargs
+            data[self.model_input_names + ["time"]].to_numpy(), **self.tkwargs
         )
 
     def get_acquisition(self, model):
@@ -103,7 +103,7 @@ class TimeDependentBayesianGenerator(BayesianGenerator, ABC):
 
         # identify which column has the `time` attribute
         column = [-1]
-        value = torch.tensor(self.target_prediction_time, **self._tkwargs).unsqueeze(0)
+        value = torch.tensor(self.target_prediction_time, **self.tkwargs).unsqueeze(0)
         fixed_acq = FixedFeatureAcquisitionFunction(
             acq, self.vocs.n_variables + 1, column, value
         )

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/turbo.py

@@ -1,11 +1,12 @@
 import logging
 import math
 from abc import ABC, abstractmethod
-from typing import Dict, Optional, Union
+from typing import Dict, Optional
 
 import pandas as pd
 import torch
 from pydantic import ConfigDict, Field, PositiveFloat, PositiveInt
+from torch import Tensor
 
 from xopt.pydantic import XoptBaseModel
 from xopt.vocs import VOCS
@@ -51,7 +52,6 @@ class TurboController(XoptBaseModel, ABC):
     restrict_model_data: Optional[bool] = Field(
         True, description="flag to restrict model data to within the trust region"
     )
-    tkwargs: Dict[str, Union[torch.dtype, str]] = Field({"dtype": torch.double})
 
     model_config = ConfigDict(validate_assignment=True, arbitrary_types_allowed=True)
 
@@ -79,9 +79,24 @@ class TurboController(XoptBaseModel, ABC):
                 )
             )
 
-    def get_trust_region(self, generator):
+    def get_trust_region(self, generator) -> Tensor:
+        """
+
+        Return the trust region based on the generator. The trust region is a
+        rectangular region around a center point. The sides of the trust region are
+        given by the `length` parameter and are scaled according to the generator
+        model lengthscales (if available).
+
+        Parameters
+        ----------
+        generator : BayesianGenerator
+            Generator object used to supply the model and datatypes for the returned
+            trust region.
+
+        """
+
         model = generator.model
-        bounds = torch.tensor(self.vocs.bounds, **self.tkwargs)
+        bounds = torch.tensor(self.vocs.bounds, **generator.tkwargs)
 
         if self.center_x is not None:
             # get bounds width
@@ -89,18 +104,22 @@ class TurboController(XoptBaseModel, ABC):
 
             # Scale the TR to be proportional to the lengthscales of the objective model
             x_center = torch.tensor(
-                [self.center_x[ele] for ele in self.vocs.variable_names], **self.tkwargs
+                [self.center_x[ele] for ele in self.vocs.variable_names],
+                **generator.tkwargs,
             ).unsqueeze(dim=0)
 
-            if model.models[0].covar_module.base_kernel.lengthscale is not None:
-                lengthscales = model.models[
-                    0
-                ].covar_module.base_kernel.lengthscale.detach()
+            # default weights are 1 (if there is no model or a model without
+            # lengthscales)
+            weights = 1.0
 
-                # calculate the ratios of lengthscales for each axis
-                weights = lengthscales / torch.prod(lengthscales) ** (1 / self.dim)
-            else:
-                weights = 1.0
+            if model is not None:
+                if model.models[0].covar_module.base_kernel.lengthscale is not None:
+                    lengthscales = model.models[
+                        0
+                    ].covar_module.base_kernel.lengthscale.detach()
+
+                    # calculate the ratios of lengthscales for each axis
+                    weights = lengthscales / torch.prod(lengthscales) ** (1 / self.dim)
 
             # calculate the tr bounding box
             tr_lb = torch.clamp(

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/bayesian/utils.py

@@ -1,3 +1,4 @@
+from copy import deepcopy
 from typing import List
 
 import numpy as np
@@ -206,16 +207,19 @@ def validate_turbo_controller_base(value, available_controller_types, info):
                 f"{available_controller_types.keys()}"
             )
     elif isinstance(value, dict):
+        value_copy = deepcopy(value)
         # create turbo controller from dict input
         if "name" not in value:
             raise ValueError("turbo input dict needs to have a `name` attribute")
-        name = value.pop("name")
+        name = value_copy.pop("name")
         if name in available_controller_types:
             # pop unnecessary elements
             for ele in ["dim"]:
-                value.pop(ele, None)
+                value_copy.pop(ele, None)
 
-            value = available_controller_types[name](vocs=info.data["vocs"], **value)
+            value = available_controller_types[name](
+                vocs=info.data["vocs"], **value_copy
+            )
         else:
             raise ValueError(
                 f"{value} not found, available values are "

{xopt-2.4.2 → xopt-2.4.4}/xopt/generators/ga/cnsga.py

@@ -123,7 +123,8 @@ class CNSGAGenerator(Generator):
             return
 
         if filename is None:
-            filename = f"{self.name}_offspring_{xopt.utils.isotime(include_microseconds=True)}.csv"
+            timestamp = xopt.utils.isotime(include_microseconds=True).replace(":", "_")
+            filename = f"{self.name}_offspring_{timestamp}.csv"
             filename = os.path.join(self.output_path, filename)
 
         self._offspring.to_csv(filename, index_label="xopt_index")
@@ -139,7 +140,8 @@ class CNSGAGenerator(Generator):
             return
 
         if filename is None:
-            filename = f"{self.name}_population_{xopt.utils.isotime(include_microseconds=True)}.csv"
+            timestamp = xopt.utils.isotime(include_microseconds=True).replace(":", "_")
+            filename = f"{self.name}_population_{timestamp}.csv"
             filename = os.path.join(self.output_path, filename)
 
         self.population.to_csv(filename, index_label="xopt_index")

{xopt-2.4.2 → xopt-2.4.4}/xopt/numerical_optimizer.py

@@ -15,7 +15,9 @@ class NumericalOptimizer(XoptBaseModel, ABC):
     model_config = ConfigDict(extra="forbid")
 
     @abstractmethod
-    def optimize(self, function: AcquisitionFunction, bounds: Tensor, n_candidates=1):
+    def optimize(
+        self, function: AcquisitionFunction, bounds: Tensor, n_candidates=1, **kwargs
+    ):
         """optimize a function to produce a number of candidate points that
         minimize the function"""
         pass
@@ -33,7 +35,7 @@ class LBFGSOptimizer(NumericalOptimizer):
 
     model_config = ConfigDict(validate_assignment=True)
 
-    def optimize(self, function, bounds, n_candidates=1):
+    def optimize(self, function, bounds, n_candidates=1, **kwargs):
         assert isinstance(bounds, Tensor)
         if len(bounds) != 2:
             raise ValueError("bounds must have the shape [2, ndim]")
@@ -46,6 +48,7 @@ class LBFGSOptimizer(NumericalOptimizer):
             num_restarts=self.n_restarts,
             timeout_sec=self.max_time,
             options={"maxiter": self.max_iter},
+            **kwargs,
         )
         return candidates
 

xopt-2.4.4/xopt/resources/test_functions/zdt.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+from xopt import VOCS
+
+
+def construct_zdt(n_dims, problem_index=1):
+    """construct Xopt versions of the multiobjective ZDT test problems"""
+    vocs = VOCS(
+        variables={f"x{i + 1}": [0, 1] for i in range(n_dims)},
+        objectives={"f1": "MINIMIZE", "f2": "MINIMIZE"},
+    )
+
+    if problem_index == 1:
+        # ZDT1
+        def evaluate(input_dict):
+            x = np.array([input_dict[f"x{i + 1}"] for i in range(n_dims)])
+
+            f1 = x[0]
+            g = 1 + (9 / (n_dims - 1)) * np.sum(x[1:])
+            h = 1 - np.sqrt(f1 / g)
+            f2 = g * h
+
+            return {"f1": f1, "f2": f2, "g": g}
+    elif problem_index == 2:
+
+        def evaluate(input_dict):
+            x = np.array([input_dict[f"x{i + 1}"] for i in range(n_dims)])
+
+            f1 = x[0]
+            g = 1 + (9 / (n_dims - 1)) * np.sum(x[1:])
+            h = 1 - (f1 / g) ** 2
+            f2 = g * h
+
+            return {"f1": f1, "f2": f2, "g": g}
+    elif problem_index == 3:
+
+        def evaluate(input_dict):
+            x = np.array([input_dict[f"x{i + 1}"] for i in range(n_dims)])
+
+            f1 = x[0]
+            g = 1 + (9 / (n_dims - 1)) * np.sum(x[1:])
+            h = 1 - np.sqrt(f1 / g) - (f1 / g) * np.sin(10 * np.pi * f1)
+            f2 = g * h
+
+            return {"f1": f1, "f2": f2, "g": g}
+    else:
+        raise NotImplementedError()
+
+    reference_point = {"f1": 1.0, "f2": 1.0}
+
+    return vocs, evaluate, reference_point