Repository: pints-team/pints (language: python)

Issue:
ABC-SMC



Discussion / hints:
# [Codecov](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=h1) Report
> Merging [#1055](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=desc) into [master](https://codecov.io/gh/pints-team/pints/commit/a571e8be4c877c045ad8726bb2677b2a825b4977?el=desc) will **decrease** coverage by `0.08%`.
> The diff coverage is `97.15%`.

[![Impacted file tree graph](https://codecov.io/gh/pints-team/pints/pull/1055/graphs/tree.svg?width=650&height=150&src=pr&token=ShEiQsiM9b)](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=tree)

```diff
@@             Coverage Diff             @@
##            master    #1055      +/-   ##
===========================================
- Coverage   100.00%   99.91%   -0.09%     
===========================================
  Files           83       86       +3     
  Lines         8730     9011     +281     
===========================================
+ Hits          8730     9003     +273     
- Misses           0        8       +8     
```


| [Impacted Files](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [pints/\_abc/\_abc\_smc.py](https://codecov.io/gh/pints-team/pints/pull/1055/diff?src=pr&el=tree#diff-cGludHMvX2FiYy9fYWJjX3NtYy5weQ==) | `91.01% <91.01%> (ø)` | |
| [pints/\_\_init\_\_.py](https://codecov.io/gh/pints-team/pints/pull/1055/diff?src=pr&el=tree#diff-cGludHMvX19pbml0X18ucHk=) | `100.00% <100.00%> (ø)` | |
| [pints/\_abc/\_\_init\_\_.py](https://codecov.io/gh/pints-team/pints/pull/1055/diff?src=pr&el=tree#diff-cGludHMvX2FiYy9fX2luaXRfXy5weQ==) | `100.00% <100.00%> (ø)` | |
| [pints/\_abc/\_abc\_rejection.py](https://codecov.io/gh/pints-team/pints/pull/1055/diff?src=pr&el=tree#diff-cGludHMvX2FiYy9fYWJjX3JlamVjdGlvbi5weQ==) | `100.00% <100.00%> (ø)` | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=footer). Last update [a571e8b...6e30367](https://codecov.io/gh/pints-team/pints/pull/1055?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

@jarthur36 Thanks. I've sorted the flake8 issues -- can you have a look at the other stuff that is causing the tests to fail?
@jarthur36 is there a ticket we can relate this PR too?
Anyone know what the status of this is? @ben18785 ? 

Fix patch:
diff --git a/docs/source/abc_samplers/abc_smc.rst b/docs/source/abc_samplers/abc_smc.rst
new file mode 100644
index 000000000..864610f47
--- /dev/null
+++ b/docs/source/abc_samplers/abc_smc.rst
@@ -0,0 +1,7 @@
+***************
+ABC-SMC sampler
+***************
+
+.. currentmodule:: pints
+
+.. autoclass:: ABCSMC
\ No newline at end of file
diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst
index 96b4e9fc9..ea9c88f6d 100644
--- a/docs/source/abc_samplers/index.rst
+++ b/docs/source/abc_samplers/index.rst
@@ -13,4 +13,5 @@ given a :class:`LogPrior` and a :class:`ErrorMeasure`.
 .. toctree::
 
     base_classes
+    abc_smc
     rejection_abc
\ No newline at end of file
diff --git a/docs/source/index.rst b/docs/source/index.rst
index fc85f8631..6a9d00869 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -81,8 +81,10 @@ Sampling
 
 #. :class:`ABC sampling<ABCSampler>`
 
+   - :class:`ABCSMC`, requires a :class:`LogPrior` that can be sampled from
+     from and an :class:`ErrorMeasure`.
    - :class:`RejectionABC`, requires a :class:`LogPrior` that can be sampled
-     from and an error measure.
+     from and an :class:`ErrorMeasure`.
 
 #. 1st order sensitivity MCMC samplers (Need derivatives of :class:`LogPDF`)
 
diff --git a/examples/README.md b/examples/README.md
index 923b08969..d0eba385c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -78,6 +78,7 @@ relevant code.
 - [Rejection nested sampling](./sampling/nested-rejection-sampling.ipynb)
 
 ### ABC
+- [ABC-SMC sampling](./sampling/abc-smc.ipynb)
 - [Rejection ABC sampling](./sampling/rejection-abc.ipynb)
 
 ### Analysing sampling results
diff --git a/examples/sampling/abc-smc.ipynb b/examples/sampling/abc-smc.ipynb
new file mode 100644
index 000000000..7923a2e57
--- /dev/null
+++ b/examples/sampling/abc-smc.ipynb
@@ -0,0 +1,321 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ABC-SMC"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "PINTS can be used to perform inference for stochastic forward models. Here, we perform inference on the [stochastic degradation model](../toy/model-stochastic-degradation.ipynb) using Approximate Bayesian Computation (ABC). This model has only a single unknown parameter -- the rate at which chemicals degrade. We use the \"ABC SMC\" method to estimate this unknown and provide a measure of uncertainty in it."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we load the stochastic degradation model and perform 10 simulations from it. The variation inbetween runs is due to the inherent stochasticity of this type of model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pints\n",
+    "import pints.toy as toy\n",
+    "import pints.toy.stochastic\n",
+    "import pints.plot\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(5)\n",
+    "\n",
+    "# Load a forward model\n",
+    "model = toy.stochastic.DegradationModel()\n",
+    "\n",
+    "# Create some toy data\n",
+    "real_parameters = model.suggested_parameters()\n",
+    "times = np.linspace(0, 10, 100)\n",
+    "\n",
+    "for i in range(10):\n",
+    "    values = model.simulate(real_parameters, times)\n",
+    "\n",
+    "    # Create an object with links to the model and time series\n",
+    "    problem = pints.SingleOutputProblem(model, times, values)\n",
+    "\n",
+    "    # Create a uniform prior parameter\n",
+    "    log_prior = pints.UniformLogPrior([0.0], [0.3])\n",
+    "\n",
+    "    # Set the error measure to be used to compare simulated to observed data\n",
+    "    error_measure = pints.RootMeanSquaredError(problem)\n",
+    "\n",
+    "    plt.step(times, values)\n",
+    "\n",
+    "\n",
+    "plt.xlabel('time')\n",
+    "plt.ylabel('concentration (A(t))')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fit using ABC SMC\n",
+    "\n",
+    "The ABC SMC method can be used to perform parameter inference for stochastic models, where the likelihood is intractable. In ABC methods, typically, a distance metric comparing the observed data and the simulated is used. Here, we use the root mean square error (RMSE), and we accept a parameter value if the $RMSE<3$ for the first intermediate distribution, $RMSE<1.5$ for the second one and $RMSE<1$ for the last. The size of the intermediate distributions will be 200."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running...\n",
+      "Using ABC-SMC\n",
+      "Running in sequential mode.\n",
+      "Starting t=0, with threshold=3.0\n",
+      "Iter. Eval. Acceptance rate Time m:s\n",
+      "1     2      0.5              0:00.0\n",
+      "2     9      0.222222222      0:00.0\n",
+      "3     13     0.230769231      0:00.0\n",
+      "20    68     0.294117647      0:00.0\n",
+      "40    126    0.317460317      0:00.1\n",
+      "60    174    0.344827586      0:00.1\n",
+      "80    225    0.355555556      0:00.1\n",
+      "100   301    0.332225914      0:00.2\n",
+      "120   349    0.343839542      0:00.2\n",
+      "140   415    0.337349398      0:00.2\n",
+      "160   473    0.338266384778   0:00.2\n",
+      "180   546    0.32967033       0:00.3\n",
+      "Starting t=1, with threshold=1.5\n",
+      "200   608    0.328947368      0:00.3\n",
+      "220   755    0.291390728      0:00.4\n",
+      "240   861    0.278745645      0:00.5\n",
+      "260   1003   0.259222333001   0:00.6\n",
+      "280   1151   0.243266725      0:00.7\n",
+      "300   1298   0.231124807396   0:00.8\n",
+      "320   1411   0.226789511      0:00.9\n",
+      "340   1604   0.211970074813   0:01.0\n",
+      "360   1744   0.206422018      0:01.1\n",
+      "380   1855   0.204851752      0:01.1\n",
+      "Starting t=2, with threshold=1.0\n",
+      "400   2010   0.199004975      0:02.3\n",
+      "420   2646   0.158730159      0:02.7\n",
+      "440   3300   0.133333333      0:03.2\n",
+      "460   4348   0.105795768      0:03.7\n",
+      "480   5075   0.0945812808     0:04.2\n",
+      "500   5687   0.0879198171     0:04.5\n",
+      "520   6377   0.0815430453     0:05.0\n",
+      "540   6955   0.0776419842     0:05.4\n",
+      "560   7592   0.0737618546     0:05.8\n",
+      "580   8053   0.0720228486     0:06.1\n",
+      "600   8735   0.0686891815     0:06.6\n",
+      "620   9380   0.066098081      0:07.1\n",
+      "640   10165  0.0629611412     0:07.5\n",
+      "660   10881  0.0606561897     0:08.0\n",
+      "680   11510  0.0590790617     0:08.4\n",
+      "700   12359  0.0566388866     0:09.0\n",
+      "720   13093  0.0549912167     0:09.5\n",
+      "740   13951  0.0530427926     0:10.0\n",
+      "760   14770  0.0514556534     0:10.6\n",
+      "780   15481  0.0503843421     0:11.0\n",
+      "800   16148  0.0495417389     0:11.5\n",
+      "820   16822  0.0487456902     0:11.9\n",
+      "840   17485  0.0480411782     0:12.4\n",
+      "860   18470  0.0465619924     0:13.1\n",
+      "880   19275  0.0456549935     0:13.6\n",
+      "900   20037  0.0449169037     0:14.1\n",
+      "920   20750  0.0443373494     0:14.5\n",
+      "940   21577  0.0435649071     0:15.0\n",
+      "960   22095  0.0434487441     0:15.3\n",
+      "980   23152  0.0423289565     0:16.0\n",
+      "1000  23557  0.0424502271     0:16.3\n",
+      "1020  24146  0.0422430216     0:16.7\n",
+      "1040  24971  0.041648312      0:17.1\n",
+      "1060  25615  0.0413820027     0:17.6\n",
+      "1080  26414  0.0408874082     0:18.0\n",
+      "1100  26868  0.0409408962     0:18.4\n",
+      "1120  27780  0.0403167747     0:19.1\n",
+      "1140  28498  0.0400028072     0:19.6\n",
+      "1160  29137  0.039811923      0:20.1\n",
+      "1180  29916  0.0394437759     0:20.7\n",
+      "1200  30661  0.0391376667     0:21.1\n",
+      "1220  31580  0.0386320456     0:21.7\n",
+      "1240  32314  0.0383734604     0:22.1\n",
+      "1260  33152  0.0380067568     0:22.5\n",
+      "1280  33981  0.0376681086     0:23.0\n",
+      "1300  34410  0.0377797152     0:23.2\n",
+      "1320  35560  0.03712036       0:23.9\n",
+      "1340  36489  0.0367233961     0:24.4\n",
+      "1360  37079  0.0366784433     0:24.7\n",
+      "1380  37809  0.0364992462     0:25.3\n",
+      "1400  38428  0.0364317685     0:26.0\n",
+      "Halting: target number of samples (1400) reached.\n",
+      "Done\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(1)\n",
+    "abc = pints.ABCController(error_measure, log_prior, method=pints.ABCSMC)\n",
+    "\n",
+    "# set threshold schedule\n",
+    "abc.sampler().set_threshold_schedule(np.array([3,1.5,1]))\n",
+    "\n",
+    "# produce intermediate distributions of size 200\n",
+    "abc.sampler().set_intermediate_size(200)\n",
+    "\n",
+    "# set target number of samples\n",
+    "abc.set_n_samples(1400)\n",
+    "\n",
+    "# log to screen\n",
+    "abc.set_log_to_screen(True)\n",
+    "\n",
+    "print('Running...')\n",
+    "samples  = abc.run()\n",
+    "print('Done')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now plot the ABC posterior samples versus the actual value that was used to generate the data. This shows that, in this case, the parameter could be identified given the data. We plot the first, second and last generation separately in order to observe how the samples are getting more accurate in later generations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist([x[0] for x in samples[0:200]], label='First generation samples')\n",
+    "plt.xlim(0, 0.3)\n",
+    "plt.vlines(x=model.suggested_parameters(), linestyles='dashed', ymin=0, ymax=50, label='Actual value', color='red')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist([x[0] for x in samples[200:400]], label='Second generation samples')\n",
+    "plt.xlim(0, 0.3)\n",
+    "plt.vlines(x=model.suggested_parameters(), linestyles='dashed', ymin=0, ymax=50, label='Actual value', color='red')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist([x[0] for x in samples[400:]], label='Third generation samples')\n",
+    "plt.xlim(0, 0.3)\n",
+    "plt.vlines(x=model.suggested_parameters(), linestyles='dashed', ymin=0, ymax=250, label='Actual value', color='red')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 32-bit",
+   "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.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb
index 6cc700f81..cb778754f 100644
--- a/examples/sampling/rejection-abc.ipynb
+++ b/examples/sampling/rejection-abc.ipynb
@@ -44,7 +44,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3de3xdZZ3v8c9v59I0Se9NL7SUAlNQILWUcJcRAbECiuUAhQpCYabMjBfGwzlax3OGF8fRg6M4Ol7pcQioyBQRFFFQZFAcbmNbKqU3wEJLIaEptZc0zXX/zh9rpSTZ2ZfsZO2dZH3fr1fI3s9+1np+aekvz372s37L3B0REYmPRLEDEBGRwlLiFxGJGSV+EZGYUeIXEYkZJX4RkZgpLXYAuZg6darPnTu32GGIiIwoa9as2eXuNX3bR0Tinzt3LqtXry52GCIiI4qZbeuvXUs9IiIxo8QvIhIzSvwiIjGjxC8iEjNK/CIiMRNZ4jezw83scTPbaGYbzOzGsH2ymT1qZi+F3ydFFYOIiKSKcsbfCdzk7scBpwEfM7PjgBXAY+4+D3gsfC4iIgUS2T5+d28AGsLH+81sEzALuBg4O+x2F/Bb4DNRxHDlT7/D65VTDz0/tfUPnNn8m4zHdFmSpHXlPaZRgvXzx9pRXkVHeTUAL+8/g837zsl4nosXzGLpqXPyjkNEJJ2CrPGb2VzgROBZYHr4SwGgEZie5pjlZrbazFY3NTUNOobXSmbxbMXJmeN0o8QH80eSxEn9pVHS1U5Z+wEApozZzl+MeyrjWTY27ONn614fRBwiIulFfuWumVUDPwH+3t33mdmh19zdzazfO8G4+0pgJUBdXV1ed4u59VsrATji0ec47ae/o51pfHjp2rT9H7gteO2ymxbmMxzLHlkGQP2i+l7tq24JVrOuvvlW1qxdynTg6otOT3ueJbc/ndf4IiK5iHTGb2ZlBEn/bne/P2x+08xmhq/PBHZGGYOIiPQW5a4eA/4N2OTuX+3x0oPANeHja4CfRRWDiIikinKp50zgamC9ma0L2/4BuBW418yuB7YBl0cYg4iI9BHlrp7/BCzNy+dGNa6IiGSmK3dFRGJGiV9EJGaU+EVEYkaJX0QkZpT4RURiRolfRCRmzD2vaggFVVdX5/ncbH3b+06ktfEgFTPGcvnffIXGceOp7ShL27+jrQtPOpZ4exfqaW8lWbCvJKfxtuzeTEvnQSpLx/ZqL9nxGxLte6ioOow55z5LxeQDJFuPTh3/z++m4633sbFhHy1tnVSOCXbb7pxUQuPUaKtrqCicyOhjZmvcva5v+6ie8Y9/319SMSNIwrWvbWXG/n0Z+ydKrFfS/1N1gmem5P5HNHnslJSkD9BadRjJ8okA7H6xitbdVSl9Ssa+Stmk/wRganX5oaRffTDJtD/nXy00FyoKJxIvkRdpK6ZJn/46kz4dPK771Mep2/ZH/uZfvpnz8Rf9Yh2MKWHxTQsGFcfbxdu+yapbVtDyInzw5lt79VmzdikAJ13cu0Bcd+G4z92QX+G4XKgonEi8jOoZv4iIpFLiFxGJGSV+EZGYUeIXEYkZJX4RkZhR4hcRiRklfhGRmIny1ot3mNlOM3uhR9sCM3vGzNaZ2WozOyWq8UVEpH9RzvjvBBb1aftn4BZ3XwD8Y/hcREQKKMpbLz5hZnP7NgPjw8cTgDeiGr8/b40dz3c/9fGU9qOadnDsm9tS2pN//a+8OLGKC+79fdDQsR86grIP5294hsXrfpd5wKoaGDeDK8IaPr/6xinsHjuR1kQp37n0fADKEmWUJcqouWgrZVMO8ssfzgeg5eWJHNg8mX2JyXRSyjeWdgIwxg8yxg/2O1zplCmUTqvJGNI7zzyb+ef1/X0clG3IdgWv6vmIjA6FLtnw98CvzOwrBO82zkjX0cyWA8sB5swZfLI5rmYsG5tSa/XsrpoA0G/if/+mdfDOsFxDYgyUAR37eHF6EE/GxN9+IPg+bgZTxk6Bg28BMLGjlT1lFQAkPUlHsoOyRBktL0+kMjy0bMpBKoEDmycHSd6C+j+dlIKN7TfxJ1ta6ISMib/p1VcAUhL/xQtmpf85Qhsbgj87JX6RkS/S6pzhjP8hdz8hfP6vwO/c/Sdmdjmw3N3Py3aefKtz5qK+vh6AZcuWZey38/bnAZh2w3wWP/cSAA+cOC/DiS8Mvi/7Rdoub9fwqe/Vfqhuz8If9Wrvrtuz+KbUuj3brv4oAEf84Ptpx1t1ywoAlvSpE5SL7ncDq244fcDHikhxDJfqnNcA94ePfwzow10RkQIrdOJ/A3hP+Pgc4KUCjy8iEnuRrfGb2T3A2cBUM9sB3Az8NfB1MysFWgnX8EVEpHCi3NVzZZqXTopqTBERyU5X7oqIxIwSv4hIzCjxi4jEjBK/iEjMKPGLiMRMpFfuDpWor9xtbGxkxowZGft1NBzgqPZpzJ/5Dq6bnWRLpXHCxMr0BzSuD8o2lFel7bKFDlpIUtnn9++ksk5KE9CZDBssAWYkOksxT+CWTDlXIgmnHlzDew4+A0BXidFVagB0jmmlo+IgFbuDej+tk3PfzDW5YjI1ldPY+MZefr9jIXvtgpQ+quEjMjwNlyt3h53a2tqsSR/greQ+tpbvBOD9O9o4tiXLL8yqmoxJH2AyiZSkD9CaTLyd9AE8eOKJZL9JH2B72SyeHRvslDV3SrqC+Eo6yyhtq8gcaxotnS3sbt0NwIzK1zhr9tqUPhsb9vGzda/ndX4RKY5CF2kbdurq6qirS/mFmKK7ps+0ZfNZcvvzLNkB0y7MUKuHTK8NQA41f4CwftBULlz0eK+6Pd31fZbetPBQrZ6lOdbqWfbIMuiEpQvrWbN2KZMnwtUX9a7Vk62ip4gMP7Gf8YuIxI0Sv4hIzCjxi4jEjBK/iEjMKPGLiMSMEr+ISMwo8YuIxIwSv4hIzESW+M3sDjPbaWYv9Gn/hJltNrMNZvbPUY0vIiL9i3LGfyewqGeDmb0XuBh4l7sfD3wlwvFFRKQfkRZpM7O5wEPufkL4/F5gpbv/ZiDnibJIW656FnPraDiAt3dh5SUZjzl+3js587JzBznwhUHBtxm1GbstnnE9G8pncnx7A21vtpPsSJIoS7B3zGF02RhKvI2O5F7cOynz/uv99NVFWO8Ho6ymjUSZU+q95wpd7nR4CV2JMgBmNTeTeHOIylXkQAXiRNIbLkXajgHOMrNnzex3ZnZyuo5mttzMVpvZ6qampgKG2L+exdwS1WVZk/6u9j1seGnTEAx8adakD3BJ8/Mc394AQElVCYmy4K92TGczJd4WdEpUEdznfuA6WkpJdlhKe4IkZdYFQENiOq9XV+d1/nyoQJxIfgpdpK0UmAycBpwM3GtmR3k/bzvcfSWwEoIZf0Gj7Eeuxdy6rfziN4do4GXBVxZXh1+ZBAXbJrL4poU5Db3skWDc+kX13HXFhwG45t9/2rtTjyJy73viQaCUVTf0LuQWFRWIE8lP1sRvZhXARcBZwGHAQeAF4BfuvmGA4+0A7g8T/X+ZWRKYChR/Si8iEhMZl3rM7BbgSeB04FngduBeoBO41cweNbP5Axjvp8B7w3MfA5QDu/KIW0RE8pRtxv9f7n5zmte+ambTgH4/WTOze4CzgalmtgO4GbgDuCPc4tkOXNPfMo+IiEQnY+J394x3/3D3ncDONK9dmeawq3ILTUREopDLGv9s4Erg3fRZ4wceds9xb6CIiAwLGRO/mdUDs4CHgC8RzO4rCLZlLgI+Z2Yr3P2JqAMVEZGhkW3Gf5u7v9BP+wvA/WZWTpo1fhERGZ4y7urpTvpmdmPf18zsRndvd/eXowpORESGXq5X7l7TT9u1QxiHiIgUSMZaPWZ2JbCU4IPd3/d4aRyQdPdBFqLJzXCo1TNQK7/4TXa172Fq+UQA5o09nOMrj4x0zMoFNVSfOjPt6w/ctpZdO5qZOju3sgpbdm+mpfMglaVjqdj6K5LJvSQSE3p38u7/GPdf+wF2lB/OrPbXsp67s7WMjpbyzJ0stURE37GDkVMdtW09R257KuPh2w8rYevhmUtv5GNq1RimjR8DwAVHXcBlx1w25GOI5CJdrZ5sa/xPAQ0EV9fe1qN9P/D80IU3+hw/752HavXs6tgbtEWY+DsammmBjIn/mFOmD+ick8dOgYNvBU+q5pI48GpqJwM8SL212zbAEeHvggxKyoLaPlkTv3vm5G9g/QzWNLkGqM2Y+Cfud3ija8gTf0tbJ7uAaePHsGX3FgAlfhl2siX+7e6+jeDK3X6ZmekirFRnXnYuZxK8Iaqvrwdg2rKBXOQ8MDtvz/57+PizZnH8WbMii2Hb1R+F/9zGET/4fsZ+a9YuBeCkRT9K36lHDaCBOuvB56B6Fl/67s/T9ll1ywoAvrTs1gGfP5Mltz8N7VC/6PRDtY5Ehptsa/yPhzdO6bVzx8zKzewcM7uL/tf/RURkmMo2418EXAfcY2ZHAnuAsQS/MH4NfM3dn4s2RBERGUrZSja0At8Gvm1mZQRr/QfdfU8hghMRkaGX841Y3L3D3RuADjO7yswGvvgqIiJFl1PiD9f0F5vZjwl2+ZwLfDfSyEREJBLZavWcT1Cg7XzgceD7wMnuru0KIiIjVLYZ/yPAUcC73f0qd/85oGqcIiIjWLbEvxB4GvhNeLet64GcrngxszvMbGd405W+r91kZm5mUwcesoiIDEa2Im3r3H2Fux9NcAetBUCZmT1sZsuznPtOgu2gvZjZ4QRLR9vzC1lERAYj641Yurn7U8BTYaXO84ArgJUZ+j9hZnP7eelfgE8DPxtQpJJVR0Nz1it4s9XzGazWzZuDK3gz9Vm0ifbJB3jy7hMBGLe1hgkvzujdqfENxs/eyyQuzDxg7aVQl/qR02sV4RW8QOW4cion9i4P0TT/HNpbD/KNB37d72lP2rmNMxr/lHnsfrzjjX28UHE0S26HV8v30WqvcWr9f0vp17Oez0ilOkQjV7abrc/t2+buSXf/tbtfZ4HZuQ5mZhcDr7v7H3Pou9zMVpvZ6qamplyHiK3KBTWUzcxcfK2joZmWddH9WY6/6CIq3vGOrP3Gba2hfHcVAO2TD7D/qNSYWt9y9u2YkNLeS+N6WH9fSvNFE8ZxeGvwuKOti5b97Sl9KidMpLxibL+nfb16ImumHZHlp+jfhINNnNAa/MKY0HUKFX54Sp+Wtk52HWjL6/zDxZbdW/jl1l8WOwzJU7YZ/5fNLEEwO18DNBHcgesvCG6kfh7BEtCObAOZWSXwDwTLPFm5+0rCdxR1dXWqBZRF9akzs87kc6nnMxiTllzOpCWXD+iYNWuXwnQ44iO96/scetewLEPdn/r+3w185j1/wWfCxw/cthZwFn9oXs4xLX7uJZg6iSWLB17HZ9UtK5gF3HLD6aQrcdWzns9IpTpEI1u2K3cvM7PjgI8QlG6YCbQAm4BfAl8Mr+7NxdHAkcAfLai4OBtYa2anuHtjnvGLiMgAZV3jd/eNwOcGO5C7rwemdT83s1eBOnffNdhzi4hI7nIu2TBQZnYPwVbQY81sR7gVVEREiiznXT0D5e5XZnl9blRji4hIepHN+EVEZHjKecZvZrOAI3oe4+5PRBGUiIhEJ6fEb2ZfApYAG4GusNkBJX4RkREm1xn/h4Fj3X1kX3UiIiI5r/FvBcqiDERERAoj1xl/C7DOzB4DDs363f2TkUQlIiKRyTXxPxh+SZ4aGxupr69Paa+traWurq5gcQyHQm59NTdvDEo39NC6aBPJlhZ2hIXc+ncAvAvqj0nbo2LmYXQlxvCrH3cAMLasharyZgBmHJjArOaJqQfNuJ4N5TNZ/PD6lJcuaX6eq5v/kD6khvB7mnISAP/41l7uaz+dJbenP81wl6kAHQzvInQqLpdj4nf3u8ysHOj+F7bF3TuiC2t0qa2t7be9sTGoVFGoxF+5oIaWLH06GpppgYIl/hnTP0h/9TpKp0yhM9vBJWVvbzVIo7xtP+1jgJIEHcky6KikqryZ5vI2Gtnbb+K/pPl56Kfe3YbymVBN5sSfg3nJV7m0HP4PlwzqPMU0oeuUtHfmaGnrZBcMy8S/ZfcWACX+XDqZ2dnAXcCrgAGHm9k12s6Zm7q6un6Te3/vAKI0HAq59TVr1pXMmpXxWr9B6S72dsQPvs8Dt62lAzjppoVvv8O44Ecpx1wdfvW1+LmXgKnwgV+kH3D7iuD7svQF3srrL+R4YNWykVukLV0BOhjeRehUXC6Q61LPbcD57r4FwMyOAe4BTooqMBERiUauu3rKupM+gLu/iHb5iIiMSLnO+Feb2feAH4bPPwKsjiYkERGJUq6J/2+BjwHd2zd/D3w7kohERCRSue7qaQO+Gn6JiMgIljHxm9m97n65ma0nqM3Ti7vPjywyERGJRLYZ/43h94uiDkRERAoj464ed+++DvHv3H1bzy/g7zIda2Z3mNlOM3uhR9uXzWyzmT1vZg+YWT+XTYqISJRy3c75vn7aPpDlmDuBRX3aHgVOCJeIXgQ+m+P4IiIyRLKt8f8twcz+KDPreUnnOODJTMe6+xNmNrdP2697PH0GuHQgwY5GPWv4FLpuT1y0bt7Mtqs/SmtFMA/ZdvXXaF20ifbJB3gyYy2g3vZN+QyvlM3h3EfWpO3Teeq7cODbj9wDwKktT3N2y297dyrtAnf4wfE5j93yYjUHNozPuX8xLXLHHeofSX1t7oQO3vuefuphRKH2UqhLvVJ3y+4tQ3YF70it+5Ntjf9HwMPA/wVW9Gjf7+67Bzn2dcCqdC+a2XJgOcCcOXMGOdTw1LOGT6Hr9sTF+Iv6/3hq3NYa9g/wXO8++EzWPgkgGT7eXjYHKklN/FhQ+CRHZVPbqaR5xCR+O/Sf3vaVlPHq3gIF0RgW2OuT+C846oIhG2Ik1/0x95TNOuk7m00DKrqfu/v2LP3nAg+5+wl92j8H1AGXeA4B1NXV+erVo/t6se5Z/7Jlxa0l0l2rZ9oNo2/D1gO3rQVg8U0LCzJeUNsHHjhx3qDO011X6KSFqXWFRpLvXBL8Ev7b+x+KfrDu6qjLMtRVGqTudw31iwpbc2sgzGyNu6fMJnNa4zezD5rZS8ArwO8IirU9nGcg1xLsEvpILklfRESGVq4f7v4TcBrworsfCZxLsEY/IGa2CPg08CF3z1YhWEREIpBr4u9w97eAhJkl3P1xgqWatMzsHuBp4Fgz22Fm1wPfJPhg+FEzW2dm3x1M8CIiMnC51urZY2bVwBPA3Wa2EziQ6QB376/I+r8NMD4RERliuc74Lya47+6ngEeAPwEfjCooERGJTtYZv5mVEOzMeS/BTrW7Io9KREQik3XG7+5dQNLMJhQgHhERiViua/zNwHoze5Qea/vu/sn0h4iIyHCUa+K/P/zqSXvwRURGoFwT/0R3/3rPBjO7MV1nGdk6GpoPXcE7UJULaqg+deYQRzR0du1oPnQFb+RjzTN2jIWzHnxuUOcpGRuUBOga5HmK5eTdzllvQVt5DUn/M99Yeh0AY/wgY/xgSv85iXKOKqlIaR+Qxjeg/QD8KPdaTAN1Be08fryxrDHY2X7BYWdx2fn/Etl4QynXXT3X9NN27RDGIcNE5YIaymbmV0Sro6GZlnVNQxzR0DnmlOlMnV2gAmEECW92al6LlR1j4Q+Tw8I9Y48lYZMA6KSUNhub0n+vd7E92T74gatqoLxq8OfJYNZO570bgoWPLd7KL9/4faTjDaVs1TmvBJYCR5rZgz1eGgcMtkibDEPVp87Me8ae77uEQjn+rFkcf9asgo23eIjOs2btl4GRWaunu17R4g/NY8ntbcB7WHXD6WnrJq26JagFecTNtxY0znxsu/qjvAOov/b7LLtzZBVXzLbU8xTQAEwFbuvRvh8Y3v/KRUSkXxkTf3inrW3A6YUJR0REopZrdc5LzOwlM9trZvvMbL+Z7Ys6OBERGXq57ur5Z+CD7r4pymBERCR6ue7qeVNJX0RkdMh1xr/azFYBPwXauhvdve9FXSIiMszlmvjHE1TnPL9Hm5N6Na+IiAxzOSV+dy/ujWBFRGTI5Lqr5xgze8zMXgifzzez/5XlmDvMbGf3MWHbZDN7NNwh9KhZeBmfiIgUTK4f7v4/4LNAB4C7Pw9ckeWYO4FFfdpWAI+5+zzgsfC5iIgUkLlnL7JpZn9w95PN7Dl3PzFsW+fuC7IcN5fgJi4nhM+3AGe7e4OZzQR+6+7HZhu/rq7OV69enf2nGcHq6+tpbGxkxowZxQ4lbx0NB/D2Lqy8ZEDHJarLKBlXHlFUI9+06d+nvPxN2tunH2qrqqpm3LhxRYwqNyuar2Br1zSOKtnJgfZOkklIJKAkCebg1ueAZAdGEizXOSkYgPU9UW8lpaWUlOb6kWaq8vIplI+Z1qutbdNmki0tJCoraWnfz8INT/L+db9NOXYKJdQwsH8TPY058jBmrPxFXsea2Rp3T6knkeufxC4zO5qwFLOZXUpQymGgprt793GNwPR0Hc1sObAcYM6cOXkMNbLU1tYWO4RBS1SXkWwe2DHe3kWyGSX+DA4cOKHX8/b2dqB5RCT+95RvgrDmWllJgg6SQD8Jv5slcA+TeS7CXx6Z+nuyi65O8k78XV0ttLeTkvhLpkw59Pi16XMBUhJ/Cw50DSrxRyHXGf9RwErgDODPwCvAVe7+apbj5tJ7xr/H3Sf2eP3P7p51nT8OM/646i7sNu2G+UWOZOSor68HYNmy0bfnYsntTwOw6obcqsSkK/bWU3fhtyV5Fn5bs3YpkLlIXncxugdOnNerfdkjwd9R/aL6vMYerEHN+N19K3CemVUBCXffn2ccb5rZzB5LPTvzPI+IiOQp1109XzSzie5+wN33m9kkM/unPMZ7kLdr+18D/CyPc4iIyCDk+gnKB9x9T/cTd/8zcEGmA8zsHuBp4Fgz22Fm1wO3Au8zs5eA88LnIiJSQLl+2lFiZmPcvQ3AzMYCYzId4O5Xpnnp3AHEJyIiQyzXxH838JiZdX9CsQy4K5qQREQkSrl+uPslM3uet2frn3f3X0UXloiIRCXnja3u/jDwcISxiIhIAegOXCIiMaM7cImIxEyuV+4+6e5nFiCefunK3dFr5+3P09HQTNnMagAqF9RQferMIkc1vOVT16m2tpa6upQLOIedJbc/zcaGfRw3c3xO/ee/1Eb1wSTNY9MvXpTv/HesvQkvr8krpnmLVlMx5QBNHUcB8PL+M9i875xefdbNLqd5TILqtmSv9tbEayRpIxFugixLJCgvzb0OEcAR5V08fNbFecU+2Fo9ugOXRKJyQQ0t4eOOhmZaQIk/i4HWdWpsbAQYEYn/4gWzBtR/56TsNXC6Kt85qEo5e16sYuIxwHiYMmY7QErin7a/q99jS308neGqeDLpdJCkPOfLp6KT64y/v0IT7u7XDX1IqTTjjwfV7YnGaK7tUwjf+quPA/Cx730zp7o96Qy0DtFQGGytHv0fIyIySuS6q2e2mT0Q3lFrp5n9xMxmRx2ciIgMvVwXm+oJCqwdFn79PGwTEZERJtfEX+Pu9e7eGX7dCeT3EbmIiBRVron/LTO7ysxKwq+rgLeiDExERKKRa+K/Dric4HaJDcClBIXaRERkhMl1V8824EMRxyIiIgWQ666eu8ys571yJ5nZHfkOamafMrMNZvaCmd1jZhX5nktERAYm16We+f3cgevEfAY0s1nAJ4G68CbsJcAV+ZxLREQGLteSDQkzmxQmfMxs8gCOTTfuWDPrACqBNwZxLhlFOhqaD13Bq7o9Q6exsfHQFbwjyXCpMdTa3MC3/urjzDn3JSom7+OR+0/L2L9ywkSqJk3u1XbRrL20tHfxg4cGVkDCy+bx0fd/bcAxZ5LrjP824Gkz+7yZfR54iqBi54C5++vAV4DtBB8U73X3X/ftZ2bLzWy1ma1uamrKZygZYSoX1Bwq1tbR0EzLOv29D4Xa2toBFXQbLhobG1m/fn2xw+Dok86kojqYgOx+eQatuzMXkGtvPUjL3j0p7VOrx1BZPpiqQUMnp1o9AGZ2HNBdmeg/3H1jXgOaTQJ+AiwB9gA/Bu5z9x+mO0a1euJHdXtkONYYeuC2tQAsvmlh2j6rblkBwJKbby1ITJkMtjonYaLPK9n3cR7wirs3hYHdD5wBpE38IiIydIpRH3Q7cJqZVZqZEdzHVzd4EREpkIInfnd/FrgPWAusD2NYWeg4RETiajA7c/Lm7jcDNxdjbBGRuCv+rWBERKSglPhFRGJGiV9EJGaU+EVEYkaJX0QkZpT4RURipijbOUVy0bNgmwzcaChyN9yKy+1qaaajrYuXP/9k2j7trSUku9r5wmc/NyRjVpZW8KnP/+8hOVc3JX4ZlioX1NBS7CBGsI6GZlpgRCf+2traYoeQonJcOS20Z+xTUlpVoGjyp8Qvw1L1qTNHdNIqttHwTqmurm5YlGQejbTGLyISM0r8IiIxo8QvIhIzSvwiIjGjxC8iEjNK/CIiMaPELyISM0VJ/GY20czuM7PNZrbJzE4vRhwiInFUrAu4vg484u6Xmlk5UFmkOEREYqfgid/MJgB/CVwL4O7tkOUaaBEZMNU6GrjRUN8oF8VY6jkSaALqzew5M/uemaUUtzCz5Wa22sxWNzU1FT5KkRGsckENZTOrix3GiNLR0EzLunjkGnP3wg5oVgc8A5zp7s+a2deBfe6etvxcXV2dr169umAxikj8dL87mnbD/CJHMnTMbI27pxQ8KsaMfweww92fDZ/fBywsQhwiIrFU8MTv7o3Aa2Z2bNh0LrCx0HGIiMRVsXb1fAK4O9zRsxVYVqQ4RERipyiJ393XASq0LSJSBLpyV0QkZpT4RURiRolfRCRmlPhFRGJGiV9EJGaU+EVEYqZY+/hFRIadnoXtRnPBNiV+ERGCRN8SPu5oaKYFlPhFREaz6lNnHkr0o72ctdb4RURiRolfRCRmlPhFRGJGiV9EJGaU+EVEYkaJX0QkZpT4RURipmiJ38xKzOw5M3uoWDGIiMRRMWf8NwKbiji+iEgsFeXKXTObDVwIfAH478WIQUQkk551e4qp/LAqJn7w6CE9Z7FKNnwN+DQwLl0HM1sOLAeYM2dOgcISEVeP5wgAAAULSURBVOldt2c0KnjiN7OLgJ3uvsbMzk7Xz91XAisB6urqvEDhiYj0qtszGhVjjf9M4ENm9irw78A5ZvbDIsQhIhJLBU/87v5Zd5/t7nOBK4D/cPerCh2HiEhcaR+/iEjMFLUev7v/FvhtMWMQEYkbzfhFRGJGiV9EJGaU+EVEYkaJX0QkZsx9+F8bZWZNwLY8D58K7BrCcEYC/czxoJ85HgbzMx/h7jV9G0dE4h8MM1vt7nXFjqOQ9DPHg37meIjiZ9ZSj4hIzCjxi4jETBwS/8piB1AE+pnjQT9zPAz5zzzq1/hFRKS3OMz4RUSkByV+EZGYGdWJ38wWmdkWM3vZzFYUO56omdnhZva4mW00sw1mdmOxYyoEMysxs+fM7KFix1IIZjbRzO4zs81mtsnMTi92TFEzs0+F/0+/YGb3mFlFsWMaamZ2h5ntNLMXerRNNrNHzeyl8PukoRhr1CZ+MysBvgV8ADgOuNLMjituVJHrBG5y9+OA04CPxeBnBrgR2FTsIAro68Aj7v4O4F2M8p/dzGYBnwTq3P0EoITgXh6jzZ3Aoj5tK4DH3H0e8Fj4fNBGbeIHTgFedvet7t5OcLevi4scU6TcvcHd14aP9xMkhFnFjSpaZjYbuBD4XrFjKQQzmwD8JfBvAO7e7u57ihtVQZQCY82sFKgE3ihyPEPO3Z8Advdpvhi4K3x8F/DhoRhrNCf+WcBrPZ7vYJQnwZ7MbC5wIvBscSOJ3NeATwPJYgdSIEcCTUB9uLz1PTOrKnZQUXL314GvANuBBmCvu/+6uFEVzHR3bwgfNwLTh+Kkoznxx5aZVQM/Af7e3fcVO56omNlFwE53X1PsWAqoFFgIfMfdTwQOMERv/4ercF37YoJfeocBVWYWu9u1erD3fkj234/mxP86cHiP57PDtlHNzMoIkv7d7n5/seOJ2JnAh8zsVYKlvHPM7IfFDSlyO4Ad7t79Tu4+gl8Eo9l5wCvu3uTuHcD9wBlFjqlQ3jSzmQDh951DcdLRnPj/AMwzsyPNrJzgw6AHixxTpMzMCNZ+N7n7V4sdT9Tc/bPuPtvd5xL8/f6Hu4/qmaC7NwKvmdmxYdO5wMYihlQI24HTzKwy/H/8XEb5B9o9PAhcEz6+BvjZUJy0qPfcjZK7d5rZx4FfEewCuMPdNxQ5rKidCVwNrDezdWHbP7j7L4sYkwy9TwB3hxOarcCyIscTKXd/1szuA9YS7Fx7jlFYusHM7gHOBqaa2Q7gZuBW4F4zu56gNP3lQzKWSjaIiMTLaF7qERGRfijxi4jEjBK/iEjMKPGLiMSMEr+ISMwo8Yv0EVa//Lvw8WHhVkKRUUPbOUX6COscPRRWghQZdUbtBVwig3ArcHR4EdxLwDvd/QQzu5agOmIVMI+gcFg5wUVzbcAF7r7bzI4mKAleA7QAf+3umwv/Y4j0T0s9IqlWAH9y9wXA/+zz2gnAJcDJwBeAlrBY2tPAR8M+K4FPuPtJwP8Avl2QqEVypBm/yMA8Ht7rYL+Z7QV+HravB+aHlVHPAH4clJUBYEzhwxRJT4lfZGDaejxO9nieJPj3lAD2hO8WRIYlLfWIpNoPjMvnwPD+B6+Y2WUQVEw1s3cNZXAig6XEL9KHu78FPBne9PrLeZziI8D1ZvZHYAOj/JafMvJoO6eISMxoxi8iEjNK/CIiMaPELyISM0r8IiIxo8QvIhIzSvwiIjGjxC8iEjP/Hx4yZTeUKwPDAAAAAElFTkSuQmCC\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -197,7 +197,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -235,7 +235,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7"
+   "version": "3.8.0"
   }
  },
  "nbformat": 4,
diff --git a/pints/__init__.py b/pints/__init__.py
index 51b3e3506..97773b6d0 100644
--- a/pints/__init__.py
+++ b/pints/__init__.py
@@ -242,6 +242,7 @@ def version(formatted=False):
 from ._abc import ABCSampler
 from ._abc import ABCController
 from ._abc._abc_rejection import RejectionABC
+from ._abc._abc_smc import ABCSMC
 
 
 #
diff --git a/pints/_abc/_abc_smc.py b/pints/_abc/_abc_smc.py
new file mode 100644
index 000000000..b92d782a6
--- /dev/null
+++ b/pints/_abc/_abc_smc.py
@@ -0,0 +1,234 @@
+#
+# ABC SMC method
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+import pints
+import numpy as np
+
+
+class ABCSMC(pints.ABCSampler):
+    r"""
+    Implements the ABC-SMC algorithm as described in [1]. This
+    algorithm is also referred to as ABC Population Monte Carlo
+    (ABC PMC) [2].
+
+    In this algorithm there are going to be several rounds of ABC,
+    each with a different proposal distribution. For each round, we
+    try to obtain ``nr_samples`` samples at once. In order to
+    transition between each set of ``nr_samples``, we have intermediate
+    distributions :math:`p_t(\theta)` from which we sample the
+    candidates for the new distribution. In particular,
+    :math:`p_0(\theta)` is the prior and for :math:`t>0`
+    :math:`p_t(\theta)` proposes sample :math:`\theta^{t-1}_i` with
+    weight :math:`\w^{t-1}_i` (which is computed at the end of the
+    iteration). In particular, at each iteration of the algorithm
+    the following steps occur:
+
+    .. math::
+        \begin{align}
+        & \theta^* \sim p_{t-1}(\theta) \textrm{, i.e. sample parameters from
+        previous intermediate distribution} \\
+        & \theta^{**} \sim K(\theta|\theta^{*}), \textrm{i.e. perturb }
+        \theta^{*} \textrm{ to     obtain to new point } x \sim
+        p(x|\theta^{**})\textrm{, i.e. sample data from sampling
+        distribution} \\
+        & \textrm{if } s(x) < \textrm{threshold}_(t), \theta^* \textrm{
+        add to list of samples[t]}
+        \end{align}
+
+    After we have obtained ``nr_samples`` samples, ``t`` is advanced, and
+    weights are calculated for ``samples[t-1]``. At the last error
+    threshold, samples are returned whenever they are accepted.
+
+    Parameters
+    ----------
+    log_prior
+        A ``pints.LogPrior`` that specifies the logarithmic prior for
+        the set of parameters that will be sampled.
+    perturbation_kernel
+        A ``pints.LogPrior`` used for perturbing the particles sampled
+        from the previous generation. By default a multivariate
+        Gaussian distribution is used with mean I and 0.001 * I
+        as covariance.
+    nr_samples
+        The number of samples requested for intermediate distributions.
+    error_schedule
+        The schedule of error threshold distance for all distributions.
+
+    References
+    ----------
+    .. [1] Toni, Welch, Strelkowa, Ipsem, Stumpf. Approximate Bayesian
+           computation scheme for parameter inference and model selection in
+           dynamical systems. Journal of the Royal Society Interface,
+           6.31: 187-202, 2009.
+           https://doi.org/10.1098/rsif.2008.0172
+
+    .. [2] Beaumont, Cornuet, Marin, Robert. Adaptive approximate Bayesian
+           computation. Biometrika, 96.4: 983-990, 2009.
+           https://doi.org/10.48550/arXiv.0805.2256
+    """
+
+    def __init__(self, log_prior, perturbation_kernel=None,
+                 nr_samples=100, error_schedule=[1]):
+        # Log prior
+        self._log_prior = log_prior
+
+        # Default value for error threshold schedule
+        self._e_schedule = error_schedule
+
+        # Default value for current threshold
+        self._threshold = error_schedule[0]
+
+        # Size of intermediate distributions
+        self._nr_samples = nr_samples
+
+        # Set up for first iteration
+        self._samples = [[], []]
+        self._accepted_count = 0
+        self._weights = []
+        self._xs = None
+        self._ready_for_tell = False
+        self._t = 0
+        self._to_print = True
+
+        # Setting the perturbation kernel
+        if perturbation_kernel is None:
+            dim = log_prior.n_parameters()
+            self._perturbation_kernel = pints.MultivariateGaussianLogPrior(
+                np.zeros(dim),
+                0.001 * np.identity(dim))
+        elif isinstance(perturbation_kernel, pints.LogPrior):
+            self._perturbation_kernel = perturbation_kernel
+        else:
+            raise ValueError('Provided perturbation kernel must be an instance'
+                  ' of pints.LogPrior')
+
+    def name(self):
+        """ See :meth:`pints.ABCSampler.name()`. """
+        return 'ABC-SMC'
+
+    def ask(self, n_samples):
+        """ See :meth:`ABCSampler.ask()`. """
+        if self._ready_for_tell:
+            raise RuntimeError('ask called before tell.')
+        if self._t == 0:
+            if self._to_print:
+                self._to_print = False
+                print(
+                    "Starting t=" + str(self._t)
+                    + ", with threshold=" + str(self._threshold))
+            self._xs = self._log_prior.sample(n_samples)
+        else:
+            self._xs = [None] * n_samples
+            i = 0
+            while i < n_samples:
+                theta_s_s = None
+                while (theta_s_s is None or
+                       self._log_prior(theta_s_s) == -np.inf):
+                    indices = np.random.choice(
+                        range(len(self._samples[(self._t - 1) % 2])),
+                        p=self._weights[self._t - 1])
+                    theta_s = self._samples[(self._t - 1) % 2][indices]
+                    # perturb using K_t
+                    theta_s_s = np.add(theta_s,
+                                       self._perturbation_kernel.sample(1)[0])
+                    # check if theta_s_s is possible under the prior
+                    # sample again if not
+                self._xs[i] = theta_s_s
+                i = i + 1
+        self._ready_for_tell = True
+        intermediate = np.array(self._xs, copy=True)
+
+        # Set as read-only so that it cannot be corrupted
+        intermediate.setflags(write=False)
+
+        return intermediate
+
+    def tell(self, fx):
+        """ See :meth:`ABCSampler.tell()`. """
+        if not self._ready_for_tell:
+            raise RuntimeError('tell called before ask.')
+        self._ready_for_tell = False
+        fx = np.asarray(fx)
+        accepted = fx < self._threshold
+        if np.any(accepted) > 0:
+            if self._t < len(self._e_schedule) - 1:
+                self._accepted_count += sum(accepted)
+                self._samples[self._t % 2].extend(
+                    [self._xs[c].tolist() for c, x in enumerate(accepted) if x]
+                )
+
+                if self._accepted_count >= self._nr_samples:
+                    self._advance_time()
+            return [self._xs[c].tolist() for c, x in
+                    enumerate(accepted) if x]
+
+        return None
+
+    def _advance_time(self):
+        t = self._t
+        if t == 0:
+            self._weights.append(
+                np.full(self._accepted_count, 1 / self._accepted_count))
+        else:
+            unnorm_weights = self._calculate_weights(
+                self._samples[self._t % 2], self._samples[(self._t - 1) % 2],
+                self._weights[t - 1])
+            # Normalise weights
+            normal = sum(unnorm_weights)
+            self._weights.append([w / normal for w in unnorm_weights])
+
+        self._samples[(t + 1) % 2] = []
+        self._accepted_count = 0
+        self._t += 1
+        self._threshold = self._e_schedule[self._t]
+        print(
+            "Starting t=" + str(self._t)
+            + ", with threshold=" + str(self._threshold))
+
+    def _calculate_weights(self, new_samples, old_samples, old_weights):
+        new_weights = []
+        for i in range(0, self._accepted_count):
+            prior_prob = np.exp(self._log_prior(new_samples[i]))
+
+            mw = [old_weights[j] * np.exp(self._perturbation_kernel(
+                np.subtract(new_samples[i], old_samples[j])))
+                for j in range(len(old_samples))]
+
+            w = prior_prob / sum(mw)
+            new_weights.append(w)
+        return new_weights
+
+    def set_perturbation_kernel(self, perturbation_kernel):
+        """
+        Sets the perturbation kernel used for perturbing particles
+        that are sampled from the previous generations. It must
+        implement the ``pints.LogPrior`` class.
+        """
+        if not isinstance(perturbation_kernel, pints.LogPrior):
+            raise ValueError('Perturbation kernel must implement ',
+                             'pints.LogPrior.')
+        self._perturbation_kernel = perturbation_kernel
+
+    def set_threshold_schedule(self, schedule):
+        """
+        Sets a schedule for the threshold error distance that determines if a
+        sample is accepted (if error < threshold). Schedule should be a list
+        of float values.
+        """
+        e_schedule = np.array(schedule)
+        if any(e_schedule <= 0):
+            raise ValueError('All threshold values must be positive.')
+        self._e_schedule = e_schedule
+        self._threshold = self._e_schedule[self._t]
+
+    def set_intermediate_size(self, n):
+        """
+        Sets the size of the intermediate distributions, after we find n
+        acceptable samples then we will progress to the next threshold values
+        in the schedule.
+        """
+        self._nr_samples = n


Test patch:
diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py
index eab78786f..9a7f2bd58 100644
--- a/pints/tests/test_abc_rejection.py
+++ b/pints/tests/test_abc_rejection.py
@@ -17,10 +17,12 @@ class TestRejectionABC(unittest.TestCase):
     """
     Tests the basic methods of the ABC Rejection routine.
     """
-    # Set up toy model, parameter values, problem, error measure
     @classmethod
     def setUpClass(cls):
-        """ Set up problem for tests. """
+        """
+        Set up toy model, parameter values, problem,
+        error measure.
+        """
 
         # Create toy model
         cls.model = toy.stochastic.DegradationModel()
diff --git a/pints/tests/test_abc_smc.py b/pints/tests/test_abc_smc.py
new file mode 100644
index 000000000..1cf64fb70
--- /dev/null
+++ b/pints/tests/test_abc_smc.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+#
+# Unit tests for the SMC ABC class.
+#
+# This file is part of PINTS (https://github.com/pints-team/pints/) which is
+# released under the BSD 3-clause license. See accompanying LICENSE.md for
+# copyright notice and full license details.
+#
+
+import unittest
+
+import numpy as np
+
+import pints
+import pints.toy as toy
+import pints.toy.stochastic
+
+
+class TestABCSMC(unittest.TestCase):
+    """
+    Tests the basic methods of the ABC SMC routine.
+    """
+# Set up toy model, parameter values, problem, error measure
+    @classmethod
+    def setUpClass(cls):
+        """ Set up problem for tests. """
+        # Create toy model
+        cls.model = toy.stochastic.DegradationModel()
+        cls.real_parameters = [0.1]
+        cls.times = np.linspace(0, 10, 10)
+        cls.values = cls.model.simulate(cls.real_parameters, cls.times)
+
+        # Create an object (problem) with links to the model and time series
+        cls.problem = pints.SingleOutputProblem(
+            cls.model, cls.times, cls.values)
+
+        # Create a uniform prior over both the parameters
+        cls.log_prior = pints.UniformLogPrior(
+            [0.0],
+            [0.3]
+        )
+
+        cls.transition_kernel = pints.MultivariateGaussianLogPrior(
+            np.zeros(1),
+            0.001 * np.identity(1)
+        )
+
+        # Set error measure
+        cls.error_measure = pints.RootMeanSquaredError(cls.problem)
+
+    def test_method(self):
+        # Create abc smc sampler
+        abc = pints.ABCSMC(self.log_prior)
+
+        # Configure
+        n_draws = 1
+        niter = 20
+        abc.set_intermediate_size(niter)
+        abc.set_threshold_schedule([6, 4, 2])
+
+        # Perform short run using ask and tell framework
+        samples = []
+        while len(samples) < 3 * niter:
+            xs = abc.ask(n_draws)
+            fxs = [self.error_measure(x) for x in xs]
+            sample = abc.tell(fxs)
+            while sample is None:
+                xs = abc.ask(n_draws)
+                fxs = [self.error_measure(x) for x in xs]
+                sample = abc.tell(fxs)
+            samples.append(sample)
+
+        samples = np.array(samples)
+        self.assertEqual(samples.shape[0], 3 * niter)
+
+    def test_method_list(self):
+        # Create abc smc sampler
+        abc = pints.ABCSMC(self.log_prior,
+                           pints.MultivariateGaussianLogPrior(
+                               np.zeros(1),
+                               0.001 * np.identity(1)))
+
+        # Configure
+        n_draws = 2
+        niter = 10
+        abc.set_intermediate_size(niter)
+        abc.set_threshold_schedule([6, 4, 2])
+        abc.set_perturbation_kernel(
+            pints.MultivariateGaussianLogPrior(
+                np.zeros(1),
+                0.001 * np.identity(1)))
+
+        # Perform short run using ask and tell framework
+        samples = []
+        while len(samples) < 3 * niter:
+            xs = abc.ask(n_draws)
+            fxs = [self.error_measure(x) for x in xs]
+            sample = abc.tell(fxs)
+            while sample is None:
+                xs = abc.ask(n_draws)
+                fxs = [self.error_measure(x) for x in xs]
+                sample = abc.tell(fxs)
+            samples.append(sample)
+
+        samples = np.array(samples)
+        self.assertEqual(samples.shape[0], 3 * niter)
+
+    def test_errors(self):
+        # test errors in abc rejection
+        abc = pints.ABCSMC(self.log_prior)
+        abc.ask(1)
+        # test two asks raises error
+        self.assertRaises(RuntimeError, abc.ask, 1)
+
+        # test tell with large value
+        self.assertEqual(None, abc.tell(100))
+        # test error raised if tell called before ask
+        self.assertRaises(RuntimeError, abc.tell, 2.5)
+
+        self.assertRaises(ValueError, abc.set_threshold_schedule, [1, -1])
+
+        self.assertRaises(ValueError, abc.set_perturbation_kernel, [1])
+
+        self.assertRaises(
+            ValueError,
+            pints.ABCSMC,
+            self.log_prior,
+            np.array([0]))
+
+    def test_name(self):
+        abc = pints.ABCSMC(self.log_prior)
+        self.assertEqual(abc.name(), 'ABC-SMC')
+
+
+if __name__ == '__main__':
+    unittest.main()