Merge pull request #281 from optimas-org/vocs

Implement VOCS interface

Author: RemiLehe

.github/workflows/unix-noax.yml

@@ -31,6 +31,7 @@ jobs:
         conda install numpy pandas pytorch cpuonly -c pytorch
         conda install -c conda-forge mpi4py mpich
         pip install .[test]
+        pip install git+https://github.com/campa-consortium/gest-api.git
         pip uninstall --yes ax-platform # Run without Ax
     - shell: bash -l {0}
       name: Run unit tests without Ax

.github/workflows/unix-openmpi.yml

@@ -32,6 +32,7 @@ jobs:
         conda install -c pytorch numpy pandas
         conda install -c conda-forge mpi4py openmpi=5.*
         pip install .[test]
+        pip install git+https://github.com/campa-consortium/gest-api.git
     - shell: bash -l {0}
       name: Run unit tests with openMPI
       run: |

.github/workflows/unix.yml

@@ -32,6 +32,7 @@ jobs:
         conda install -c pytorch numpy pandas
         conda install -c conda-forge mpi4py mpich
         pip install .[test]
+        pip install git+https://github.com/campa-consortium/gest-api.git
     - shell: bash -l {0}
       name: Run unit tests with MPICH
       run: |

doc/environment.yaml

@@ -11,6 +11,7 @@ dependencies:
     - matplotlib
     - nbsphinx
     - numpydoc
+    - git+https://github.com/campa-consortium/gest-api.git
     - pydata-sphinx-theme
     - sphinx-copybutton
     - sphinx-design

doc/source/user_guide/advanced_usage/build_gp_surrogates.ipynb

@@ -11,7 +11,7 @@
     "\n",
     "The :class:`~optimas.diagnostics.ExplorationDiagnostics` class\n",
     "provides a simple way of fitting a Gaussian process (GP) model to any of the\n",
-    "objectives or analyzed parameters of an ``optimas``\n",
+    "objectives or observables of an ``optimas``\n",
     ":class:`~optimas.explorations.Exploration`, independently of which generator\n",
     "was used. This is useful to get a better understanding of the underlying\n",
     "function, make predictions, etc.\n",
@@ -29,7 +29,7 @@
     "\n",
     "The following cell sets up and runs an optimization with two input parameters\n",
     "``x1`` and ``x2``, two objectives ``f1`` and ``f2``, and one additional\n",
-    "analyzed parameter ``p1``.\n",
+    "observable ``p1``.\n",
     "At each evaluation, the ``eval_func_sf_moo`` function is run,\n",
     "which assigns a value to each outcome parameter according to the analytical\n",
     "formulas\n",
@@ -55,9 +55,9 @@
    "source": [
     "import numpy as np\n",
     "from optimas.explorations import Exploration\n",
-    "from optimas.core import VaryingParameter, Objective, Parameter\n",
     "from optimas.generators import RandomSamplingGenerator\n",
     "from optimas.evaluators import FunctionEvaluator\n",
+    "from gest_api.vocs import VOCS\n",
     "\n",
     "\n",
     "def eval_func_sf_moo(input_params, output_params):\n",
@@ -70,17 +70,20 @@
     "    output_params[\"p1\"] = np.sin(x1) + np.cos(x2)\n",
     "\n",
     "\n",
-    "var1 = VaryingParameter(\"x1\", 0.0, 5.0)\n",
-    "var2 = VaryingParameter(\"x2\", -5.0, 5.0)\n",
-    "par1 = Parameter(\"p1\")\n",
-    "obj1 = Objective(\"f1\", minimize=True)\n",
-    "obj2 = Objective(\"f2\", minimize=False)\n",
-    "\n",
-    "gen = RandomSamplingGenerator(\n",
-    "    varying_parameters=[var1, var2],\n",
-    "    objectives=[obj1, obj2],\n",
-    "    analyzed_parameters=[par1],\n",
+    "# Create VOCS object defining variables, objectives, and observables.\n",
+    "vocs = VOCS(\n",
+    "    variables={\n",
+    "        \"x1\": [0.0, 5.0],\n",
+    "        \"x2\": [-5.0, 5.0],\n",
+    "    },\n",
+    "    objectives={\n",
+    "        \"f1\": \"MINIMIZE\",\n",
+    "        \"f2\": \"MAXIMIZE\",\n",
+    "    },\n",
+    "    observables=[\"p1\"],\n",
     ")\n",
+    "\n",
+    "gen = RandomSamplingGenerator(vocs=vocs)\n",
     "ev = FunctionEvaluator(function=eval_func_sf_moo)\n",
     "exploration = Exploration(\n",
     "    generator=gen,\n",
@@ -125,18 +128,18 @@
     "raw_mimetype": "text/restructuredtext"
    },
    "source": [
-    "Building a GP model of each objective and analyzed parameter\n",
-    "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
+    "Building a GP model of each objective and observable\n",
+    "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
     "\n",
     "To build a GP model, simply call\n",
     ":meth:`~optimas.diagnostics.Exploration.build_gp_model` on the diagnostics,\n",
     "indicating the name of the variable to which the model should be fitted.\n",
-    "This variable can be any ``objective`` or ``analyzed_parameter`` of the\n",
+    "This variable can be any ``objective`` or ``observable`` of the\n",
     "optimization.\n",
     "\n",
-    "Note that when building a surrogate model of an analyzed parameter, it is\n",
+    "Note that when building a surrogate model of an observable, it is\n",
     "required to provide a value to the ``minimize`` argument. This parameter\n",
-    "should therefore be ``True`` if lower values of the analyzed parameter are\n",
+    "should therefore be ``True`` if lower values of the observable are\n",
     "better than higher values. This information is necessary, e.g., for determining\n",
     "the best point in the model."
    ]
@@ -147,7 +150,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Build one model for each objective and analyzed parameter.\n",
+    "# Build one model for each objective and observable.\n",
     "f1_model = diags.build_gp_model(\"f1\")\n",
     "f2_model = diags.build_gp_model(\"f2\")\n",
     "p1_model = diags.build_gp_model(\"p1\", minimize=False)"

doc/source/user_guide/basic_usage/exploration_diagnostics.ipynb

@@ -125,16 +125,17 @@
     "import matplotlib.pyplot as plt\n",
     "\n",
     "fig, ax = plt.subplots()\n",
-    "vps = diags.varying_parameters\n",
+    "vocs = diags._exploration.generator.vocs\n",
     "df = diags.history\n",
-    "f1 = diags.objectives[0]\n",
-    "ax.axvline(vps[0].lower_bound)\n",
-    "ax.axvline(vps[0].upper_bound)\n",
-    "ax.set_xlabel(vps[0].name)\n",
-    "ax.axhline(vps[1].lower_bound)\n",
-    "ax.axhline(vps[1].upper_bound)\n",
-    "ax.set_ylabel(vps[1].name)\n",
-    "ax.scatter(df[vps[0].name], df[vps[1].name], c=df[f1.name])"
+    "vps = list(vocs.variables.keys())\n",
+    "f1 = list(vocs.objectives.keys())[0]\n",
+    "ax.axvline(vocs.variables[vps[0]].domain[0])\n",
+    "ax.axvline(vocs.variables[vps[0]].domain[1])\n",
+    "ax.set_xlabel(vps[0])\n",
+    "ax.axhline(vocs.variables[vps[1]].domain[0])\n",
+    "ax.axhline(vocs.variables[vps[1]].domain[1])\n",
+    "ax.set_ylabel(vps[1])\n",
+    "ax.scatter(df[vps[0]], df[vps[1]], c=df[f1])"
    ]
   }
  ],
@@ -144,5 +145,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

examples/astra/run_optimization_serial_ASTRA.py

@@ -9,34 +9,32 @@
 https://optimas.readthedocs.io/en/latest/index.html
 """
 
-from optimas.core import VaryingParameter, Objective, Parameter
 from optimas.generators import AxSingleFidelityGenerator
 from optimas.evaluators import TemplateEvaluator
 from optimas.explorations import Exploration
+from gest_api.vocs import VOCS
 from analysis_script import analyze_simulation
 
-# Create varying parameters and objectives.
+# Create VOCS object.
 # name of parameter, lower bound of values to be explored,
 # upper bound of values to be explored
-var_1 = VaryingParameter("RF_phase", -2.5, 2.5)
-var_2 = VaryingParameter("B_sol", 0.12, 0.38)
-# Objectives that will be minimized:
-obj_1 = Objective("bunch_length", minimize=True)
-obj_2 = Objective("emittance", minimize=True)
-# Additional example parameters that will be analyzed but are not used for the
-# optimization:
-em_x = Parameter("emittance_x")
-em_y = Parameter("emittance_y")
+vocs = VOCS(
+    variables={
+        "RF_phase": [-2.5, 2.5],
+        "B_sol": [0.12, 0.38],
+    },
+    objectives={
+        "bunch_length": "MINIMIZE",
+        "emittance": "MINIMIZE",
+    },
+    observables=["emittance_x", "emittance_y"],
+)
 
 # Create generator.
 # Pick the generator to be used, here Single-fidelity Bayesian optimization.
-# The analyzed_parameters are parameters that are calculated for each
-# simulation but not used for the optimization.
 gen = AxSingleFidelityGenerator(
-    varying_parameters=[var_1, var_2],
-    objectives=[obj_1, obj_2],
+    vocs=vocs,
     n_init=8,
-    analyzed_parameters=[em_x, em_y],
 )
 
 

examples/dummy/run_example.py

@@ -1,6 +1,6 @@
 """Basic example of parallel Bayesian optimization with Ax."""
 
-from optimas.core import VaryingParameter, Objective
+from gest_api.vocs import VOCS
 from optimas.generators import AxSingleFidelityGenerator
 from optimas.evaluators import TemplateEvaluator
 from optimas.explorations import Exploration
@@ -10,16 +10,16 @@ def analyze_simulation(simulation_directory, output_params):
     """Analyze the simulation output.
 
     This method analyzes the output generated by the simulation to
-    obtain the value of the optimization objective and other analyzed
-    parameters, if specified. The value of these parameters has to be
-    given to the `output_params` dictionary.
+    obtain the value of the optimization objective and other observables.
+    The value of these parameters has to be given to the
+    `output_params` dictionary.
 
     Parameters
     ----------
     simulation_directory : str
         Path to the simulation folder where the output was generated.
     output_params : dict
-        Dictionary where the value of the objectives and analyzed parameters
+        Dictionary where the value of the objectives and observables
         will be stored. There is one entry per parameter, where the key
         is the name of the parameter given by the user.
 
@@ -37,16 +37,18 @@ def analyze_simulation(simulation_directory, output_params):
     return output_params
 
 
-# Create varying parameters and objectives.
-var_1 = VaryingParameter("x0", 0.0, 15.0)
-var_2 = VaryingParameter("x1", 0.0, 15.0)
-obj = Objective("f", minimize=True)
+# Create VOCS object defining variables, objectives.
+vocs = VOCS(
+    variables={
+        "x0": [0.0, 15.0],
+        "x1": [0.0, 15.0],
+    },
+    objectives={"f": "MINIMIZE"},
+)
 
 
 # Create generator.
-gen = AxSingleFidelityGenerator(
-    varying_parameters=[var_1, var_2], objectives=[obj], n_init=2
-)
+gen = AxSingleFidelityGenerator(vocs=vocs, n_init=2)
 
 
 # Create evaluator.

examples/dummy_grid_sampling/run_example.py

@@ -1,6 +1,6 @@
 """Basic example of parallel grid sampling with simulations."""
 
-from optimas.core import VaryingParameter, Objective
+from gest_api.vocs import VOCS
 from optimas.generators import GridSamplingGenerator
 from optimas.evaluators import TemplateEvaluator
 from optimas.explorations import Exploration
@@ -10,16 +10,16 @@ def analyze_simulation(simulation_directory, output_params):
     """Analyze the simulation output.
 
     This method analyzes the output generated by the simulation to
-    obtain the value of the optimization objective and other analyzed
-    parameters, if specified. The value of these parameters has to be
-    given to the `output_params` dictionary.
+    obtain the value of the optimization objective and other observables.
+    The value of these parameters has to be given to the
+    `output_params` dictionary.
 
     Parameters
     ----------
     simulation_directory : str
         Path to the simulation folder where the output was generated.
     output_params : dict
-        Dictionary where the value of the objectives and analyzed parameters
+        Dictionary where the value of the objectives and observables
         will be stored. There is one entry per parameter, where the key
         is the name of the parameter given by the user.
 
@@ -37,16 +37,18 @@ def analyze_simulation(simulation_directory, output_params):
     return output_params
 
 
-# Create varying parameters and objectives.
-var_1 = VaryingParameter("x0", 0.0, 15.0)
-var_2 = VaryingParameter("x1", 0.0, 15.0)
-obj = Objective("f")
+# Create VOCS object defining variables, objectives.
+vocs = VOCS(
+    variables={
+        "x0": [0.0, 15.0],
+        "x1": [0.0, 15.0],
+    },
+    objectives={"f": "MAXIMIZE"},
+)
 
 
 # Create generator.
-gen = GridSamplingGenerator(
-    varying_parameters=[var_1, var_2], objectives=[obj], n_steps=[5, 7]
-)
+gen = GridSamplingGenerator(vocs=vocs, n_steps=[5, 7])
 
 
 # Create evaluator.

examples/dummy_line_sampling/run_example.py

@@ -1,6 +1,6 @@
 """Basic example of parallel line sampling with simulations."""
 
-from optimas.core import VaryingParameter, Objective
+from gest_api.vocs import VOCS, ContinuousVariable
 from optimas.generators import LineSamplingGenerator
 from optimas.evaluators import TemplateEvaluator
 from optimas.explorations import Exploration
@@ -10,16 +10,16 @@ def analyze_simulation(simulation_directory, output_params):
     """Analyze the simulation output.
 
     This method analyzes the output generated by the simulation to
-    obtain the value of the optimization objective and other analyzed
-    parameters, if specified. The value of these parameters has to be
-    given to the `output_params` dictionary.
+    obtain the value of the optimization objective and other observables.
+    The value of these parameters has to be given to the
+    `output_params` dictionary.
 
     Parameters
     ----------
     simulation_directory : str
         Path to the simulation folder where the output was generated.
     output_params : dict
-        Dictionary where the value of the objectives and analyzed parameters
+        Dictionary where the value of the objectives and observables
         will be stored. There is one entry per parameter, where the key
         is the name of the parameter given by the user.
 
@@ -37,16 +37,18 @@ def analyze_simulation(simulation_directory, output_params):
     return output_params
 
 
-# Create varying parameters and objectives.
-var_1 = VaryingParameter("x0", 0.0, 15.0, default_value=5.0)
-var_2 = VaryingParameter("x1", 0.0, 15.0, default_value=6.0)
-obj = Objective("f")
+# Create VOCS object defining variables, objectives.
+vocs = VOCS(
+    variables={
+        "x0": ContinuousVariable(domain=[0.0, 15.0], default_value=5.0),
+        "x1": ContinuousVariable(domain=[0.0, 15.0], default_value=6.0),
+    },
+    objectives={"f": "MAXIMIZE"},
+)
 
 
 # Create generator.
-gen = LineSamplingGenerator(
-    varying_parameters=[var_1, var_2], objectives=[obj], n_steps=[5, 7]
-)
+gen = LineSamplingGenerator(vocs=vocs, n_steps=[5, 7])
 
 
 # Create evaluator.