example/tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07fdf86d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "\n",
    "import numpy as np\n",
    "from shutil import rmtree\n",
    "\n",
    "def clean():\n",
    "    for name in (\"my-experiment\", \"ioh_data\"):\n",
    "        for path in glob.glob(f\"{name}*\"):\n",
    "            if os.path.isfile(path):\n",
    "                os.remove(path)\n",
    "            if os.path.isdir(path):\n",
    "                rmtree(path, ignore_errors=True)\n",
    "\n",
    "def ls(p=\"./\"):\n",
    "    for obj in os.listdir(os.path.normpath(p)):\n",
    "        print(obj)\n",
    "\n",
    "def cat(f):\n",
    "    with open(os.path.normpath(f)) as h:\n",
    "        print(h.read())\n",
    "\n",
    "clean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41cf4c7e-1813-4414-9e38-e1efc3ad622d",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import ioh\n",
    "%pip show ioh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f8621d",
   "metadata": {},
   "source": [
    "# Problem\n",
    "In ioh, everything revolves around the `problem` class, which exists for both `Real` and `Integer` types for continious and discrete problems resp. These classes are wrappers around an objective function, and can be used to interact with the various other parts of iohexperimenter. \n",
    "\n",
    "We have a number of objective functions already implemented for convenience, which includes the objective functions from the BBOB single objective benchmark by the COCO platform for the continous case and the PBO benchmark functions for the discrete case.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cbe3df2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# A list of problems can be accessed via the base classes\n",
    "ioh.problem.Real.problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e9d10a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# In order to instantiate a problem instance, we can do the following:\n",
    "problem = ioh.get_problem(\n",
    "    \"Sphere\", \n",
    "    instance=1,\n",
    "    dimension=10,\n",
    "    problem_type=\"Real\"\n",
    ")\n",
    "problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0c8733f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The problem class includes information about the problem, which can be retrieved via the meta_data accessor\n",
    "problem.meta_data.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0264ec1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The current state of the problem, e.g. the number of evaluations, best seen points etc. are stored in the problems state.\n",
    "problem.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50ac1487",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Every problem as has a simple box-bounds associcated\n",
    "problem.bounds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "372f25a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can access the contraint information of the problem\n",
    "x0 = np.random.uniform(problem.bounds.lb, problem.bounds.ub)\n",
    "\n",
    "# Evaluation happens like a 'normal' objective function would\n",
    "problem(x0)\n",
    "\n",
    "# Whenever the problem is evaluated, the state changes\n",
    "problem.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f26c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we want to perform multiple runs with the same objective function, after every run, the problem has to be reset, \n",
    "# such that the internal state reflects the current run.\n",
    "def run_experiment(problem, algorithm, n_runs=5):\n",
    "    for run in range(n_runs):\n",
    "        \n",
    "        # Run the algorithm on the problem\n",
    "        algorithm(problem)\n",
    "\n",
    "        # print the best found for this run\n",
    "        print(f\"run: {run+1} - best found:{problem.state.current_best.y: .3f}\")\n",
    "\n",
    "        # Reset the problem\n",
    "        problem.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "16d775ef",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (633907483.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn [1], line 3\u001b[0;36m\u001b[0m\n\u001b[0;31m    def __init__(self, n, length = 0.0)\u001b[0m\n\u001b[0m                                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "class RandomSearch:\n",
    "    'Simple random search algorithm'\n",
    "    def __init__(self, n: int, length: float = 0.0):\n",
    "        self.n: int = n\n",
    "        self.length: float = length\n",
    "        \n",
    "    def __call__(self, problem: ioh.problem.Real) -> None:\n",
    "        'Evaluate the problem n times with a randomly generated solution'\n",
    "        \n",
    "        for _ in range(self.n):\n",
    "            # We can use the problems bounds accessor to get information about the problem bounds\n",
    "            x = np.random.uniform(problem.bounds.lb, problem.bounds.ub)\n",
    "            self.length = np.linalg.norm(x)\n",
    "            \n",
    "            problem(x)  \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04699081-e241-493f-8f51-85f14c137df1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# using the random search algorithm, we can then run a simple experiment\n",
    "run_experiment(problem, RandomSearch(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff1d41c0",
   "metadata": {},
   "source": [
    "# Adding custom problems\n",
    "As the list of already implemented problems might not contains the objective function you would like to analyze and benchmark, we include an easy to use interface to wrap your benchmark function into an iohexperimenter `problem` object. \n",
    "\n",
    "Currently, only single objective functions are supported, so the only requirement on the function is its signature, which should take a single array parameter, and return a single floating point number $f(\\mathbf{x}) \\mapsto \\mathbb{R}$.\n",
    "\n",
    "In this example we will add the function (Styblinski–Tang):\n",
    "\n",
    "$f(\\mathbf{x}) = \\frac{\\sum_{i=1}^n x_i^4 - 16x_i^2 + 5x_i}{2}$\n",
    "\n",
    "defined on $[-5, 5]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86f32b7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def styblinski_tang(x: np.ndarray) -> float:\n",
    "    return np.sum(np.power(x, 4) - (16 * np.power(x, 2)) + (5 * x)) / 2\n",
    "\n",
    "\n",
    "styblinski_tang(np.array([-2.903534]*10)) # global minima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb23a7d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can wrap this function in ioh, as this is is a continous function, we use wrap_real_problem:\n",
    "ioh.problem.wrap_real_problem(\n",
    "    styblinski_tang,                                     # Handle to the function\n",
    "    name=\"StyblinskiTang\",                               # Name to be used when instantiating\n",
    "    optimization_type=ioh.OptimizationType.MIN, # Specify that we want to minimize\n",
    "    lb=-5,                                               # The lower bound\n",
    "    ub=5,                                                # The upper bound\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f76f8aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can create an instance of this problem, wrapped in ioh\n",
    "problem = ioh.get_problem(\"StyblinskiTang\", dimension=10)\n",
    "problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcedf9d9-29f9-4292-a7a7-d16a8bfdae48",
   "metadata": {},
   "outputs": [],
   "source": [
    "problem(np.array([-2.903534]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6ef70d4",
   "metadata": {},
   "source": [
    "## Specifying instances\n",
    "When doing bechmarking of custom problems, it can often be usefull to look at different instances of the same problem, but that perform some transformation the parameter or objective space, to test if an algorithm is invariant to such transformations. \n",
    "\n",
    "Here we add the following transformations to the aforementioned objective function:\n",
    "\n",
    "$T_x(\\mathbf{x}, c) = \\mathbf{x} + c$\n",
    "\n",
    "$T_y(y, c) = y * c$\n",
    "\n",
    "We can do this by providing transformation functions to the `wrap_problem` interface. Note that these take two parameters:\n",
    " 1. The operand they function on, which are the variables for the variables transformation and objective function value for the objective transformation. \n",
    " 2. An integer identifier of the instance id which is currently used. This allows you to specify alternate behavior for different instances.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "200870f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables transformation R^d -> R^d\n",
    "def transform_variables(x: np.ndarray, instance_id:int) -> np.ndarray:\n",
    "    c = (instance_id - 1) * .5\n",
    "    return x + c\n",
    "\n",
    "# Objective transformation R -> R\n",
    "def transform_objectives(y: float, instance_id:int) -> float:\n",
    "    c = instance_id\n",
    "    return y * c\n",
    "\n",
    "# Note that we can overwrite a previously defined problem by calling wrap_real_problem again with the same name\n",
    "ioh.problem.wrap_real_problem(\n",
    "    styblinski_tang,                                     \n",
    "    name=\"StyblinskiTang\",                               \n",
    "    optimization_type=ioh.OptimizationType.MIN, \n",
    "    lb=-5,                                               \n",
    "    ub=5,      \n",
    "    \n",
    "    # Adding the transformation functions\n",
    "    transform_variables=transform_variables,     \n",
    "    transform_objectives=transform_objectives\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b86e87e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can now create different instances of the same problem\n",
    "instance1 = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=10)\n",
    "instance2 = ioh.get_problem(\"StyblinskiTang\", instance=2, dimension=10)\n",
    "instance1, instance2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e20b5d6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that when evaluating with the same point, each instance gives a different (transformed value)\n",
    "instance1(x0), instance2(x0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "021fac60",
   "metadata": {},
   "source": [
    "# Logging data\n",
    "The default usage of IOHExperimenter is in generating logs of benchmarking experiments which can be analyzed in IOHAnalyzer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5d4b73d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "logger = ioh.logger.Analyzer(\n",
    "    root=os.getcwd(),                  # Store data in the current working directory\n",
    "    folder_name=\"my-experiment\",       # in a folder named: 'my-experiment'\n",
    "    algorithm_name=\"random-search\",    # meta-data for the algorithm used to generate these results\n",
    "    store_positions=True               # store x-variables in the logged files\n",
    ")\n",
    "\n",
    "# this automatically creates a folder 'my-experiment' in the current working directory\n",
    "# if the folder already exists, it will given an additional number to make the name unique\n",
    "logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e008c25a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "276c6a7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In order to log data for a problem, we only have to attach it to a logger\n",
    "problem = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=2)\n",
    "problem.attach_logger(logger)\n",
    "\n",
    "# We can then run the random search as before, only now all data will be logged to a file\n",
    "run_experiment(problem, RandomSearch(10), n_runs=1)\n",
    "\n",
    "# Force logger to flush and write files. (> v0.3.3)\n",
    "# This is only required when using the logger in an interactive context, such as this jupyter notebook.\n",
    "# Otherwise, the destructor, which is called on exit of the python interpreter, forces such a write automatically.\n",
    "logger.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4207c311",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat(\"my-experiment/IOHprofiler_f25_StyblinskiTang.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d820be5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat(\"my-experiment/data_f25_StyblinskiTang/IOHprofiler_f25_DIM2.dat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da18cd9",
   "metadata": {},
   "source": [
    "## Triggers \n",
    "The default behavior of the `Analyzer` logger is to log data only when there is an improvement of the objective value. We can change this behaviour, by specifying one or more triggers, which are logical operators, which when one of them evaluates to True, will cause data to be logged.\n",
    "\n",
    "We provide a number of trigger variants which can be use to customize the logging. In the following example, a trigger is defined which evaluates to True, every 3 function evaluations. It is combined with a trigger for improvement, so data will be logged on every 3rd function evaluation, or when there is an observed improvement of the objective value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3673e717",
   "metadata": {},
   "outputs": [],
   "source": [
    "triggers = [\n",
    "    ioh.logger.trigger.Each(3),\n",
    "    ioh.logger.trigger.OnImprovement()\n",
    "]\n",
    "\n",
    "logger = ioh.logger.Analyzer(\n",
    "    root=os.getcwd(),                  \n",
    "    folder_name=\"my-experiment\",       \n",
    "    algorithm_name=\"random-search\",    \n",
    "    store_positions=True,\n",
    "    \n",
    "    # Add the triggers to the logger\n",
    "    triggers = triggers\n",
    ")\n",
    "\n",
    "logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8720851",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Rerun the same experiment as before\n",
    "problem = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=2)\n",
    "problem.attach_logger(logger)\n",
    "run_experiment(problem, RandomSearch(10), n_runs=1)\n",
    "logger.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eb16b3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can now see that data is logged either if there is improvement, or on every 3rd evaluation\n",
    "cat(\"my-experiment-1/data_f25_StyblinskiTang/IOHprofiler_f25_DIM2.dat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ebb4607",
   "metadata": {},
   "source": [
    "## Properties\n",
    "If we want to keep track of any dynamic parameters a given algorithm might have, we can use properties to log them to the output files. \n",
    "\n",
    "In the following example, we will track the length parameters for the RandomSearch algorithm, which is added for illustrative purpoposes, and changes for every function evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3a125d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RandomSearch has a length parameter, which is dynamic\n",
    "algorithm = RandomSearch(10)\n",
    "\n",
    "# Creating a new logger\n",
    "logger = ioh.logger.Analyzer(\n",
    "    root=os.getcwd(),                  \n",
    "    folder_name=\"my-experiment\",       \n",
    "    algorithm_name=\"random-search\",    \n",
    "    store_positions=True\n",
    ")\n",
    "\n",
    "# Before we attach a problem, we tell the logger to keep track of the length parameter on algorithm\n",
    "logger.watch(algorithm, \"length\")\n",
    "\n",
    "# We can now again run the same experiment \n",
    "problem = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=2)\n",
    "\n",
    "problem.attach_logger(logger)\n",
    "run_experiment(problem, algorithm, n_runs=1)\n",
    "logger.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "103e13cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note the additional length parameter being logged \n",
    "cat(\"my-experiment-2/data_f25_StyblinskiTang/IOHprofiler_f25_DIM2.dat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e2642f5",
   "metadata": {},
   "source": [
    "# Alternate logging behaviour\n",
    "We provide a number of different loggers in addition to the `Analyzer` logger, which include:\n",
    " - `FlatFile` which logs data to a simple csv file\n",
    " - `Store` which keeps all of the stored data in memory\n",
    " - `EAF/EAH` which compute Empirical Attainment Function/Histogram statistics on the fly\n",
    "\n",
    "You can define your own custom logging behavoir by inheriting from the `AbstractLogger` class. The only required part of the interface is that you override the `__call__` operator, which takes a single `ioh.LogInfo` parameter. In this method you should define your desired behavior. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bad5d7de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple logger that logs data using the python logging module whenever it is triggeredd\n",
    "class MyLogger(ioh.logger.AbstractLogger):\n",
    "    def __call__(self, log_info: ioh.LogInfo):\n",
    "        print(f\"triggered! y: {log_info.y}\")\n",
    "\n",
    "\n",
    "# The abstract logger takes two parameters, triggers and properties\n",
    "mylogger = MyLogger(triggers=[ioh.logger.trigger.ALWAYS])\n",
    "\n",
    "problem = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=2)\n",
    "problem.attach_logger(mylogger)\n",
    "\n",
    "run_experiment(problem, RandomSearch(10), 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b163d3e",
   "metadata": {},
   "source": [
    "# Standardized Experimental Setup (Python only)\n",
    "In Python, we provide the `Experiment` class which can be used to easily run a given algorithm over a larger number of problems. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84f169dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment = ioh.Experiment(\n",
    "    algorithm = RandomSearch(10), # An algorithm instance\n",
    "    fids = [1, 25],               # the id's of the problems we want to test\n",
    "    iids = [1, 10],               # the instances \n",
    "    dims = [2, 10],               # the dimensions\n",
    "    reps = 3,                     # the number of runs,\n",
    "    zip_output = True       \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d116207",
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3adf7ee0",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls(\"ioh_data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "541c3f60",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat(\"ioh_data/IOHprofiler_f25_StyblinskiTang.info\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "424db49c",
   "metadata": {},
   "outputs": [],
   "source": [
    "clean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "675c09cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# cleanup\n",
    "rmtree(\"my-experiment\", ignore_errors=True)\n",
    "rmtree(\"ioh_data\", ignore_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b194f1",
   "metadata": {},
   "source": [
    "# Working with constraints (> v0.3.3)\n",
    "Every problem has a set of constraints associated with it. For most of the currently implemented problems, this is an empty set by default. However, we can modify this set, and add arbitrary functions as constraints. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1165fc20",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We take the Shere function as example\n",
    "p = ioh.get_problem(\"Sphere\", 1, 2)\n",
    "\n",
    "# The set of constraints is empty by default\n",
    "p.constraints\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67e63ea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can turn the bounds of the problem into a contraint\n",
    "print(p.bounds)\n",
    "\n",
    "# By default, bounds are not enforced, so violating them changes nothing to the returned objective function value\n",
    "p([10, 10])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77a523d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For bound constraints, violation is computed as the sum of the squared violation per component\n",
    "p.enforce_bounds(\n",
    "    how=ioh.ConstraintEnforcement.SOFT, # The enforcement strategy: SOFT ensure penalization on violation by a penalty (y + p)\n",
    "    weight=1.0,                         # Penaly p is computed as: weight * violation ^ exponent                       \n",
    "    exponent=1.0,                        \n",
    ")\n",
    "# Now the bounds are in the constraint set\n",
    "p.constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b1bc2cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can now observe the added penalty term\n",
    "p([10, 10]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cd91c34",
   "metadata": {},
   "outputs": [],
   "source": [
    "# There a several strategies that modify a constraint's behavoir:\n",
    "types = (\n",
    "    ioh.ConstraintEnforcement.NOT,       # Don't calulate the constraint function\n",
    "    ioh.ConstraintEnforcement.HIDDEN,    # Calulate the constraint, but don't penalize\n",
    "    ioh.ConstraintEnforcement.SOFT,      # Calculate both constraint and objective function value y, and penalize as y + p\n",
    "    ioh.ConstraintEnforcement.HARD,      # Calulate the constraint, if there is violation, don't calculate y, and only return p\n",
    ")\n",
    "for strategy in types:\n",
    "    p.enforce_bounds(how=strategy, weight=1.0, exponent=1.0)\n",
    "    print(strategy, p([10, 10]), p.constraints.violation())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d436d64c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that when we use a HARD method, the objective value is actually lower (50.0) than the actual objective value (298.96)\n",
    "# This is because we didn't change any of the other parameters, that influence the penalty. Normally, with HARD constraints, we \n",
    "# want to also make sure that we return a y-value that is infeasible. We can do this by changing the weight and/or exponent parameters.\n",
    "p.enforce_bounds(\n",
    "    how=ioh.ConstraintEnforcement.HARD, \n",
    "    weight=float(\"inf\"),                \n",
    "    exponent=1.0                        \n",
    ")\n",
    "\n",
    "# Any infeasible solution gets an infinity value\n",
    "p([10, 10])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "967caa00",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that the actual objective function is not called for infeasible points with HARD constraints:\n",
    "p.state.y_unconstrained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08f50677",
   "metadata": {},
   "outputs": [],
   "source": [
    "# If we pass a feasible point it is evaluated\n",
    "p([1.,-1.]), p.state.y_unconstrained"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cd768e3",
   "metadata": {},
   "source": [
    "### Custom constraint functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74a98dc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can create custom constraint functions, which can be 'just' functions that check something on x.\n",
    "# Such functions should return a nonzero floating point value when there is violation, and zero otherwise. \n",
    "\n",
    "def is_x_ordered(x: np.ndarray) -> float:\n",
    "    '''Checks that xi < xi+1'''\n",
    "\n",
    "    return 1. - (np.diff(x) > 0).all().astype(float)\n",
    "\n",
    "# x is not ordered, so there is a violation (1.)\n",
    "print(is_x_ordered([10, 1, 3]))\n",
    "\n",
    "# x is ordered, so there is no violation (0.)\n",
    "print(is_x_ordered([1, 3, 10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3375039",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can add such a function to an arbitary problem as constraint like so:\n",
    "constraint = ioh.RealConstraint(is_x_ordered, name=\"is_x_ordered\", weight=100_000)\n",
    "\n",
    "p = ioh.get_problem(\"Sphere\", 1, 3)\n",
    "p.add_constraint(constraint)\n",
    "\n",
    "# Note that it gets added to the list of constraints. \n",
    "p.constraints "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4927b59",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p([4, 1, 3]))  # The penalty gets added \n",
    "print(p([1, 3, 4]))  # The penalty doesn't get added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1991b5b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can remove the contraint again\n",
    "p.remove_constraint(constraint)\n",
    "p.constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00ad93ab",
   "metadata": {},
   "source": [
    "### Wrapping constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ae27408",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also add constraints to the problem definition to wrap problem\n",
    "ioh.problem.wrap_real_problem(\n",
    "    styblinski_tang,                                     \n",
    "    name=\"StyblinskiTang\",                               \n",
    "    optimization_type=ioh.OptimizationType.MIN, \n",
    "    lb=-5,                                              \n",
    "    ub=5,   \n",
    "    # Adding the constraints                                            \n",
    "    constraints=[constraint]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2150cffd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now if we instantiate an instance of the Styblinski-Tang function, is has the x_ordering constraint added automatically\n",
    "p = ioh.get_problem(\"StyblinskiTang\", 1, 5)\n",
    "p.constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23e11cb6",
   "metadata": {},
   "source": [
    "### Logging constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bf8b3b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a new logger\n",
    "logger = ioh.logger.Analyzer(\n",
    "    root=os.getcwd(),                  \n",
    "    folder_name=\"my-experiment\",       \n",
    "    algorithm_name=\"random-search\",    \n",
    "    store_positions=True,\n",
    "    \n",
    "    # We add the constraint properties to the list of logged items\n",
    "    # Note that these properties are aggregated values for ALL applied constrains, \n",
    "    # So when you have more than one constraint added to a problem, these values will be the sums\n",
    "    # of all the applied constraints. \n",
    "    additional_properties=[\n",
    "        ioh.logger.property.CURRENTY,   # The constrained y-value, by default only the untransformed & unconstraint y\n",
    "                                        # value is logged. \n",
    "        ioh.logger.property.VIOLATION,  # The violation value\n",
    "        ioh.logger.property.PENALTY     # The applied penalty\n",
    "    ]\n",
    ")\n",
    "\n",
    "# We can now again run the same experiment \n",
    "problem = ioh.get_problem(\"StyblinskiTang\", instance=1, dimension=2)\n",
    "\n",
    "problem.attach_logger(logger)\n",
    "run_experiment(problem, RandomSearch(10), n_runs=1)\n",
    "logger.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34932bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat(\"my-experiment/IOHprofiler_f25_StyblinskiTang.json\")\n",
    "cat(\"my-experiment/data_f25_StyblinskiTang/IOHprofiler_f25_DIM2.dat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f8d16a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "clean()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 ('venv': venv)",
   "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.8.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "4df11b7c6bc988e752c29608807e53948928701720d1ef956f7ac1d1074d71bd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}