examples/optimisation/first-example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimisation: First example\n",
    "\n",
    "This example shows you how to run an optimisation with Pints.\n",
    "\n",
    "We will start very simple, mimising a general error function and maximising a likelihood, before moving on to the _time series problems_ that PINTS specialises in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we import the `pints` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need an [ErrorMeasure](https://pints.readthedocs.io/en/stable/error_measures.html) to minimise, or alternatively a [LogPDF](https://pints.readthedocs.io/en/stable/log_pdfs.html#pints.LogPDF) (representing a distribution) to maximise.\n",
    "\n",
    "For now, we will define a very simple parabola:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n",
      "25\n",
      "0.009999999999999929\n"
     ]
    }
   ],
   "source": [
    "class MyError(pints.ErrorMeasure):\n",
    "    \n",
    "    def n_parameters(self):\n",
    "        # This method tells the optimiser the dimensionality of the problem\n",
    "        return 1\n",
    "    \n",
    "    def __call__(self, p):\n",
    "        # This method accepts a vector of n_parameters parameters, and\n",
    "        # should return a scalar error.\n",
    "        x = p[0]\n",
    "        return (x - 10)**2\n",
    "    \n",
    "error = MyError()\n",
    "print(error([1]))\n",
    "print(error([5]))\n",
    "print(error([9.9]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This slightly strange looking class is a Python \"[callable](https://docs.python.org/3/reference/datamodel.html#object.__call__)\": a class that can be called like a function.\n",
    "These are used throughout PINTS, because they provide the benefits of objects while simultaneously acting as the mathematical \"functions\" we usually think about in optimisation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we call on PINTS to find the parameter vector (in this case containing just a single value) that minimises our error function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Nelder-Mead\n",
      "Running in sequential mode.\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     2      81        81         0:00.0\n",
      "1     3      80.1025   80.1025    0:00.0\n",
      "2     4      80.1025   80.1025    0:00.0\n",
      "3     5      78.3225   78.3225    0:00.0\n",
      "20    22     0.0625    0.0625     0:00.0\n",
      "40    42     1.14e-28  1.14e-28   0:00.0\n",
      "60    62     1.14e-28  1.14e-28   0:00.0\n",
      "80    82     1.14e-28  1.14e-28   0:00.0\n",
      "100   102    1.14e-28  1.14e-28   0:00.0\n",
      "120   122    0         0          0:00.0\n",
      "140   142    0         0          0:00.0\n",
      "160   162    0         0          0:00.0\n",
      "180   182    0         0          0:00.0\n",
      "200   202    0         0          0:00.0\n",
      "220   222    0         0          0:00.0\n",
      "228   229    0         0          0:00.0\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "# Define an initial guess\n",
    "x0 = [1]\n",
    "\n",
    "# Run an optimisation\n",
    "found_parameters, found_error = pints.optimise(error, x0, method=pints.NelderMead)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now have a look at the obtained parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtained parameters [10.]\n"
     ]
    }
   ],
   "source": [
    "print('Obtained parameters', found_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As well as the final error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final parameters 0.0\n"
     ]
    }
   ],
   "source": [
    "print('Final parameters', found_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can look at the original call in some more detail:\n",
    "\n",
    "```\n",
    "pints.optimise(error, x0, method=pints.NelderMead)\n",
    "```\n",
    "\n",
    "This calls the short-hand function `optimise` (below we will use a more verbose but far more flexible syntax) with the `error` we defined, our starting position `x0`, and a `method` argument.\n",
    "The `method` argument specifies the optimisation algorithm to use, and should be a class that implements the [pints.Optimiser](https://pints.readthedocs.io/en/stable/optimisers/base_classes.html#pints.Optimiser) interface.\n",
    "A list of optimisers included in PINTS [can be found here](https://pints.readthedocs.io/en/stable/optimisers/index.html).\n",
    "For this example we used the \"[Nelder-Mead](https://pints.readthedocs.io/en/stable/optimisers/nelder_mead.html) simplex algorithm\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll now take a quick look at the printed output:\n",
    "\n",
    "```\n",
    "Minimising error measure\n",
    "Using Nelder-Mead\n",
    "Running in sequential mode.\n",
    "```\n",
    "\n",
    "These first few lines tell us what PINTS is about to do: it will minimise an error measure, using the method called \"Nelder-Mead\", and it will run in \"sequential mode\".\n",
    "This last bit means that only a single CPU process will be used.\n",
    "\n",
    "Next, we get a log of the optimiser's progress:\n",
    "```\n",
    "Iter. Eval. Best      Current   Time    \n",
    "0     2      81        81         0:00.0\n",
    "1     3      80.1025   80.1025    0:00.0\n",
    "```\n",
    "The first two numbers are the iteration count and the number of evaluations of the error function.\n",
    "Here we can see that we needed two evaluations for the initial iteration, but then just one for the next.\n",
    "\n",
    "The next two numbers show the best obtained \"score\" (i.e. the lowest error) and the current score.\n",
    "For Nelder-Mead, the best score will always be the current score, but more complex methods allow exploratory steps in which the error temporarily becomes higher.\n",
    "\n",
    "The final field shows the elapsed time in hours, minutes, and seconds.\n",
    "\n",
    "Finally, the method prints\n",
    "```\n",
    "100   102    1.14e-28  1.14e-28   0:00.0\n",
    "120   122    0         0          0:00.0\n",
    "140   142    0         0          0:00.0\n",
    "160   162    0         0          0:00.0\n",
    "180   182    0         0          0:00.0\n",
    "200   202    0         0          0:00.0\n",
    "220   222    0         0          0:00.0\n",
    "228   229    0         0          0:00.0\n",
    "Halting: No significant change for 200 iterations.\n",
    "```\n",
    "\n",
    "We see that the error went to 0, and then stayed at 0 for 200 iterations, causing the optimisation to halt.\n",
    "Below, we will see how we can choose different _stopping criteria_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximising a likelihood\n",
    "\n",
    "When working in a statistical context, instead of _minimising_ some error function, you might want to define a _likelihood_ to _maximise_.\n",
    "PINTS facilitates this through the [LogPDF](https://pints.readthedocs.io/en/stable/log_pdfs.html#pints.LogPDF) interface, which is used to represent probability density functions including likelihoods, priors, and Bayesian posterior distributions.\n",
    "All methods that accept `ErrorMeasures` will accept `LogPDF` instances as well, and automatically switch from minimising to maximising.\n",
    "\n",
    "For example, we can define a Normal distribution centered around 5, and use the same method as above to find this optimum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximising LogPDF\n",
      "Using Nelder-Mead\n",
      "Running in sequential mode.\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     2     -13.41894 -13.41894   0:00.0\n",
      "1     3     -13.41894 -13.41894   0:00.0\n",
      "2     4     -13.41894 -13.41894   0:00.0\n",
      "3     5     -8.918939 -8.918939   0:00.0\n",
      "20    22    -0.919    -0.919      0:00.0\n",
      "40    42    -0.919    -0.919      0:00.0\n",
      "60    62    -0.919    -0.919      0:00.0\n",
      "80    82    -0.919    -0.919      0:00.0\n",
      "100   102   -0.919    -0.919      0:00.0\n",
      "120   122   -0.919    -0.919      0:00.0\n",
      "140   142   -0.919    -0.919      0:00.0\n",
      "160   162   -0.919    -0.919      0:00.0\n",
      "180   182   -0.919    -0.919      0:00.0\n",
      "200   202   -0.919    -0.919      0:00.0\n",
      "208   209   -0.919    -0.919      0:00.0\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "class NormalLogPDF(pints.LogPDF):\n",
    "\n",
    "    def n_parameters(self):\n",
    "        # This method tells the optimiser the dimensionality of the problem\n",
    "        return 1\n",
    "\n",
    "    def __call__(self, p):\n",
    "        # This method accepts a vector of n_parameters parameters, and\n",
    "        # should return a scalar log-likelihood.\n",
    "        return -0.5 * np.log(2 * np.pi) -0.5 * (p[0] - 5)**2\n",
    "\n",
    "\n",
    "# Create a logpdf\n",
    "logpdf = NormalLogPDF()\n",
    "\n",
    "# Define an initial guess\n",
    "x0 = [10]\n",
    "\n",
    "# Run an optimisation\n",
    "found_parameters, found_logpdf = pints.optimise(logpdf, x0, method=pints.NelderMead)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And as before we can check that it found the expected result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obtained parameters [5.]\n"
     ]
    }
   ],
   "source": [
    "print('Obtained parameters', found_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimising more complicated \"functions\"\n",
    "\n",
    "Using the methods above, any callable class that implements the [ErrorMeasure](https://pints.readthedocs.io/en/stable/error_measures.html#pints.ErrorMeasure) interface or [LogPDF](https://pints.readthedocs.io/en/stable/log_pdfs.html#pints.LogPDF) interface can be optimised.\n",
    "By design, this can be quite a complicated class, as shown in this pseudo-code example:\n",
    "\n",
    "```\n",
    "class ARealisticError(pints.ErrorMeasure):\n",
    "\n",
    "    def __init__(self):\n",
    "        Initialise fast-running external library\n",
    "        Initialise parallelisation\n",
    "    \n",
    "    def n_parameters(self):\n",
    "        return high number of parameters\n",
    "    \n",
    "    def __call__(self, p):\n",
    "        Make call to external library, return error\n",
    "```\n",
    "\n",
    "This way, arbitrarily complex \"error functions\" can be defined and optimised.\n",
    "\n",
    "However, PINTS specialises in cases where the error function (or likelihood) is calculated as the difference between two _time series_.\n",
    "These are discussed below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting time-series models\n",
    "\n",
    "In this section, we show how PINTS can be used to define a _model_ (e.g. a simulation), a _problem_ (comparing a simulation to a specific data set), and finally an error function to optimise.\n",
    "\n",
    "We start by defining a Model that implements the [pints.ForwardModel interface](http://pints.readthedocs.io/en/latest/core_classes_and_methods.html#forward-model).\n",
    "Like the `Error` and `LogPDF` classes, this has just two main methods: One to declare the number of parameters, and one to run _simulations_.\n",
    "\n",
    "We won't give a full example here, but typically it will look a bit like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyModel(pints.ForwardModel):\n",
    "    def __init__(self):\n",
    "        # Here, we might instantiate a simulation using some\n",
    "        # external simulation library\n",
    "        self.simulation = ...\n",
    "    \n",
    "    def n_parameters(self):\n",
    "        # Define the number of parameters you'll want to optimise\n",
    "        return 10\n",
    "    \n",
    "    def simulate(self, parameters, times):\n",
    "        # Run a simulation with the given parameters, log all the results\n",
    "        # at the given times, and return\n",
    "        self.simulation.set_parameters(parameters)\n",
    "        return self.simulation.run(times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To keep it simple, we will use a predefined model from [PINTS' toy model collection](http://pints.readthedocs.io/en/latest/toy/index.html): in this case a [logistic model](https://en.wikipedia.org/wiki/Logistic_function)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pints.toy as toy\n",
    "model = toy.LogisticModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This model has two parameters: A growth rate (which determines the steepness of the curve) and a carrying capacity (which determines the number the curve converges to).\n",
    "For the example, we simply pick some nice values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "real_parameters = [0.015, 500]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we create a list of times (in a real experiment, these would be the times at which the time series was sampled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "times = np.linspace(0, 1000, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have everything we need to run a simulation and generate some toy data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = model.simulate(real_parameters, times)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use Matplotlib (or any other plotting package) to have a look at the generated data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(14, 6))\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Values')\n",
    "plt.plot(times, values)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now set up an optimisation, to see if we can recover our original parameters from this data.\n",
    "\n",
    "First, we define a problem (in this case a [single-valued time series fitting problem](https://pints.readthedocs.io/en/latest/core_classes_and_methods.html#pints.SingleOutputProblem)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "problem = pints.SingleOutputProblem(model, times, values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then define an [error measure](http://pints.readthedocs.io/en/latest/error_measures.html) on this problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "error = pints.SumOfSquaresError(problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A lot of real problems have physical constraints on the values the parameters can take, so in this example we add them in the form of [boundaries](http://pints.readthedocs.io/en/latest/boundaries.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "boundaries = pints.RectangularBoundaries([0, 200], [1, 1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we define an initial position to start searching at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "x0 = np.array([0.5, 500])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now run an optimisation, using the [xNES](http://pints.readthedocs.io/en/latest/optimisers/xnes.html) method (although we could also have used a different global [optimiser](http://pints.readthedocs.io/en/latest/optimisers/index.html), like [CMA-ES](http://pints.readthedocs.io/en/latest/optimisers/cmaes.html) or [PSO](http://pints.readthedocs.io/en/latest/optimisers/pso.html)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 6\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     6      5539481   5539481    0:00.0\n",
      "1     12     4072617   4072617    0:00.0\n",
      "2     17     4012850   4012850    0:00.0\n",
      "3     23     3881994   3881994    0:00.0\n",
      "20    103    2197960   2993724    0:00.0\n",
      "40    199    1965792   1965792    0:00.0\n",
      "60    319    1011119   1011119    0:00.0\n",
      "80    439    219.0919  3510.56    0:00.0\n",
      "100   559    0.605     3.264092   0:00.0\n",
      "120   679    0.000482  0.00151    0:00.0\n",
      "140   799    7.16e-07  2.33e-06   0:00.1\n",
      "160   919    2e-10     2e-10      0:00.1\n",
      "180   1039   3.22e-12  8.32e-12   0:00.1\n",
      "200   1159   8.29e-14  1.36e-13   0:00.1\n",
      "220   1279   1.34e-15  1.34e-15   0:00.1\n",
      "240   1399   4.85e-19  2.73e-18   0:00.1\n",
      "260   1519   1.02e-23  2.3e-21    0:00.1\n",
      "280   1639   1.68e-24  1.98e-23   0:00.1\n",
      "300   1759   0         0          0:00.1\n",
      "320   1879   0         0          0:00.1\n",
      "340   1999   0         0          0:00.1\n",
      "360   2119   0         0          0:00.1\n",
      "364   2137   0         0          0:00.1\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/michael/dev/pints/pints/_optimisers/_xnes.py:84: UserWarning: All points requested by XNES are outside the boundaries.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "found_parameters, found_value = pints.optimise(\n",
    "    error,\n",
    "    x0,\n",
    "    boundaries=boundaries,\n",
    "    method=pints.XNES,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now look at the quality of the fit by running a simulation with the obtained parameters and plotting it on top of the noisy data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values2 = model.simulate(found_parameters, times)\n",
    "\n",
    "plt.figure(figsize=(14, 6))\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Values')\n",
    "plt.plot(times, values, 'x', label='Experimental data')\n",
    "plt.plot(times, values2, label='Simulated data')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because this was a toy model, we can also compare the parameters with the known true parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found solution:          True parameters:\n",
      " 1.49999999999999994e-02     1.49999999999999994e-02\n",
      " 5.00000000000000000e+02     5.00000000000000000e+02\n"
     ]
    }
   ],
   "source": [
    "print('Found solution:          True parameters:' )\n",
    "for k, x in enumerate(found_parameters):\n",
    "    print(pints.strfloat(x) + '    ' + pints.strfloat(real_parameters[k]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting to noisy data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now repeat this exercise with noisy data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "times = np.linspace(0, 1000, 1000)\n",
    "\n",
    "values = model.simulate(real_parameters, times)\n",
    "values += np.random.normal(size=values.shape) * 10\n",
    "\n",
    "plt.figure(figsize=(14, 6))\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Values')\n",
    "plt.plot(times, values)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we set up a problem, define an error measure, and run the optimisation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 6\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     6      4.26e+07  4.26e+07   0:00.0\n",
      "1     10     4.26e+07  4.46e+07   0:00.0\n",
      "2     10     4.26e+07  inf        0:00.0\n",
      "3     13     3080891   3080891    0:00.0\n",
      "20    94     3080891   2.03e+07   0:00.0\n",
      "40    213    656796.8  656796.8   0:00.0\n",
      "60    333    104330.7  104653.7   0:00.0\n",
      "80    453    104266.5  104268     0:00.0\n",
      "100   573    104266.4  104266.4   0:00.0\n",
      "120   693    104266.4  104266.4   0:00.1\n",
      "140   813    104266.4  104266.4   0:00.1\n",
      "160   933    104266.4  104266.4   0:00.1\n",
      "180   1053   104266.4  104266.4   0:00.1\n",
      "200   1173   104266.4  104266.4   0:00.1\n",
      "220   1293   104266.4  104266.4   0:00.1\n",
      "240   1413   104266.4  104266.4   0:00.1\n",
      "260   1533   104266.4  104266.4   0:00.1\n",
      "280   1653   104266.4  104266.4   0:00.1\n",
      "300   1773   104266.4  104266.4   0:00.1\n",
      "320   1893   104266.4  104266.4   0:00.1\n",
      "340   2013   104266.4  104266.4   0:00.1\n",
      "360   2133   104266.4  104266.4   0:00.1\n",
      "380   2253   104266.4  104266.4   0:00.2\n",
      "400   2373   104266.4  104266.4   0:00.2\n",
      "420   2493   104266.4  104266.4   0:00.2\n",
      "440   2613   104266.4  104266.4   0:00.2\n",
      "441   2613   104266.4  104266.4   0:00.2\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "problem = pints.SingleOutputProblem(model, times, values)\n",
    "error = pints.SumOfSquaresError(problem)\n",
    "\n",
    "found_parameters, found_value = pints.optimise(\n",
    "    error,\n",
    "    x0,\n",
    "    boundaries=boundaries,\n",
    "    method=pints.XNES,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can inspect the result by plotting a simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1400x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values2 = model.simulate(found_parameters, times)\n",
    "\n",
    "plt.figure(figsize=(14, 6))\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Values')\n",
    "plt.plot(times, values, label='Noisy experimental data')\n",
    "plt.plot(times, values2, label='Simulated data')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like a great fit!\n",
    "\n",
    "Because it's still a toy problem, we can look at the parameter values as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found solution:          True parameters:\n",
      " 1.49752545255054589e-02     1.49999999999999994e-02\n",
      " 4.99702025973736681e+02     5.00000000000000000e+02\n"
     ]
    }
   ],
   "source": [
    "print('Found solution:          True parameters:' )\n",
    "for k, x in enumerate(found_parameters):\n",
    "    print(pints.strfloat(x) + '    ' + pints.strfloat(real_parameters[k]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it looks like we were close, but not _exactly_ at the right parameters.\n",
    "\n",
    "Why didn't we find _exactly_ the right solution in the noisy case?\n",
    "\n",
    "To investigate this, we start by looking at the error measure, evaluated at the true solution and at the obtained solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error at obtained solution: \n",
      "104266.40277168492\n",
      "Error at true solution: \n",
      "104628.42246321507\n"
     ]
    }
   ],
   "source": [
    "print('Error at obtained solution: ')\n",
    "print(error(found_parameters))\n",
    "\n",
    "print('Error at true solution: ')\n",
    "print(error(real_parameters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to compare them is to plot the error function on a line drawn between these points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pints.plot\n",
    "fig, axes = pints.plot.function_between_points(error, point_1=found_parameters, point_2=real_parameters)\n",
    "axes.set_ylabel('score')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it looks like we found a solution that's slightly _better_ than the true solution - how can that be?\n",
    "\n",
    "The answer comes from the noise we added to our data: it seems the optimiser is able to adjust the model parameters _so that the model reproduces some aspects of the noise signal_.\n",
    "\n",
    "If we re-run this example (with a different random seed) we'll obtain an error of a slightly different size and direction.\n",
    "In other words, we can treat our noise as a [finite sample from some distribution](https://en.wikipedia.org/wiki/Sampling_distribution) (in this case a Normal distribution), so that the parameters we infer from this noisy signal will have a slight randomness that should (on average) get worse with an increased variance (noise amplitude) but better with an increased sample size (higher sampling rate)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the \"controller\" interface to change optimiser settings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the examples above we ran the optimisation using [`pints.optimise`](https://pints.readthedocs.io/en/stable/optimisers/running.html#pints.optimise).\n",
    "This is OK for small problems, but for many applications we prefer the extra control offered by the [`OptimisationController`](https://pints.readthedocs.io/en/stable/optimisers/running.html#pints.OptimisationController) class.\n",
    "\n",
    "This is slightly more verbose:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 6\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     6      4.75e+07  4.75e+07   0:00.0\n",
      "1     12     4.08e+07  4.08e+07   0:00.0\n",
      "2     17     4.08e+07  4.11e+07   0:00.0\n",
      "3     22     4.08e+07  4.08e+07   0:00.0\n",
      "20    113    7520433   1.49e+07   0:00.0\n",
      "40    231    6592101   6626759    0:00.0\n",
      "60    351    5447720   5447720    0:00.0\n",
      "80    471    2355371   2355371    0:00.0\n",
      "100   591    2148233   2148233    0:00.1\n",
      "120   711    753484.7  753484.7   0:00.1\n",
      "140   831    629881.7  629881.7   0:00.1\n",
      "160   951    167205.2  169108.6   0:00.1\n",
      "180   1071   121351.9  121351.9   0:00.1\n",
      "200   1191   104680.4  104890.1   0:00.1\n",
      "220   1311   104357    104357     0:00.1\n",
      "240   1431   104266.4  104266.4   0:00.1\n",
      "260   1551   104266.4  104266.4   0:00.1\n",
      "280   1671   104266.4  104266.4   0:00.1\n",
      "300   1791   104266.4  104266.4   0:00.1\n",
      "320   1911   104266.4  104266.4   0:00.2\n",
      "340   2031   104266.4  104266.4   0:00.2\n",
      "360   2151   104266.4  104266.4   0:00.2\n",
      "380   2271   104266.4  104266.4   0:00.2\n",
      "400   2391   104266.4  104266.4   0:00.2\n",
      "420   2511   104266.4  104266.4   0:00.2\n",
      "440   2631   104266.4  104266.4   0:00.2\n",
      "460   2751   104266.4  104266.4   0:00.2\n",
      "479   2859   104266.4  104266.4   0:00.2\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "opt = pints.OptimisationController(error, x0, boundaries=boundaries, method=pints.XNES)\n",
    "found_parameters, found_value = opt.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but much more flexible. For example, we can change the stopping criteria to make it halt quicker:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 6\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     6      6.15e+07  6.15e+07   0:00.0\n",
      "1     12     4.88e+07  4.88e+07   0:00.0\n",
      "2     18     4.02e+07  4.02e+07   0:00.0\n",
      "3     24     4.02e+07  4.02e+07   0:00.0\n",
      "20    110    1.34e+07  2.26e+07   0:00.0\n",
      "40    228    125008.4  275283.7   0:00.0\n",
      "60    348    104480.5  106409     0:00.0\n",
      "80    468    104266.4  104266.4   0:00.0\n",
      "100   588    104266.4  104266.4   0:00.0\n",
      "120   708    104266.4  104266.4   0:00.1\n",
      "140   828    104266.4  104266.4   0:00.1\n",
      "160   948    104266.4  104266.4   0:00.1\n",
      "180   1068   104266.4  104266.4   0:00.1\n",
      "200   1188   104266.4  104266.4   0:00.1\n",
      "220   1308   104266.4  104266.4   0:00.1\n",
      "221   1308   104266.4  104266.4   0:00.1\n",
      "Halting: No significant change for 50 iterations.\n"
     ]
    }
   ],
   "source": [
    "opt = pints.OptimisationController(error, x0, boundaries=boundaries, method=pints.XNES)\n",
    "opt.set_max_unchanged_iterations(50)\n",
    "found_parameters, found_value = opt.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The controller handles\n",
    "\n",
    "- logging to screen or disk\n",
    "- parallelisation\n",
    "- stopping criteria (*although optimisers may also tell the controller to stop, for example if they can detect they are stuck)\n",
    "\n",
    "For example, we can tweak the logging output with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 6\n",
      "Iter. Eval. Best      Current   Time    \n",
      "0     6      4.3e+07   4.3e+07    0:00.0\n",
      "1     11     4.04e+07  4.04e+07   0:00.0\n",
      "2     17     4.04e+07  4.04e+07   0:00.0\n",
      "3     23     4.04e+07  4.2e+07    0:00.0\n",
      "4     28     4.04e+07  4.1e+07    0:00.0\n",
      "5     34     4.04e+07  4.04e+07   0:00.0\n",
      "100   576    104266.5  104267.2   0:00.0\n",
      "200   1176   104266.4  104266.4   0:00.1\n",
      "300   1776   104266.4  104266.4   0:00.1\n",
      "400   2376   104266.4  104266.4   0:00.2\n",
      "500   2976   104266.4  104266.4   0:00.2\n",
      "501   2976   104266.4  104266.4   0:00.2\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "opt = pints.OptimisationController(error, x0, boundaries=boundaries, method=pints.XNES)\n",
    "opt.set_log_interval(100, warm_up=5)\n",
    "found_parameters, found_value = opt.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows the first 5 iterations (the \"warm up\") but then logs only every 100th iteration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can ask the controller for a reference to the optimiser object, and use that to configure optimiser-specific settings.\n",
    "In our example, we set a property of [XNES](https://pints.readthedocs.io/en/stable/optimisers/xnes.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimising error measure\n",
      "Using Exponential Natural Evolution Strategy (xNES)\n",
      "Running in sequential mode.\n",
      "Population size: 12\n",
      "Iter. Eval.  Best      Current   Time    \n",
      "0     12      4.02e+07  4.02e+07   0:00.0\n",
      "1     21      4.01e+07  4.01e+07   0:00.0\n",
      "2     32      3.99e+07  3.99e+07   0:00.0\n",
      "3     44      3.99e+07  3.99e+07   0:00.0\n",
      "20    218     2628626   2628626    0:00.0\n",
      "40    458     104301.7  104594.1   0:00.0\n",
      "60    698     104266.4  104266.4   0:00.0\n",
      "80    938     104266.4  104266.4   0:00.1\n",
      "100   1178    104266.4  104266.4   0:00.1\n",
      "120   1418    104266.4  104266.4   0:00.1\n",
      "140   1658    104266.4  104266.4   0:00.1\n",
      "160   1898    104266.4  104266.4   0:00.1\n",
      "180   2138    104266.4  104266.4   0:00.1\n",
      "200   2378    104266.4  104266.4   0:00.1\n",
      "220   2618    104266.4  104266.4   0:00.2\n",
      "240   2858    104266.4  104266.4   0:00.2\n",
      "260   3098    104266.4  104266.4   0:00.2\n",
      "280   3338    104266.4  104266.4   0:00.2\n",
      "300   3578    104266.4  104266.4   0:00.2\n",
      "320   3818    104266.4  104266.4   0:00.2\n",
      "340   4058    104266.4  104266.4   0:00.2\n",
      "360   4298    104266.4  104266.4   0:00.3\n",
      "380   4538    104266.4  104266.4   0:00.3\n",
      "384   4574    104266.4  104266.4   0:00.3\n",
      "Halting: No significant change for 200 iterations.\n"
     ]
    }
   ],
   "source": [
    "opt = pints.OptimisationController(error, x0, boundaries=boundaries, method=pints.XNES)\n",
    "opt.optimiser().set_population_size(12)\n",
    "found_parameters, found_value = opt.run()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}