From a02b5d1dca4baaa810fea47a8165409c1efd46b1 Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Mon, 29 Jul 2019 18:37:09 +0100 Subject: [PATCH 01/56] Add files via upload --- ...tic degradation (Erban et al., 2007).ipynb | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb diff --git a/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb b/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb new file mode 100644 index 000000000..fc5a7844d --- /dev/null +++ b/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb @@ -0,0 +1,92 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stochastic Degradation Model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "k = 0.1\n", + "\n", + "for i in range(10):\n", + " A = 20\n", + " t = 0\n", + " tao_vals = []\n", + " mol_conc = []\n", + " time = []\n", + " \n", + " while A > 0:\n", + " r = np.random.uniform(0,1)\n", + " tao = (1/(A*k))*np.log(1/r)\n", + " tao_vals.append(tao)\n", + " t += tao\n", + " time.append(t)\n", + " A = A-1\n", + " mol_conc.append(A)\n", + " \n", + " plt.step(time, mol_conc) \n", + " \n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8f1140928940b4645c30a36cb576a140954f3683 Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:11:27 +0100 Subject: [PATCH 02/56] Add files via upload --- pints/toy/_stochastic_decay_model.py | 78 ++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py new file mode 100644 index 000000000..184a16b10 --- /dev/null +++ b/pints/toy/_stochastic_decay_model.py @@ -0,0 +1,78 @@ +# +# Logistic toy model. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import numpy as np +import pints + +from . import ToyModel + + +class StochasticDecayModel(pints.ForwardModelS1, ToyModel): + + """ + Stochastic decay model of a single chemical reaction [1]. + + .. math:: + + + Has one parameter: Rate constant :math:`k`. + The initial concentration :math:`A(0) = n_0` can be set using the + (optional) named constructor arg ``initial_concentration`` + + [1] Erban et al., 2007 + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + """ + + def __init__(self, initial_concentration=20): + super(StochasticDecayModel, self).__init__() + self._n0 = float(initial_concentration) + if self._n0 <= 0: + raise ValueError('Initial concentration must be positive.') + + def n_parameters(self): + """ See :meth:`pints.ForwardModel.n_parameters()`. """ + return 1 + + def simulate(self, parameter, times): + """ See :meth:`pints.ForwardModel.simulate()`. """ + return self._simulate(parameter, times, False) + + def simulateS1(self, parameter, times): + """ See :meth:`pints.ForwardModelS1.simulateS1()`. """ + return self._simulate(parameter, times, True) + + def _simulate(self, parameter, times, sensitivities): + if parameter <= 0: + raise ValueError('rate constant must be postive') + + A = self._n0 + k = float(parameter) + + t = 0 + mol_conc = [] + time = [] + + while A > 0: + r = np.random.uniform(0, 1) + tao = (1 / (A * k)) * np.log(1 / r) + t += tao + time.append(t) + A = A - 1 + mol_conc.append(A) + + + return mol_conc, time + + def suggested_parameter(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + + return 0.1 + From 5d5010f6879041ac6d4003132a7c348b21e98fc6 Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:20:42 +0100 Subject: [PATCH 03/56] Delete _stochastic_decay_model.py --- pints/toy/_stochastic_decay_model.py | 78 ---------------------------- 1 file changed, 78 deletions(-) delete mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py deleted file mode 100644 index 184a16b10..000000000 --- a/pints/toy/_stochastic_decay_model.py +++ /dev/null @@ -1,78 +0,0 @@ -# -# Logistic toy model. -# -# This file is part of PINTS. -# Copyright (c) 2017-2019, University of Oxford. -# For licensing information, see the LICENSE file distributed with the PINTS -# software package. -# -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals -import numpy as np -import pints - -from . import ToyModel - - -class StochasticDecayModel(pints.ForwardModelS1, ToyModel): - - """ - Stochastic decay model of a single chemical reaction [1]. - - .. math:: - - - Has one parameter: Rate constant :math:`k`. - The initial concentration :math:`A(0) = n_0` can be set using the - (optional) named constructor arg ``initial_concentration`` - - [1] Erban et al., 2007 - - *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. - """ - - def __init__(self, initial_concentration=20): - super(StochasticDecayModel, self).__init__() - self._n0 = float(initial_concentration) - if self._n0 <= 0: - raise ValueError('Initial concentration must be positive.') - - def n_parameters(self): - """ See :meth:`pints.ForwardModel.n_parameters()`. """ - return 1 - - def simulate(self, parameter, times): - """ See :meth:`pints.ForwardModel.simulate()`. """ - return self._simulate(parameter, times, False) - - def simulateS1(self, parameter, times): - """ See :meth:`pints.ForwardModelS1.simulateS1()`. """ - return self._simulate(parameter, times, True) - - def _simulate(self, parameter, times, sensitivities): - if parameter <= 0: - raise ValueError('rate constant must be postive') - - A = self._n0 - k = float(parameter) - - t = 0 - mol_conc = [] - time = [] - - while A > 0: - r = np.random.uniform(0, 1) - tao = (1 / (A * k)) * np.log(1 / r) - t += tao - time.append(t) - A = A - 1 - mol_conc.append(A) - - - return mol_conc, time - - def suggested_parameter(self): - """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - - return 0.1 - From 31f9b812f8ab51821ed4fddaf06b366ba526857f Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:21:17 +0100 Subject: [PATCH 04/56] Add files via upload --- pints/toy/_stochastic_decay_model.py | 74 ++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py new file mode 100644 index 000000000..0f9829b6f --- /dev/null +++ b/pints/toy/_stochastic_decay_model.py @@ -0,0 +1,74 @@ +# +# Logistic toy model. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import numpy as np +import pints + +from . import ToyModel + + +class StochasticDecayModel(pints.ForwardModelS1, ToyModel): + + """ + Stochastic decay model of a single chemical reaction [1]. + + .. math:: + + + Has one parameter: Rate constant :math:`k`. + The initial concentration :math:`A(0) = n_0` can be set using the + (optional) named constructor arg ``initial_concentration`` + + [1] Erban et al., 2007 + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + """ + + def __init__(self, initial_concentration=20): + super(StochasticDecayModel, self).__init__() + self._n0 = float(initial_concentration) + if self._n0 <= 0: + raise ValueError('Initial concentration must be positive.') + + def n_parameters(self): + """ See :meth:`pints.ForwardModel.n_parameters()`. """ + return 1 + + def simulate(self, parameter, times): + """ See :meth:`pints.ForwardModel.simulate()`. """ + return self._simulate(parameter, times, False) + + def _simulate(self, parameter, times, sensitivities): + if parameter <= 0: + raise ValueError('rate constant must be postive') + + A = self._n0 + k = float(parameter) + + t = 0 + mol_conc = [] + time = [] + + while A > 0: + r = np.random.uniform(0, 1) + tao = (1 / (A * k)) * np.log(1 / r) + t += tao + time.append(t) + A = A - 1 + mol_conc.append(A) + + + return mol_conc, time + + def suggested_parameter(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + + return 0.1 + From 92d9aa9747c8fe63b393af22027ae58a2a48f6db Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:25:38 +0100 Subject: [PATCH 05/56] Delete _stochastic_decay_model.py --- pints/toy/_stochastic_decay_model.py | 74 ---------------------------- 1 file changed, 74 deletions(-) delete mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py deleted file mode 100644 index 0f9829b6f..000000000 --- a/pints/toy/_stochastic_decay_model.py +++ /dev/null @@ -1,74 +0,0 @@ -# -# Logistic toy model. -# -# This file is part of PINTS. -# Copyright (c) 2017-2019, University of Oxford. -# For licensing information, see the LICENSE file distributed with the PINTS -# software package. -# -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals -import numpy as np -import pints - -from . import ToyModel - - -class StochasticDecayModel(pints.ForwardModelS1, ToyModel): - - """ - Stochastic decay model of a single chemical reaction [1]. - - .. math:: - - - Has one parameter: Rate constant :math:`k`. - The initial concentration :math:`A(0) = n_0` can be set using the - (optional) named constructor arg ``initial_concentration`` - - [1] Erban et al., 2007 - - *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. - """ - - def __init__(self, initial_concentration=20): - super(StochasticDecayModel, self).__init__() - self._n0 = float(initial_concentration) - if self._n0 <= 0: - raise ValueError('Initial concentration must be positive.') - - def n_parameters(self): - """ See :meth:`pints.ForwardModel.n_parameters()`. """ - return 1 - - def simulate(self, parameter, times): - """ See :meth:`pints.ForwardModel.simulate()`. """ - return self._simulate(parameter, times, False) - - def _simulate(self, parameter, times, sensitivities): - if parameter <= 0: - raise ValueError('rate constant must be postive') - - A = self._n0 - k = float(parameter) - - t = 0 - mol_conc = [] - time = [] - - while A > 0: - r = np.random.uniform(0, 1) - tao = (1 / (A * k)) * np.log(1 / r) - t += tao - time.append(t) - A = A - 1 - mol_conc.append(A) - - - return mol_conc, time - - def suggested_parameter(self): - """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - - return 0.1 - From 4e83464a8c30ccf4b4e2d5cb6ec988b948a24d8f Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:25:53 +0100 Subject: [PATCH 06/56] Add files via upload --- pints/toy/_stochastic_decay_model.py | 74 ++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py new file mode 100644 index 000000000..7b87357a0 --- /dev/null +++ b/pints/toy/_stochastic_decay_model.py @@ -0,0 +1,74 @@ +# +# Logistic toy model. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import numpy as np +import pints + +from . import ToyModel + + +class StochasticDecayModel(pints.ForwardModelS1, ToyModel): + + """ + Stochastic decay model of a single chemical reaction [1]. + + .. math:: + + + Has one parameter: Rate constant :math:`k`. + The initial concentration :math:`A(0) = n_0` can be set using the + (optional) named constructor arg ``initial_concentration`` + + [1] Erban et al., 2007 + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + """ + + def __init__(self, initial_concentration=20): + super(StochasticDecayModel, self).__init__() + self._n0 = float(initial_concentration) + if self._n0 <= 0: + raise ValueError('Initial concentration must be positive.') + + def n_parameters(self): + """ See :meth:`pints.ForwardModel.n_parameters()`. """ + return 1 + + def simulate(self, parameter): + """ See :meth:`pints.ForwardModel.simulate()`. """ + return self._simulate(parameter, False) + + def _simulate(self, parameter): + if parameter <= 0: + raise ValueError('rate constant must be postive') + + A = self._n0 + k = float(parameter) + + t = 0 + mol_conc = [] + time = [] + + while A > 0: + r = np.random.uniform(0, 1) + tao = (1 / (A * k)) * np.log(1 / r) + t += tao + time.append(t) + A = A - 1 + mol_conc.append(A) + + + return mol_conc, time + + def suggested_parameter(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + + return 0.1 + From 1ce4cf97f6fc49e6129c05b1fef7debbf40fae4a Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:26:56 +0100 Subject: [PATCH 07/56] Delete _stochastic_decay_model.py --- pints/toy/_stochastic_decay_model.py | 74 ---------------------------- 1 file changed, 74 deletions(-) delete mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py deleted file mode 100644 index 7b87357a0..000000000 --- a/pints/toy/_stochastic_decay_model.py +++ /dev/null @@ -1,74 +0,0 @@ -# -# Logistic toy model. -# -# This file is part of PINTS. -# Copyright (c) 2017-2019, University of Oxford. -# For licensing information, see the LICENSE file distributed with the PINTS -# software package. -# -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals -import numpy as np -import pints - -from . import ToyModel - - -class StochasticDecayModel(pints.ForwardModelS1, ToyModel): - - """ - Stochastic decay model of a single chemical reaction [1]. - - .. math:: - - - Has one parameter: Rate constant :math:`k`. - The initial concentration :math:`A(0) = n_0` can be set using the - (optional) named constructor arg ``initial_concentration`` - - [1] Erban et al., 2007 - - *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. - """ - - def __init__(self, initial_concentration=20): - super(StochasticDecayModel, self).__init__() - self._n0 = float(initial_concentration) - if self._n0 <= 0: - raise ValueError('Initial concentration must be positive.') - - def n_parameters(self): - """ See :meth:`pints.ForwardModel.n_parameters()`. """ - return 1 - - def simulate(self, parameter): - """ See :meth:`pints.ForwardModel.simulate()`. """ - return self._simulate(parameter, False) - - def _simulate(self, parameter): - if parameter <= 0: - raise ValueError('rate constant must be postive') - - A = self._n0 - k = float(parameter) - - t = 0 - mol_conc = [] - time = [] - - while A > 0: - r = np.random.uniform(0, 1) - tao = (1 / (A * k)) * np.log(1 / r) - t += tao - time.append(t) - A = A - 1 - mol_conc.append(A) - - - return mol_conc, time - - def suggested_parameter(self): - """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - - return 0.1 - From 12ed51fcaade7247a95ab81f8354735d5c53359f Mon Sep 17 00:00:00 2001 From: danielfridman98 <34761927+danielfridman98@users.noreply.github.com> Date: Tue, 30 Jul 2019 18:27:10 +0100 Subject: [PATCH 08/56] Add files via upload --- pints/toy/_stochastic_decay_model.py | 74 ++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py new file mode 100644 index 000000000..53ab605ba --- /dev/null +++ b/pints/toy/_stochastic_decay_model.py @@ -0,0 +1,74 @@ +# +# Logistic toy model. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import numpy as np +import pints + +from . import ToyModel + + +class StochasticDecayModel(pints.ForwardModelS1, ToyModel): + + """ + Stochastic decay model of a single chemical reaction [1]. + + .. math:: + + + Has one parameter: Rate constant :math:`k`. + The initial concentration :math:`A(0) = n_0` can be set using the + (optional) named constructor arg ``initial_concentration`` + + [1] Erban et al., 2007 + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + """ + + def __init__(self, initial_concentration=20): + super(StochasticDecayModel, self).__init__() + self._n0 = float(initial_concentration) + if self._n0 <= 0: + raise ValueError('Initial concentration must be positive.') + + def n_parameters(self): + """ See :meth:`pints.ForwardModel.n_parameters()`. """ + return 1 + + def simulate(self, parameter): + """ See :meth:`pints.ForwardModel.simulate()`. """ + return self._simulate(parameter) + + def _simulate(self, parameter): + if parameter <= 0: + raise ValueError('rate constant must be postive') + + A = self._n0 + k = float(parameter) + + t = 0 + mol_conc = [] + time = [] + + while A > 0: + r = np.random.uniform(0, 1) + tao = (1 / (A * k)) * np.log(1 / r) + t += tao + time.append(t) + A = A - 1 + mol_conc.append(A) + + + return mol_conc, time + + def suggested_parameter(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + + return 0.1 + From 83761e9d3a14d9a264631cd1961cd6367f1fc5c2 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 31 Jul 2019 13:53:48 +0100 Subject: [PATCH 09/56] Rename example --- ...tic degradation (Erban et al., 2007).ipynb | 92 ------ .../toy-model-stochastic-degradation.ipynb | 282 ++++++++++++++++++ 2 files changed, 282 insertions(+), 92 deletions(-) delete mode 100644 examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb create mode 100644 examples/toy-model-stochastic-degradation.ipynb diff --git a/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb b/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb deleted file mode 100644 index fc5a7844d..000000000 --- a/examples/toy-model-stochastic degradation (Erban et al., 2007).ipynb +++ /dev/null @@ -1,92 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Stochastic Degradation Model" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "k = 0.1\n", - "\n", - "for i in range(10):\n", - " A = 20\n", - " t = 0\n", - " tao_vals = []\n", - " mol_conc = []\n", - " time = []\n", - " \n", - " while A > 0:\n", - " r = np.random.uniform(0,1)\n", - " tao = (1/(A*k))*np.log(1/r)\n", - " tao_vals.append(tao)\n", - " t += tao\n", - " time.append(t)\n", - " A = A-1\n", - " mol_conc.append(A)\n", - " \n", - " plt.step(time, mol_conc) \n", - " \n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb new file mode 100644 index 000000000..8f62545c6 --- /dev/null +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -0,0 +1,282 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import scipy \n", + "from scipy.interpolate import interp1d\n", + "import math" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stochastic Degradation Model" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "k = 0.1\n", + "\n", + "for i in range(10):\n", + " A = 20\n", + " t = 0\n", + " tao_vals = []\n", + " mol_conc = [A]\n", + " time = [t]\n", + " \n", + " while A > 0:\n", + " r = np.random.uniform(0,1)\n", + " tao = (1/(A*k))*np.log(1/r)\n", + " tao_vals.append(tao)\n", + " t += tao\n", + " time.append(t)\n", + " A = A-1\n", + " mol_conc.append(A)\n", + " \n", + " plt.step(time, mol_conc, where='post') \n", + " \n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [], + "source": [ + "f1 = interp1d(time, mol_conc, kind = 'previous')" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "x_new = np.linspace(0,math.floor(max(time)),num=math.floor(max(time))+1)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.step(time, mol_conc, where='post')\n", + "plt.plot(x_new, f1(x_new), '-')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([20., 14., 12., 9., 9., 6., 5., 4., 3., 2., 2., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f1(x_new)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0,\n", + " 0.1996986803279101,\n", + " 0.2522707803787877,\n", + " 0.41682038458525944,\n", + " 0.5179632844084141,\n", + " 0.7480299643393336,\n", + " 0.7851812671973191,\n", + " 1.1547169496549954,\n", + " 1.9370806084188108,\n", + " 2.37620748268798,\n", + " 2.5215431230663192,\n", + " 2.9371973684584813,\n", + " 4.269445779831648,\n", + " 4.482885472976252,\n", + " 4.848794875464168,\n", + " 5.01264086221713,\n", + " 6.703711312246048,\n", + " 7.161381975606392,\n", + " 8.600201986398055,\n", + " 10.841909921883971,\n", + " 21.24688500818157]" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "time" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mol_conc" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.,\n", + " 13., 14., 15., 16., 17., 18., 19., 20., 21.])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_new" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "times = np.arange(0,100)" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.concatenate((f1(times[np.where(times<=max(time))]), np.zeros(len(times[np.where(times>max(time))]))))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 98b7eb5c40624b1bc4dc1e466e980e5f94374618 Mon Sep 17 00:00:00 2001 From: Chon Lok Lei Date: Wed, 31 Jul 2019 14:02:29 +0100 Subject: [PATCH 10/56] Demo for Daniel --- pints/toy/_stochastic_decay_model.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py index 53ab605ba..a9b5737cb 100644 --- a/pints/toy/_stochastic_decay_model.py +++ b/pints/toy/_stochastic_decay_model.py @@ -14,7 +14,7 @@ from . import ToyModel -class StochasticDecayModel(pints.ForwardModelS1, ToyModel): +class StochasticDegredationModel(pints.ForwardModel, ToyModel): """ Stochastic decay model of a single chemical reaction [1]. @@ -32,7 +32,7 @@ class StochasticDecayModel(pints.ForwardModelS1, ToyModel): """ def __init__(self, initial_concentration=20): - super(StochasticDecayModel, self).__init__() + super(StochasticDegredationModel, self).__init__() self._n0 = float(initial_concentration) if self._n0 <= 0: raise ValueError('Initial concentration must be positive.') @@ -43,9 +43,6 @@ def n_parameters(self): def simulate(self, parameter): """ See :meth:`pints.ForwardModel.simulate()`. """ - return self._simulate(parameter) - - def _simulate(self, parameter): if parameter <= 0: raise ValueError('rate constant must be postive') @@ -64,11 +61,9 @@ def _simulate(self, parameter): A = A - 1 mol_conc.append(A) - return mol_conc, time def suggested_parameter(self): """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - return 0.1 From 740bfd05d46014e80af243c13dc5af44ffca6002 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 31 Jul 2019 14:47:44 +0100 Subject: [PATCH 11/56] updated stochastic example --- .../toy-model-stochastic-degradation.ipynb | 193 +----------------- 1 file changed, 3 insertions(+), 190 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index 8f62545c6..99a251c8c 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 49, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -23,12 +23,12 @@ }, { "cell_type": "code", - "execution_count": 106, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -63,193 +63,6 @@ "plt.show()\n" ] }, - { - "cell_type": "code", - "execution_count": 121, - "metadata": {}, - "outputs": [], - "source": [ - "f1 = interp1d(time, mol_conc, kind = 'previous')" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "metadata": {}, - "outputs": [], - "source": [ - "x_new = np.linspace(0,math.floor(max(time)),num=math.floor(max(time))+1)" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.step(time, mol_conc, where='post')\n", - "plt.plot(x_new, f1(x_new), '-')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([20., 14., 12., 9., 9., 6., 5., 4., 3., 2., 2., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1.])" - ] - }, - "execution_count": 109, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f1(x_new)" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0,\n", - " 0.1996986803279101,\n", - " 0.2522707803787877,\n", - " 0.41682038458525944,\n", - " 0.5179632844084141,\n", - " 0.7480299643393336,\n", - " 0.7851812671973191,\n", - " 1.1547169496549954,\n", - " 1.9370806084188108,\n", - " 2.37620748268798,\n", - " 2.5215431230663192,\n", - " 2.9371973684584813,\n", - " 4.269445779831648,\n", - " 4.482885472976252,\n", - " 4.848794875464168,\n", - " 5.01264086221713,\n", - " 6.703711312246048,\n", - " 7.161381975606392,\n", - " 8.600201986398055,\n", - " 10.841909921883971,\n", - " 21.24688500818157]" - ] - }, - "execution_count": 76, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "time" - ] - }, - { - "cell_type": "code", - "execution_count": 104, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]" - ] - }, - "execution_count": 104, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mol_conc" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.,\n", - " 13., 14., 15., 16., 17., 18., 19., 20., 21.])" - ] - }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "x_new" - ] - }, - { - "cell_type": "code", - "execution_count": 112, - "metadata": {}, - "outputs": [], - "source": [ - "times = np.arange(0,100)" - ] - }, - { - "cell_type": "code", - "execution_count": 134, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "100" - ] - }, - "execution_count": 134, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.concatenate((f1(times[np.where(times<=max(time))]), np.zeros(len(times[np.where(times>max(time))]))))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, From bb9dd08de6fcee47bf4361dcc4154c6d425c8fec Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 31 Jul 2019 14:52:33 +0100 Subject: [PATCH 12/56] updated stochastic model --- pints/toy/_stochastic_degradation_model.py | 88 ++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 pints/toy/_stochastic_degradation_model.py diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py new file mode 100644 index 000000000..f68d4f0c0 --- /dev/null +++ b/pints/toy/_stochastic_degradation_model.py @@ -0,0 +1,88 @@ +# +# Logistic toy model. +# +# This file is part of PINTS. +# Copyright (c) 2017-2019, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import numpy as np +import pints + +from . import ToyModel + + +class StochasticDegradationModel(pints.ForwardModel, ToyModel): + + """ + Stochastic decay model of a single chemical reaction [1]. + + Time until next reaction... + .. math:: + $\tau = \frac{1}{A(t)k}*\ln{\frac{1}{r}}$ + + Has one parameter: Rate constant :math:`k`. + :math:`r` is a random variable, which is part of the stochastic model + The initial concentration :math:`A(0) = n_0` can be set using the + (optional) named constructor arg ``initial_concentration`` + + [1] Erban et al., 2007 + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + """ + + def __init__(self, initial_concentration=20): + super(StochasticDegradationModel, self).__init__() + self._n0 = float(initial_concentration) + if self._n0 < 0: + raise ValueError('Initial concentration cannot be negative.') + + def n_parameters(self): + """ See :meth:`pints.ForwardModel.n_parameters()`. """ + return 1 + + def simulate(self, parameters, times): + """ See :meth:`pints.ForwardModel.simulate()`. """ + if parameters <= 0: + raise ValueError('rate constant must be positive') + + k = [float(parameters)] + times = np.asarray(times) + if np.any(times < 0): + raise ValueError('Negative times are not allowed.') + if self._n0 == 0: + return np.zeros(times.shape) + a = self._n0 + + t = 0 + mol_conc = [a] + time = [t] + + # Run stochastic degradation algorithm, calculating time until next + # reaction and decreasing concentration by 1 at that time + while a > 0: + r = np.random.uniform(0, 1) + tao = (1 / (a * k)) * np.log(1 / r) + t += tao + time.append(t) + a = a - 1 + mol_conc.append(a) + + # Interpolate as step function, decreasing mol_conc by 1 at each + # reaction time point + f1 = interp1d(time, mol_conc, kind='previous') + + # Compute concentration ('a') values at given time points using f1 + # at any time beyond the last reaction, concentration = 0 + values = f1(times[np.where(times <= max(time))]) + zero_vector = np.zeros(len(times[np.where(times > max(time))])) + values = np.concatenate((values, zero_vector)) + + return values + + def suggested_parameter(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + return 0.1 + From b9ddbd32df1a25635c8444295e08ddea843bea76 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 31 Jul 2019 17:27:50 +0100 Subject: [PATCH 13/56] updated sotchastic degradation example notebook --- .../toy-model-stochastic-degradation.ipynb | 119 ++++++++++++++---- 1 file changed, 92 insertions(+), 27 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index 99a251c8c..b619068c7 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -1,16 +1,32 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stochastic Degradation Model\n", + "\n", + "This example shows how the Stochastic Degradation Model can be used.\n", + "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n", + "The substance degrades starting from an initial concentration, n_0, to 0 following a rate constant, k:\n", + " $$A \\xrightarrow{\\text{k}} \\emptyset$$\n", + " \n", + "The time until the next single reaction occurs is modelled as follows:\n", + " $$ \\tau = \\frac{1}{A(t)k} \\ln{\\big[\\frac{1}{r}\\big]} $$\n", + " \n", + "(adapted from Erban et al., 2007)" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", - "import matplotlib\n", + "import pints\n", + "import pints.toy\n", "import matplotlib.pyplot as plt\n", - "import scipy \n", - "from scipy.interpolate import interp1d\n", + "import numpy as np\n", "import math" ] }, @@ -18,17 +34,72 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Stochastic Degradation Model" + "Specify initial concentration, time points at which to record concentration values, and rate constant value (k)" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "n_0 = 20\n", + "model = pints.toy.StochasticDegradationModel(n_0)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "times = np.linspace(0, 100, 100)\n", + "k = 0.1\n", + "\n", + "values = model.simulate(k, times)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXRc5Znn8e9TWizJ8iJZsmQbLzgsXrAxoNgQQmIIECMgLI3D0m1oJX2ge5I+yQndHXfPTAjJ6R56Zki6J/RJ4gGU5QTihmCy0QROEppkEiCycTA2GBsvYFuyZcuLZO2qZ/6oKrkkVUmlqtLi69/nHB3Vfe97733rIp56fes+9zF3R0REgis01gMQEZGRpUAvIhJwCvQiIgGnQC8iEnAK9CIiAZc71gNIpKyszOfNmzfWwxAROW1s3LjxsLuXJ1o3LgP9vHnzqKurG+thiIicNsxsb7J1unQjIhJwCvQiIgGnQC8iEnAK9CIiAadALyIScEMGejObbWa/NrO3zGyrmX0u2l5qZi+a2Y7o75Ik298T7bPDzO7J9hsQEZHBpTKj7wbud/eFwKXAZ8xsEbAW+KW7nwv8Mrrch5mVAg8AK4DlwAPJPhBERGRkDHkfvbvXA/XR181m9hYwC7gJWBnt9l3gJeCL/Tb/OPCiuzcBmNmLwCrgySyMfYA7n/0m+4vKIuMG3Jy2UC5t5Pf2KS0opbwoYU5BUrdWlLBmZlk2hyoiMmqGdY3ezOYBFwGvAhXRD4HYh8H0BJvMAt6PW94XbUu073vNrM7M6hobG4czrCSc3FA3BdbZ29La1UpTe9Ow9rK1pY1nDh7NwnhERMZGypmxZlYM/Aj4vLufMLOUNkvQlrDSibuvA9YBVFVVpVUN5cmb/4r1D65l4ZHFvDz5EGdd8mNmzz2LSy5+AoCa52ugC2ovqk15n7e8viOdoYiIjBspzejNLI9IkP+Buz8TbT5oZjOi62cAhxJsug+YHbd8FnAg/eGKiMhwpXLXjQGPAW+5+9fiVv0EiN1Fcw/w4wSb/wK41sxKol/CXhttExGRUZLKjP5yYA1wlZltjv5UAw8B15jZDuCa6DJmVmVmjwJEv4T9KvCH6M9XYl/MiojI6EjlrpvfkvhaO8DHEvSvA/4ibvlx4PF0BygiIplRZqyISMAp0IuIBJwCvYhIwI3LClOZ6rYQuaEcwt7NkcZN/PTpFQB8dF8luw7PZu3WtZQWllJeGMmQXbJkCVVVVUn39/tjJ/n+gcPKjhWR01LgZvQLL1/J3pPbOKenktaGhXQ0TwFgwqTjlM44wNRWo7W7laa2yM0/DQ0NbNmyJen+bq2IPJpH2bEicroKXKBfevUqjoY3Mq01xMX1n+LG217lxtteZVr5xUzr7uZPGo/TfGEzBxcfpKamhsrKykH3t2ZmGZdNnThKoxcRyb7ABXoREelLgV5EJOAU6EVEAk6BXkQk4BToRUQCToFeRCTgFOhFRAIukJmxAB7uorCjk21ffIGivFZ6rmikfcYJDk/ezB3fKABg7w/upnvJBRzu6aG2NlJ1aqgsWRGR000gZ/TTzl/M3pPbONbVSFdPHnRNZfKeCwBo/1BOb7/2t99m7p69vUlTQ2XJioicjgIZ6G/64sNszjnKs60vsWvGFFrppLShiqlTV1CwcCE//OvF/PCvF1OwYAHnNzdTU1OTUpasiMjpaMhLN2b2OHADcMjdL4i2rQfOj3aZChxz92UJtt0DNAM9QLe765qIiMgoS+Ua/XeAR4DvxRrc/fbYazN7GDg+yPZXuvvhdAcoIiKZSaWU4MtmNi/Rumjh8E8CV2V3WCIiki2ZXqO/Ajjo7juSrHfgBTPbaGb3DrYjM7vXzOrMrK6xsTHDYYmISEymgf5O4MlB1l/u7hcD1wGfMbOPJOvo7uvcvcrdq8rLyzMcloiIxKQd6M0sF7gVWJ+sj7sfiP4+BGwAlqd7PBERSU8mM/qrgbfdfV+ilWY20cwmxV4D1wJvZnA8ERFJQyq3Vz4JrATKzGwf8IC7PwbcQb/LNmY2E3jU3auBCmBD5PtacoEn3P357A5/cAUnGtj5x3XMm3YVnTaHpp17YeoRbjyRT4/3sO2aMEXt3ez+/gXkhfIom5RPt4X42Y8fo7T8Bj70obW9+9ra0sYtryf7KiK5WytKVGtWRMZUKnfd3Jmk/c8TtB0AqqOvdwEXZji+tM2u+jDv1/2W4rYwe1t3Uz5hBpMPfJCjua+QG+ok1OF05hqh/G5ywl3khfIo7OmhjTB5xUc5euwXQCTQx+rGDtfWljYABXoRGVPm7mM9hgGqqqq8rq4uK/va8PAmAC5qijzaYN4/3gPA+gcjQfz5FQcBqF0VedbN3jV388ZN2wkVFXF99a8zOnbsXwAbLjo3o/2IiAzFzDYmS0oN5CMQRETkFAV6EZGAU6AXEQk4BXoRkYBToBcRCTgFehGRgFOgFxEJuMDWjI13YMcxFk2dxETKqf8ff8eMaxYC0LhnN2c3ddLc2cwjv/405UXltHedYLI7RTn1bHh6BQBmBmaEcnOZPGUqkyZNAqCy4kZmzUqYT9YrUUatsmVFZDQFfkZ/3vIKAN6jCABrng9bnmbh5Sspn3c2pQWlADS1NwGQO20aLbum0do8JbIDd9ydcDhMd3c3J0+2ANDSso2Ggz8d9Ni3VpSwuLiwT9vWljaeOXg0a+9PRGQogZ/RL75iFu+8dpAWYGfzSeZ1RQLv0qtXsfTqVQDUPF/DYeBLqx4asP3eNXcD8Mo5M9nr+ZTPPZvrq2vYuOmuIY+9ZmbZgJl7Os/LERHJROBn9CIiZzoFehGRgFOgFxEJOAV6EZGAU6AXEQm4IQO9mT1uZofM7M24ti+b2X4z2xz9qU6y7Soz225mO81sbaI+IiIyslKZ0X8HWJWg/evuviz681z/lWaWA/wbcB2wCLjTzBZlMlgRERm+VEoJvmxm89LY93JgZ7SkIGb2Q+AmYFsa+8rY4X0tzM6HXJvPy2/8Ge997jF6CsuYXD6b85uuobmrmXV1v6C8sLx3m/OWV1Act4/O9jbe37uHR772MGcvqCc//yA/f+5KSqZ+vE992aHEZ8sqS1ZERlom1+g/a2ZvRC/tJCqqOgt4P255X7QtITO718zqzKyusbExg2ENdN7yCsrOKuZQXuTtluaWUhBuI6ftcGS5cBoATW1Herc5vK+Fd1472Lu88PKVlBXkE2pvpfXEcU6evIDOzgpycxui9WVTE58tqyxZERkN6WbGfhP4KuDR3w8Dn+rXxxJsl7RArbuvA9ZBpGZsmuNKaPEVs1h8ReQz5tC332A6U7AjX42su//TQCQ7FmDtqkjGa6zWbEwskzZSa7aTT67+BgA/f+7KYY0lPltWWbIiMhrSmtG7+0F373H3MPB/iVym6W8fMDtu+SzgQDrHExGR9KUV6M1sRtziLcCbCbr9ATjXzM42s3zgDuAn6RxPRETSN+SlGzN7ElgJlJnZPuABYKWZLSNyKWYPcF+070zgUXevdvduM/ss8AsgB3jc3beOyLsQEZGkUrnrJtED1x9L0vcAUB23/Bww4NZLEREZPcqMFREJOAV6EZGAU6AXEQk4c8/qLetZUVVV5XV1dSOy70PffoOu+ha6unYwIdxGRyiSvLQnr4d2c/I8jy7LY1prBbk9ORxpPcrB44cJFUVKER7p/E862vdTNu8TVN1wPXua/4zc3HomTDi3t5ZsvMHqysbuo99w0bkj8l5F5MxhZhvdvSrRujNuRl+0rJy8GcX0FJb1BnmAKT1GkTs5dBOmnba8ZibnGNOKJvcG+XBrKwXR5N6jB17nndcOUjL147S0lPbWko2XSl1ZEZGRFviasf0Vr5hB8YoZTGdpn/Z5ALXXA1AzYzoA97zyKSCPO/93JFt275q7IQyvLLqAw+9HAvuHPrSW2toKThyH66tr+uwzlbqyIiIj7Yyb0YuInGkU6EVEAk6BXkQk4BToRUQCToFeRCTgFOhFRALujLu9MlXbm7bTbvuY117G8w8+Sa5P4uySanI72lh0dAJdE4H33+X1z+/kZPEhjud08PUH/pEu62AyPZRYD1OW7CKn+BjPP3MpAEVTpjKxpLT3GC0tdwCwcdMDgyZWiYhkQoE+ger5kQdwbi7fCY0Qpp1Od47lT2Z6jjHBw4TNCOM4xqyOqeQUnCRsPTRbJ5BDCT20N86hILrPzvY2gD6BPqalZRsNoEAvIiNCgT6B1eetZvV5q3uXa56vYVv9CeZ1/g3r77uhT98ND2+i/e0ubiieyoQFC/l5/kYAbq/pmzy1/sG1tAGrbn2ot604+giEYl80Qu9ERCSFa/TR4t+HzOzNuLb/ZWZvR4uDbzCzqUm23WNmW8xss5mNzMNrRERkUKl8GfsdYFW/theBC9x9KfAO8PeDbH+luy9L9rAdEREZWUMGend/GWjq1/aCu3dHF18hUvhbRETGoWzcXvkp4D+SrHPgBTPbaGb3DrYTM7vXzOrMrK6xsTELwxIREcgw0JvZfwW6gR8k6XK5u18MXAd8xsw+kmxf7r7O3avcvaq8vDyTYYmISJy0A72Z3QPcAPypJ6leEi0WjrsfAjYAy9M9noiIpCetQG9mq4AvAp9w99YkfSaa2aTYa+Ba4M1EfUVEZOQMeR+9mT0JrATKzGwf8ACRu2wmAC+aGcAr7v6XZjYTeNTdq4EKYEN0fS7whLs/PyLvYhS0ht5hW8sL3P7tvu1L6zsopYRjHqL43SZO5h/leM5JHvlvX2N2Vzlzmjspbf5P2rtOcNx7+O4dN/due/DGP+dA2Qy+YDdjOd34C//eZ9+Xdb5GdeGbCZOs4imrVkQGM2Sgd/dEEeSxJH0PANXR17uACzMa3ThRPb+auoN1FJW+AZ3X9ll3qCSHSS0dHGh3ZpgxmzLIh+M5J8mxEB8oXAzNMCeUz3vhzj7bXrhtIyy6hPDUCQP+afVezll4bg8rj/920ECvrFoRGYoyY1Ow+rzVPLfrOQBqV102aN9YgcK//ad/ZVKbEyoqYu73v8fcBH1Xrrkb3tvL3O9/b8C6W17fQeOeFo5vWdknm7Y/lSsUkaHo6ZUiIgGnQC8iEnAK9CIiAadALyIScAr0IiIBp0AvIhJwCvQiIgFnSR5TM6aqqqq8rm4M6pTUXg8NW6BySd/2JbdRc/hltjdt5/zS86meX92nAlUif/tP/8qUjmamhYvp6reuKwTh3BzCra3Q0wM5OQO2f6rqgxyaVEzZiSYslEdeThF5VjCgX07hHgi1Q7iAS7ve4Mquvuet6+iH6TpyTdJxnre8gsVXzBr0vYjI+GdmG5PV/VDCVLwltw1sa9gCQPXlfw5EioYDQwb6s89dyPE3tw0I8nkAYegALC+PZB+z5x/Yj8+cgQNOmG7vSBjow91TCOXCezmVAH0CfU7hHoCkgf7wvhYABXqRgNOMfii110d+1/w88uv5SC3Y2lW1ae3upS//BoCVX75i0H5719wNwCvnzGSv51M+92xq+tWhjXdLtP7shovO7W2LZc1ecvETCbfZ8PCmyLb3X5zi6EVkvBpsRq9r9CIiAadALyIScAr0IiIBp0AvIhJwCvQiIgGXUqA3s8fN7JCZvRnXVmpmL5rZjujvkiTb3hPtsyNaZ1ZEREZRqjP67wCr+rWtBX7p7ucCv4wu92FmpURKD64gUhj8gWQfCCIiMjJSCvTu/jLQ1K/5JuC70dffBW5moI8DL7p7k7sfBV5k4AfG+Lf3t1B36r75uoN1PPXOU2nvrrLdeenLv+FXP9yaUv+Okyc5sG8ftbW1vT+J8gx+f+wk3z9wOO1xiUgwZXKNvsLd6wGiv6cn6DMLeD9ueV+0bQAzu9fM6sysrrGxMYNhZVksW3bL00CkfizQW1pwuMILSmkoMCrbndDb/T87B1p4+UpyTxwhr+dUjm1DQwNbtmzp0+/Wisg/lJ45eDStcYlIcI30l7GWoC1hKq67r3P3KnevKi8vH+FhDUNVDcz9cO/i6vNWU1WRMPksJVfdsZiVX76ChoJEp2agpVevYv7MSuZaJzU1NdTU1FBZWTmg35qZZVw2dWLa4xKR4Mok0B80sxkA0d+HEvTZB8yOWz4LOJDBMUVEZJgyCfQ/AWJ30dwD/DhBn18A15pZSfRL2GujbSIiMkpSvb3ySeD3wPlmts/MPg08BFxjZjuAa6LLmFmVmT0K4O5NwFeBP0R/vhJtExGRUZLSY4rd/c4kqz6WoG8d8Bdxy48Dj6c1OhERyZgyY0VEAk6BXkQk4BToRUQCThWmUpGgylSsfuxwxNeafenLv+GcdnhqWohXJp/6vL1p2SzuWjGHvWvupv3ttylYsICXuk5w3HuYYpHasvVzzqFzQiH5HW199v/U8mtonFxC+YmjhIDCyccI5fQQ7skh1J5PUUvfr2SOh0rptnwmhk/wiXc3ccv2vklYk2+4gZLbPzms9ygiY0MVprKsen71sIP89qbtfbJpwwtKAbjoZLi3bVv9CX68eT8QCbIFCxYAMCeU3xvkASYePzogyAMsqN9N+YmjOE4Y6OksiAT5nB7CBZ0D+k/wdgB2lU7lhfkL+qxrf/ttTvzsZ8N6jyIyPqk4eBpWn7d6yOLg/cVqzcZcdcdiDh1/g0XA+vuWAnD7t3/fu77k9k/2zqbnDnN86x+MPF/u9gceAuDnz10JwPV3/XpA3w0Pb+JrhcaEhQuYe9f3ettjNWtF5PSnGb2ISMAp0IuIBJwCvYhIwCnQi4gEnAK9iEjAKdCLiAScAr2ISMDpPvpUxerGVtUM3TeJWK3Z+HvwO3cfp+XVeopXzAAiSVPx99OnY8GBExS1HOSB+/4LAEuvaaN48jGeevYjABw4fD77Dl0AQHFbmLbO5WxshEuePpWNnF99LxYO40/+NrKPXce4auPv2TujmI1LV/b2i2Xyisj4pRl9KvrVjU1HolqzRcsiJRNbN0dq5N60bBaLZkxO+xgxRyoW01pc0bvctKuUlhNTAZhU1MjMsu2963pyTvKBxvcpP9HTZx89oVw8FPnzqC8tZPMHyumcMI8l21/t7ROfySsi45dm9KmoqskoyEMkm7Z/QfHiFTN6gzzAXSvmZGl2fFmfpfUPrqV7ayRTduOmuygHVt/8OQBqa2s5mzZqbkteB/eW13dwuKOF3OKJLMqdzPr7IvvP9F8eIjI60p7Rm9n5ZrY57ueEmX2+X5+VZnY8rs+XMh+yiIgMR9ozenffDiwDMLMcYD+wIUHX37j7DekeR0REMpOta/QfA951971Z2p+IiGRJtgL9HcCTSdZdZmZ/NLP/MLPFyXZgZveaWZ2Z1TU2NibrJiIiw5RxoDezfOATwFMJVm8C5rr7hcA3gGeT7cfd17l7lbtXlZeXZzosERGJysaM/jpgk7sf7L/C3U+4e0v09XNAnpmVZeGYIiKSomwE+jtJctnGzCrNzKKvl0ePdyQLxxQRkRRlVDPWzIqA94H57n482vaXAO7+LTP7LPBXQDfQBnzB3X831H7HXc1YiNSNbdgClUv6ti+5LeVs2US1Zj/1+nVUtpTSUNw06LalhdMoL4xc0ipaVt6bSZuK9Q+upXHPbsrnnc2UJS+RP6WFKSWRqlbvvjuNd3fOpLKykiVLllBVNfB++lte38Hmwy1UNHWR09MBoRATvJ0PbvodH3zlVXYtvbxPtuxoUVauyCmD1YzNKGHK3VuBaf3avhX3+hHgkUyOMW7EsmPjNUSLaacY6GPZsfHeqNg15Hat3a3QBuWF5XTVt9AKwwr0Cy9f2fv68NtFlC0ASqClZRvTp8/mZMvFNDQ0ACQM9LdWlNB6rJOTuV24h+ixPHaVFBBaupQ7XtjAxO2vjnqg31Z/AkCBXiQFyoxNVVXNwIBee/2wdpFOrVk4VW+2dtUnOfTtN4a9/dKrV7H06lVAZHZ/fAusujWSJQtQU1NDbW1t0u3XzCxjzcxTX63E6sxOumARpUsvoBR6s2VHi7JyRVKnZ92IiAScAr2ISMAp0IuIBJwCvYhIwCnQi4gEnAK9iEjAKdCLiASc7qPPVMOWgffTDyNbNlWxerMf5Xy66lvSup8e4IKOS+lqb2frPzzLyUsO0128n5d/dC2lU07SQ5hnn1mXcLumQ/M43HAuAF0dPZyc91Hea+xi9apPAg5P/hyzEBfs2cnFO0+VKiyclM/EqflAJHErdj9/NmSjvm6qlIUrpzPN6DOx5LaBj0Ro2JJx2cH+4uvNFi0rJ29Gcdr7Kpo8lbyCAgAKGy4it2UWOZ5Doecn/WMoLD5K6fQ9vcuhHOPcQ/soaz4GIYs0hp2GklLenHdOb7+ujh7amjsBaNyzm7f+30tpj7u/bNXXTYVq48rpTjP6TGQhWzYV8fVmi1fMGNbjDwZ3M0Dvvw6m37c0Ya+Nm+6CMrj51q/0ttXW1sKJ/dTU1LB3zd0AfP4L/x2ml/KZOyJPvdjw8CYAbrn/YtY/uDZLY47IXn3doSkLV053mtGLiAScAr2ISMAp0IuIBJwCvYhIwGWjZuweM9tiZpvNbEC1EIv4P2a208zeMLOLMz2miIikLlt33Vzp7oeTrLsOODf6swL4ZvS3iIiMgtG4vfIm4HseqVn4iplNNbMZ7l4/CsceG/FJVFlMntretL23CEm86vnVaRU0iTdYElbXrBbaJuzmlZ99oretvOQ4XeFufvbsd/Cbe2iu/wAHdr9PQ/EkVjzzKwrDueTPLQBCfPPp1/BFkW0fe/q1hMe4an8HN9b3cLS4kMbCvD7rzlteweIrZmX0/jL16u4mnnj1PSVNyWkpG9foHXjBzDaa2b0J1s8iUlc2Zl+0rQ8zu9fM6sysrrGxMQvDGiPxSVRZTJ6qnl/dp9ZszPam7b332KdrqCSsqc0fobDj7D5thaEJ5IUi84QJk44waca7LGmop7KlmW4L0xbqJuRhIDzk8d+dnMuvZk5gYtgo7ejus+7wvhbeee3g8N9UFt20LPLnqqQpOV1lY0Z/ubsfMLPpwItm9ra7vxy33hJsM6AiubuvA9ZBpDh4FsY1NuKTqLKYPJWsDGGiGf5wDZWENZ2lwN8kXR9LqHr0T/4UoLcsYU3NqbHFEqZuf+ChAdvf8voOOg6/TU5XK2UfWMiiuMStWNLVWLprxRwFeTmtZTyjd/cD0d+HgA3A8n5d9gGz45bPAg5kelwREUlNRoHezCaa2aTYa+Ba4M1+3X4C3B29++ZS4Higr8+LiIwzmV66qQA2mFlsX0+4+/Nm9pcA7v4t4DmgGtgJtALZfayjiIgMKqNA7+67gAsTtH8r7rUDn8nkOCIikj5lxoqIBJwCvYhIwCnQi4gEnAqPjLREpQazyQ6ynU5qnroOJlUO2T0bWbSJHDv2Kvv3P8msWXcCsHfvXurq6qiqqurt07hn94ACJAsvXwnTPsA7peXcd2kX5HTAU7/rXd89N5dYdm1XOExnuAeACd5OgbcOGEfOtGnkTi8fdKy3VpSwZmbZsN/jaJYuzITKHkp/mtGPpESlBrOs2idyfmcXnBw6mzgbWbSJVFbcCEDDwZ8CsGRJ5D1v2bKlt8/Cy1dSPq9vdm2svOCtFSUstDDQCd7Vp08suzaHEHmhyJ9rj+XRYQUDxhFubaXnyJFBx7q1pY1nDh4d1vuD0S1dmAmVPZRENKMfSYlKDWbZamB17fWRXONVtYP2zUYWbSKzZt3ZG+QBqqqq+gR5gKVXrxpQGDw2u18zs2zIGfapcofLo9myudxy/419+sRKGs6963tJ93PL6zsGfzNJjGbpwkycDv/ikNGnGb2ISMAp0IuIBJwCvYhIwCnQi4gEnAK9iEjAKdCLiAScAr2ISMBZ5OGS40tVVZXX1dWN9TBOH7XXRzJwh0jOqolm0Z5PftaHcM30ZkrywxxlEgB5J/MJhY1wKPnfV6jbMXc88phrLNwF3p2wb6mVk2v5dOZ20dkdorMnRE9u3+Sq/I5wn/0l8j9LP8N7ebOY0xVJKlrRtomPtg2897xl9yJadlw0+JtOYFLrZqac7FsX961LyvjjhyqGva907N+3gPp9y7Ka3KVM29ODmW1096pE65QwFQRLbkupW7VPTFzYMQt2n3CYHCL2GRLO64GunEG38RAQjg7IQngoD+tJHOg7elohB/J78rFQD23WNaBPT46R0zP4OFe0nSpN+F5epBZs/0CfX3qQYhh2oO/Mn0Ez9An00/e3AodHJdBvb9pOyeQOFs34SNb2ua3+BIAC/WlOM3rJjtjzfGp+nt7mCerMxotl0V5ZeRcA0+PqyqYrliW74aJz+7Rv3BQ5xiUXPzGs/cXq295y/8W9bb3Zut9Pnq2bLbHM59ohMqSHI5Zpu/6+y7K2TxkZg83o075Gb2azzezXZvaWmW01s88l6LPSzI6b2eboz5fSPZ6IiKQnk0s33cD97r4pWjd2o5m96O7b+vX7jbvfkMFxREQkA2nP6N293t03RV83A28Bs7I1MBERyY6s3F5pZvOAi4BXE6y+zMz+aGb/YWaLB9nHvWZWZ2Z1jY1DP3JXRERSk3GgN7Ni4EfA5939RL/Vm4C57n4h8A3g2WT7cfd17l7l7lXl5YMXjhARkdRlFOjNLI9IkP+Buz/Tf727n3D3lujr54A8Mxt+aR8REUlbJnfdGPAY8Ja7fy1Jn8poP8xsefR4g5cAEhGRrEr7Pnoz+zDwG2ALEI42/wMwB8Ddv2VmnwX+isgdOm3AF9z9dwl214fuoz8NpZidC0QSvPpV3qqtraWhoYHKysR1bxv37qazvY2S/OmEyCVM4sSq4fjesktoKJ5EZUtzn/YJxUcI5XQR7smLtjiZZZs46WSqfbDjNa7o+O3gnSwHC0US08Iext2xQTKD3cKEQ+Gk6/sLuw/YpxlYiu+n4egc9h+Z37tcWlhKeWGwLs0uWbKkT23ksTIimbHu/luG+Ot190eAR9I9hpxGUszOpSFaYrBfoI/VmU2maPIUADq9k/ws5fhdcLAhYXt3V2G//zEMMgr1ww/y+3LOggkMGugdx7wHyIkexQY/lBtGiFPzsqFF/z1+ahce+dAa5LOk16TCYwC9gb61uxXaCFSgb2iI/A2Nh0A/GD0CQbIj1fq4sQza/ptXVcloUfYAAAZaSURBVI3L/1lO1arNPBN3OKqf+ClQyC13vZK0Tyxb+PYHHkppn7HM3dVxmbvDNZxM2Y2b7qIcWH1TZHw1z9fQTDMPrUptvKeDWEb3eKenV4qIBJwCvYhIwCnQi4gEnAK9iEjAKdCLiAScAr2ISMAp0IuIBJwqTMnoGk4G7Thw6L276OqYTt6EQwNXTiyHSYkzeQGKlpVTvGJGWsetfuKnvDN1GucdS/7EkHk7NrNg22tMscFLNsacCJXSTS65GWQV94RPxYuQMWgW7tzrN1NQ2kJ7UzEQS7YanpAVELKC4Q80C8xsyAzgA0dms//QfCZ0TRi03wRvo8DbyJk2jdxBHtqYSZbtiFSYEknLkttOmyAPUDR5a+Ig39kCJ5M/TrurvoXWzek/bvumifmDBvl3Sst565ylKQd5iASbTII8RIJ7THiIuH185/TeIA+pPzbhlB7C3j7MbbLD8SE/mHJLGpg+ffeQQb6HXDqskHBrKz1Hkv83bWhoYMuWLWmNdyia0YukY4gauSOdUZus3u1oGY1assPN/M2mVOrvplpbOJaRfPHmfwGS1w8eqm7yUDSjFxE5gynQi4gEnAK9iEjAKdCLiAScAr2ISMBlWjN2lZltN7OdZrY2wfoJZrY+uv5VM5uXyfFERGT4MqkZmwP8G3AdsAi408wW9ev2aeCou58DfB3453SPJyIi6clkRr8c2Onuu9y9E/ghcFO/PjcB342+fhr4mA2WSiciIlmXSSnBWcD7ccv7gBXJ+rh7t5kdB6YBh/vvzMzuBe4FmDNnTgbDEhkFQ2T35s+cOKKHv6C4cET3P5RFMyeP+DGmz50/dKcRsqB0wZB9JhUvTGlfZbMj2cETOgbfZ2Vl8sdpZCrtzFgzWw183N3/Irq8Blju7n8d12drtM++6PK70T7J84BRZqyIyHCNVGbsPmB23PJZwIFkfcwsF5gCNGVwTBERGaZMAv0fgHPN7GwzywfuAH7Sr89PgHuir28DfuXj8eE6IiIBlvY1+ug1988CvwBygMfdfauZfQWoc/efAI8B3zeznURm8ndkY9AiIpK6TL6Mxd2fA57r1/aluNftwOpMjiEiIplRZqyISMAp0IuIBJwCvYhIwCnQi4gE3LgsJWhmjcDeNDcvI0HmrQyg85QanafU6DwNbaTP0Vx3T1h5fFwG+kyYWV2y7DA5RecpNTpPqdF5GtpYniNduhERCTgFehGRgAtioF831gM4Teg8pUbnKTU6T0Mbs3MUuGv0IiLSVxBn9CIiEkeBXkQk4AIT6IcqVH4mM7PHzeyQmb0Z11ZqZi+a2Y7o75KxHONYM7PZZvZrM3vLzLaa2eei7TpPccyswMxeM7M/Rs/Tg9H2s83s1eh5Wh99dPkZz8xyzOx1M/tZdHlMzlMgAn2KhcrPZN8BVvVrWwv80t3PBX4ZXT6TdQP3u/tC4FLgM9G/IZ2nvjqAq9z9QmAZsMrMLgX+Gfh69DwdBT49hmMcTz4HvBW3PCbnKRCBntQKlZ+x3P1lBlb2ii/c/l3g5lEd1Djj7vXuvin6upnI/5yz0HnqwyNaoot50R8HrgKejraf8ecJwMzOAq4HHo0uG2N0noIS6BMVKp81RmM5XVS4ez1EghwwfYzHM26Y2TzgIuBVdJ4GiF6O2AwcAl4E3gWOuXt3tIv+/4v4F+DvgHB0eRpjdJ6CEugtQZvuG5VhM7Ni4EfA5939xFiPZzxy9x53X0akTvRyYGGibqM7qvHFzG4ADrn7xvjmBF1H5TxlVGFqHEmlULn0ddDMZrh7vZnNIDI7O6OZWR6RIP8Dd38m2qzzlIS7HzOzl4h8pzHVzHKjs1X9/weXA58ws2qgAJhMZIY/JucpKDP6VAqVS1/xhdvvAX48hmMZc9Hrp48Bb7n71+JW6TzFMbNyM5safV0IXE3k+4xfA7dFu53x58nd/97dz3L3eUTi0a/c/U8Zo/MUmMzY6Cfnv3CqUPk/jvGQxg0zexJYSeQxqQeBB4BngX8H5gDvAavdvf8XtmcMM/sw8BtgC6euqf4Dkev0Ok9RZraUyJeIOUQmiv/u7l8xs/lEboIoBV4H/szdO8ZupOOHma0E/sbdbxir8xSYQC8iIokF5dKNiIgkoUAvIhJwCvQiIgGnQC8iEnAK9CIiAadALyIScAr0IiIB9/8BWCUCR/PXFfoAAAAASUVORK5CYII=\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.step(times, values)\n", + "plt.xlabel('time')\n", + "plt.ylabel('A (concentration)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007):\n", + "$$n_0exp[-kt]$$" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -40,27 +111,21 @@ } ], "source": [ - "k = 0.1\n", - "\n", "for i in range(10):\n", - " A = 20\n", - " t = 0\n", - " tao_vals = []\n", - " mol_conc = [A]\n", - " time = [t]\n", - " \n", - " while A > 0:\n", - " r = np.random.uniform(0,1)\n", - " tao = (1/(A*k))*np.log(1/r)\n", - " tao_vals.append(tao)\n", - " t += tao\n", - " time.append(t)\n", - " A = A-1\n", - " mol_conc.append(A)\n", - " \n", - " plt.step(time, mol_conc, where='post') \n", + " values = model.simulate(k, times)\n", + " plt.step(times, values)\n", + "\n", + "y_vals = []\n", + "for i in times:\n", + " y = n_0*math.exp(-k*i)\n", + " y_vals.append(y)\n", " \n", - "plt.show()\n" + "plt.plot(times, y_vals, label = 'stochastic mean of A(t)')\n", + "plt.title('stochastic degradation across different iterations')\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", + "plt.legend(loc = 'upper right')\n", + "plt.show()" ] }, { From aae50044f5c1011f53751cd7859e13c79d15dee0 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 31 Jul 2019 17:31:39 +0100 Subject: [PATCH 14/56] updated PINTS stochastic degradation toy model --- pints/toy/_stochastic_degradation_model.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index f68d4f0c0..63d61677f 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -9,6 +9,8 @@ from __future__ import absolute_import, division from __future__ import print_function, unicode_literals import numpy as np +import scipy +from scipy.interpolate import interp1d import pints from . import ToyModel @@ -48,13 +50,13 @@ def simulate(self, parameters, times): if parameters <= 0: raise ValueError('rate constant must be positive') - k = [float(parameters)] + k = np.array([float(parameters)]) times = np.asarray(times) if np.any(times < 0): raise ValueError('Negative times are not allowed.') if self._n0 == 0: return np.zeros(times.shape) - a = self._n0 + a = np.array([float(self._n0)]) t = 0 mol_conc = [a] @@ -64,11 +66,11 @@ def simulate(self, parameters, times): # reaction and decreasing concentration by 1 at that time while a > 0: r = np.random.uniform(0, 1) - tao = (1 / (a * k)) * np.log(1 / r) + tao = ((1 / (a * k)) * np.log(1 / r))[0] t += tao time.append(t) a = a - 1 - mol_conc.append(a) + mol_conc.append(a[0]) # Interpolate as step function, decreasing mol_conc by 1 at each # reaction time point From 082d182637b9a413c3ba30e6deed545882492bd0 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 1 Aug 2019 12:29:43 +0100 Subject: [PATCH 15/56] updated stochastic degradation example notebook --- .../toy-model-stochastic-degradation.ipynb | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index b619068c7..16bd4fefb 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -4,17 +4,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Stochastic Degradation Model\n", + "# Stochastic degradation model\n", "\n", - "This example shows how the Stochastic Degradation Model can be used.\n", + "This example shows how the stochastic degradation model can be used.\n", "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n", - "The substance degrades starting from an initial concentration, n_0, to 0 following a rate constant, k:\n", + "The substance degrades starting from an initial concentration, n_0, to 0 following a rate constant, k, according to the following model (Erban et al., 2007):\n", " $$A \\xrightarrow{\\text{k}} \\emptyset$$\n", - " \n", - "The time until the next single reaction occurs is modelled as follows:\n", + "\n", + "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)\n", + " 1. Sample a random value r from a uniform distribution: r ~ unif(0,1)\n", + " 2. Calculate the time ($\\tau$) until the next single reaction as follows (Erban et al., 2007):\n", " $$ \\tau = \\frac{1}{A(t)k} \\ln{\\big[\\frac{1}{r}\\big]} $$\n", - " \n", - "(adapted from Erban et al., 2007)" + " 3. Update the molecule count at time t + $\\tau$ as: $ A(t + \\tau) = A(t) - 1 $\n", + " 4. Return to step (1) until molecule count reaches 0\n", + " " ] }, { @@ -89,7 +92,7 @@ "metadata": {}, "source": [ "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007):\n", - "$$n_0exp[-kt]$$" + "$$n_0exp[-kt]$$\n" ] }, { From 1804d723246aaa9487974330bf2e75c810b68d01 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 1 Aug 2019 17:03:19 +0100 Subject: [PATCH 16/56] updated stochastic degradation example notebook --- .../toy-model-stochastic-degradation.ipynb | 58 +++++++++++++++---- 1 file changed, 48 insertions(+), 10 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index 16bd4fefb..a081c91ec 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -69,7 +69,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAZRUlEQVR4nO3df7RdZX3n8ffHAI6iFjBXCoEYdBgqZUlk7gCK4wAqhQw1TouFYBV/plq0YnWm2JkR0TrL1oodRcEUImgV8QcotsiPoVjUKouAiOGHhSJKTEqiaILiL+Q7f5x95XDZN/fk5p5zknPfr7XOOns/+9lnf/facL/Z+3me/aSqkCRpskcNOwBJ0rbJBCFJamWCkCS1MkFIklqZICRJrXYYdgCzaf78+bVo0aJhhyFJ243rr7/++1U11rZtpBLEokWLWLVq1bDDkKTtRpLvTLXNR0ySpFYmCElSKxOEJKmVCUKS1MoEIUlq1bcEkWTvJFcnuTXJzUne0JTvluTKJLc337tOsf9JTZ3bk5zUrzglSe36eQfxAPCmqnoacChwcpL9gVOBq6pqX+CqZv1hkuwGnAYcAhwMnDZVIpEk9UffEkRVrauqG5rl+4BbgQXAUuD8ptr5wAtbdv8d4MqqureqfghcCRzdr1hP//zNnP75m/v185K0XRrIQLkki4BnANcCu1fVOugkkSRPatllAXB31/qapqztt5cDywEWLlw4o/huWbtpRvtJ0ijreyN1kscBnwFOqape/xKnpax1ZqOqWlFV41U1PjbWOlpckjQDfU0QSXakkxw+VlUXNcX3JNmj2b4HsL5l1zXA3l3rewFr+xmrJOnh+tmLKcC5wK1VdUbXpkuAiV5JJwGfa9n9cuCoJLs2jdNHNWWSpAHp5x3EYcBLgCOT3Nh8lgDvAp6f5Hbg+c06ScaTnANQVfcC7wCuaz5vb8okSQPSt0bqqvoy7W0JAM9tqb8KeFXX+kpgZX+ikyRNx5HUkqRWJghJUisThCSp1UjNKLc1blm3ieM/9FUAli5ewImHzGzQnSSNChMEnYQw4ZZ1nbF8JghJc50Jgk4ymEgIE3cRkjTX2QYhSWplgpAktTJBSJJamSAkSa1MEJKkViYISVIrE4QkqZXjIFo4qlqSTBCP4KhqSeowQUziqGpJ6uhbgkiyEjgWWF9VBzRlFwL7NVV2AX5UVYtb9r0LuA/4FfBAVY33K05JUrt+3kGcB5wJfGSioKqOn1hO8h5g42b2P6Kqvt+36CRJm9XPKUevSbKobVuSAH8AHNmv40uSts6wurn+Z+Ceqrp9iu0FXJHk+iTLN/dDSZYnWZVk1YYNG2Y9UEmaq4aVIJYBF2xm+2FVdRBwDHBykudMVbGqVlTVeFWNj42NzXackjRnDTxBJNkB+D3gwqnqVNXa5ns9cDFw8GCikyRNGMYdxPOA26pqTdvGJDsnefzEMnAUsHqA8UmS6G831wuAw4H5SdYAp1XVucAJTHq8lGRP4JyqWgLsDlzcacdmB+DjVXVZv+KcTveo6m6OsJY06vrZi2nZFOUvaylbCyxplu8EDuxXXFuie1R1N0dYS5oLHEm9Gd2jqrs5wlrSXODbXCVJrUwQkqRWJghJUisThCSplQlCktTKBCFJamWCkCS1MkFIklqZICRJrUwQkqRWJghJUisThCSplQlCktTKBCFJamWCkCS16luCSLIyyfokq7vK3pbke0lubD5Lptj36CTfSnJHklP7FaMkaWr9vIM4Dzi6pfy9VbW4+Vw6eWOSecAHgGOA/YFlSfbvY5ySpBZ9SxBVdQ1w7wx2PRi4o6rurKpfAJ8Als5qcJKkaQ2jDeJ1SW5qHkHt2rJ9AXB31/qapqxVkuVJViVZtWHDhtmOVZLmrEEniLOApwKLgXXAe1rqpKWspvrBqlpRVeNVNT42NjY7UUqSBpsgquqeqvpVVT0I/C2dx0mTrQH27lrfC1g7iPgkSQ8ZaIJIskfX6n8DVrdUuw7YN8k+SXYCTgAuGUR8kqSH7NCvH05yAXA4MD/JGuA04PAki+k8MroL+KOm7p7AOVW1pKoeSPI64HJgHrCyqm7uV5ySpHZ9SxBVtayl+Nwp6q4FlnStXwo8ogusJGlwHEktSWq1RQkiyc7NQDZJ0ojbbIJI8qgkJyb5hyTrgduAdUluTvLuJPsOJkxJ0qBN1wZxNfD/gLcAq5vuqSTZDTgCeFeSi6vq7/ob5rbnlnWbOP5DXwVg6eIFnHjIwiFHJEmza7oE8byq+uXkwqq6F/gM8JkkO/Ylsm3Y0sUPDey+Zd0mABOEpJGz2QTRnRyatofdu/epqu+2JZBRd+IhC3+dECbuIiRp1PTUzTXJ6+mMY7gHeLApLuDpfYpLkjRkvY6DeAOwX1X9oJ/BSJK2Hb12c70b2NjPQCRJ25Ze7yDuBL6Y5B+An08UVtUZfYlKkjR0vSaI7zafnZqPJGnE9ZQgqup0gCSP76zWj/salSRp6HrtxXQA8FFgt2b9+8BLfctqR/eguW4OoJO0Pev1EdMK4E+r6mqAJIfTmfDnWX2Ka7vRPWiumwPoJG3vek0QO08kB4Cq+mKSnfsU03ale9BcNwfQSdre9drN9c4k/zvJoubzv4Bvb26HJCuTrE+yuqvs3UluS3JTkouT7DLFvncl+WaSG5Os6v10JEmzpdcE8QpgDLgIuLhZfvk0+5wHHD2p7ErggKp6OvAvdF4COJUjqmpxVY33GKMkaRb12ovph8CfbMkPV9U1SRZNKruia/VrwHFb8puSpMHZbIJI8jdVdUqSz9N599LDVNULtuLYrwAunGJbAVckKeBDVbViMzEuB5YDLFxog7AkzZbp7iA+2nz/9WweNMn/BB4APjZFlcOqam2SJwFXJrmtqq5pq9gkjxUA4+Pjj0hikqSZ2WwbRFVd3ywurqp/6v4Ai2dywCQnAccCL66q1j/oVbW2+V5Pp83j4JkcS5I0c702Up/UUvayLT1YkqOBPwNeUFX3T1Fn52bENk1X2qOA1W11JUn9M10bxDLgRGCfJJd0bXo8sNlXfye5ADgcmJ9kDZ35JN4CPJrOYyOAr1XVa5LsCZxTVUvoTEp0cbN9B+DjVXXZDM5NkrQVpmuD+GdgHTAfeE9X+X3ATZvbsaqWtRSfO0XdtcCSZvlO4MBp4pIk9dl0U45+B/gO8MzBhCNJ2lb01AaR5NAk1yX5cZJfJPlVkk39Dk6SNDy9NlKfCSwDbgceA7wKeH+/gpIkDV+vL+ujqu5IMq+qfgV8OMk/9zEuSdKQ9Zog7k+yE3Bjkr+i03Dt21wlaYT1+ojpJU3d1wE/AfYGfr9fQUmShm/aO4gk84B3VtUfAj8DTu97VJKkoZv2DqJpcxhrHjFJkuaIXtsg7gK+0oym/slEYVWd0Y+gRoVzVUvanvWaINY2n0fRec0GtLz+Ww9xrmpJ27teE8QtVfWp7oIkL+pDPCPDuaolbe967cXUNjXo5qYLlSRt56Z7m+sxdF6ityDJ+7o2PYHOhD+SpBE13SOmtcAq4AXA9V3l9wFv7FdQkqThm+5trt8AvpHk41X1ywHFJEnaBvTaSH1wkrcBT272CVBV9ZR+BSZJGq5eG6nPBc4Ang38J2C8+d6sJCuTrE+yuqtstyRXJrm9+d51in1Paurc3sxjLUkaoF4TxMaq+kJVra+qH0x8etjvPODoSWWnAldV1b7AVc36wyTZjc4UpYcABwOnTZVIJEn90WuCuDrJu5M8M8lBE5/pdqqqa4B7JxUvBc5vls8HXtiy6+8AV1bVvVX1Q+BKHploJEl91GsbxCHN93hXWQFHzuCYu1fVOoCqWpfkSS11FgB3d62vacoeIclyYDnAwoWOTpak2dJTgqiqI/odyCRpC6OtYlWtAFYAjI+P+/oPSZolvc5JvXuSc5N8oVnfP8krZ3jMe5Ls0fzOHsD6ljpr6Mw5MWEvOmMyJEkD0msbxHnA5cCezfq/AKfM8JiXABO9kk4CPtdS53LgqCS7No3TRzVlkqQB6TVBzK+qTwIPAlTVA8CvptspyQXAV4H9kqxp7jreBTw/ye3A85t1kownOaf5/XuBdwDXNZ+3N2WSpAHptZH6J0meSNMOkORQYON0O1XVsik2Pbel7irgVV3rK4GVPcYnSZplvSaIP6XzaOipSb4CjAHH9S0qSdLQ9dqL6YYk/wXYj04Po2/5biZJGm299mI6GXhcVd1cVauBxyX54/6GJkkapl4bqV9dVT+aWGlGN7+6PyFJkrYFvSaIRyX59eC1JPOAnfoTkiRpW9BrI/XlwCeTnE2nJ9NrgMv6FpUkaeh6TRB/BvwR8Fo6jdRXAOf0KyhJ0vD12ovpQeCs5iNJmgN6ShBJDgPehjPKSdKc0esjpnOBNwLX08MrNiRJ279eE8TGqvpCXyORJG1Tek0QVyd5N3AR8POJwqq6oS9RSZKGbhgzykmStgPb6oxyI+2WdZs4/kNfnbbe0sULOPEQp1GVNBy99mL6DeA04DlN0T/RmaNh2ld+6+GWLm6dWvsRblm3CcAEIWloen3EtBJYDfxBs/4S4MPA7/UjqFF24iELe/qj38sdhiT1U6/vYnpqVZ1WVXc2n9OBGY2BSLJfkhu7PpuSnDKpzuFJNnbVeetMjiVJmrle7yB+muTZVfVl+PXAuZ/O5IBV9S1gcfM784DvARe3VP1SVR07k2NIkrZerwnitcD5TVsEwA+Bl83C8Z8L/GtVfWcWfkuSNIt67cV0I3Bgkic065tm6fgnABdMse2ZSb4BrAXeXFU3t1VKshxYDrBwoQ26kjRbep1R7v8k2aWqNlXVpiS7JvmLrTlwkp2AFwCfatl8A/DkqjoQeD/w2al+p6pWVNV4VY2PjY1tTUiSpC69NlIf0zKj3JKtPPYxwA1Vdc/kDU0i+nGzfCmwY5L5W3k8SdIW6DVBzEvy6ImVJI8BHr2Z+r1YxhSPl5L85sQMdkkObuL8wVYeT5K0BXptpP474KokH6bzio1XAOfP9KBJHgs8n84kRBNlrwGoqrOB44DXJnmATm+pE6qqZnq87VWvI663hKOzJfWq10bqv0pyE/A8OnNBvKOqLp/pQavqfuCJk8rO7lo+Ezhzpr8/Cnodcb0lHJ0taUtsNkEkycS/3KvqMlrmoe6uo9nT64jrLeHobElbYro2iKuTvD7Jw/5SJdkpyZFJzgdO6l94kqRhme4R09F02hsuSLIP8CPgMXQSyxXAe5sxEpKkEbPZBFFVPwM+CHwwyY7AfOCn3V1eJUmjqddeTFTVL4F1fYxFkrQN6XUchCRpjjFBSJJazShBJDksyQdmOxhJ0raj5zaIJIuBE+nMKvdt4KJ+BaX+mcnobEdfS3PTdAPl/gOdV3Ivo/MupAuBVNURA4hNs2wmo7MdfS3NXdPdQdwGfAn43aq6AyDJG/selfpiJqOzHX0tzV3TtUH8PvBvdEZU/22S59J5F5MkacRtNkFU1cVVdTzwW8AXgTcCuyc5K8lRA4hPkjQkPfViqqqfVNXHqupYYC/gRuDUvkYmSRqqLe7mWlX3VtWHqurIfgQkSdo2DG2gXJK7knwzyY1JVrVsT5L3JbkjyU1JDhpGnJI0V/U8DqJPjqiq70+x7Rhg3+ZzCHBW8y1JGoBt+VUbS4GPVMfXgF2S7DHsoCRprhhmgijgiiTXJ1nesn0BcHfX+pqm7GGSLE+yKsmqDRs29ClUSZp7hpkgDquqg+g8Sjo5yXMmbW8bb/GIqU2rakVVjVfV+NjYWD/ilKQ5aWgJoqrWNt/rgYuBgydVWQPs3bW+F7B2MNFJkoaSIJLsnOTxE8vAUcDqSdUuAV7a9GY6FNhYVU5YJEkDMqxeTLsDFyeZiOHjVXVZktcAVNXZwKXAEuAO4H7g5UOKVZLmpKEkiKq6EziwpfzsruUCTh5kXJKkh2zL3VwlSUNkgpAktTJBSJJaDftVG9oO9DJNqdOSSqPHBKHN6mWaUqcllUaTCUKb1cs0pU5LKo0m2yAkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktTJBSJJamSAkSa1MEJKkVgNPEEn2TnJ1kluT3JzkDS11Dk+yMcmNzeetg45Tkua6YbyL6QHgTVV1QzMv9fVJrqyqWybV+1JVHTuE+CRJDOEOoqrWVdUNzfJ9wK3A9K8MlSQN1FDbIJIsAp4BXNuy+ZlJvpHkC0l+ezO/sTzJqiSrNmzY0KdIJWnuGVqCSPI44DPAKVW1adLmG4AnV9WBwPuBz071O1W1oqrGq2p8bGysfwFL0hwzlASRZEc6yeFjVXXR5O1VtamqftwsXwrsmGT+gMOUpDltGL2YApwL3FpVZ0xR5zebeiQ5mE6cPxhclJKkYfRiOgx4CfDNJDc2ZX8OLASoqrOB44DXJnkA+ClwQlXVEGJVj3qZt3oqzmctbZsGniCq6stApqlzJnDmYCLS1upl3uqpOJ+1tO1yTmpttV7mrZ6K81lL2y5ftSFJamWCkCS1MkFIklqZICRJrUwQkqRWJghJUisThCSpleMgNHRbMwp71DnKXMNkgtBQbc0o7FHnKHMNmwlCQ7U1o7BHnXdVGjbbICRJrUwQkqRWJghJUisThCSplQlCktRqWHNSH53kW0nuSHJqy/ZHJ7mw2X5tkkWDj1KS5rZhzEk9D/gAcAywP7Asyf6Tqr0S+GFV/XvgvcBfDjZKSdIwxkEcDNxRVXcCJPkEsBS4pavOUuBtzfKngTOTxHmpNdc4yly92H/PJ3Da7/72rP/uMBLEAuDurvU1wCFT1amqB5JsBJ4IfH/yjyVZDiwHWLjQAVcaHY4y17ANI0GkpWzynUEvdTqFVSuAFQDj4+PeYWhkOMpcwzaMRuo1wN5d63sBa6eqk2QH4DeAewcSnSQJGE6CuA7YN8k+SXYCTgAumVTnEuCkZvk44B9tf5CkwRr4I6amTeF1wOXAPGBlVd2c5O3Aqqq6BDgX+GiSO+jcOZww6Dglaa4byttcq+pS4NJJZW/tWv4Z8KJBxyVJeogjqSVJrUwQkqRWJghJUisThCSpVUap92iSDcB3Zrj7fFpGao84z3n0zbXzBc95Sz25qsbaNoxUgtgaSVZV1fiw4xgkz3n0zbXzBc95NvmISZLUygQhSWplgnjIimEHMASe8+iba+cLnvOssQ1CktTKOwhJUisThCSp1ZxPEEmOTvKtJHckOXXY8fRDkr2TXJ3k1iQ3J3lDU75bkiuT3N587zrsWGdbknlJvp7k75v1fZJc25zzhc0r50dGkl2SfDrJbc31fuaoX+ckb2z+u16d5IIk/27UrnOSlUnWJ1ndVdZ6XdPxvuZv2k1JDprpced0gkgyD/gAcAywP7Asyf7DjaovHgDeVFVPAw4FTm7O81TgqqraF7iqWR81bwBu7Vr/S+C9zTn/EHjlUKLqn/8LXFZVvwUcSOfcR/Y6J1kA/AkwXlUH0JlC4ARG7zqfBxw9qWyq63oMsG/zWQ6cNdODzukEARwM3FFVd1bVL4BPAEuHHNOsq6p1VXVDs3wfnT8aC+ic6/lNtfOBFw4nwv5IshfwX4FzmvUARwKfbqqM1DkneQLwHDrzqVBVv6iqHzHi15nOtAWPaWaffCywjhG7zlV1DY+cVXOq67oU+Eh1fA3YJckeMznuXE8QC4C7u9bXNGUjK8ki4BnAtcDuVbUOOkkEeNLwIuuLvwH+B/Bgs/5E4EdV9UCzPmrX+ynABuDDzWO1c5LszAhf56r6HvDXwHfpJIaNwPWM9nWeMNV1nbW/a3M9QaSlbGT7/SZ5HPAZ4JSq2jTsePopybHA+qq6vru4peooXe8dgIOAs6rqGcBPGKHHSW2a5+5LgX2APYGd6TximWyUrvN0Zu2/87meINYAe3et7wWsHVIsfZVkRzrJ4WNVdVFTfM/ErWfzvX5Y8fXBYcALktxF59HhkXTuKHZpHkXA6F3vNcCaqrq2Wf80nYQxytf5ecC3q2pDVf0SuAh4FqN9nSdMdV1n7e/aXE8Q1wH7Nj0edqLTuHXJkGOadc2z93OBW6vqjK5NlwAnNcsnAZ8bdGz9UlVvqaq9qmoRnev6j1X1YuBq4Lim2qid878BdyfZryl6LnALI3yd6TxaOjTJY5v/zifOeWSvc5epruslwEub3kyHAhsnHkVtqTk/kjrJEjr/spwHrKyqdw45pFmX5NnAl4Bv8tDz+D+n0w7xSWAhnf/RXlRVkxvCtntJDgfeXFXHJnkKnTuK3YCvA39YVT8fZnyzKcliOo3yOwF3Ai+n8w/Bkb3OSU4HjqfTW+/rwKvoPHMfmeuc5ALgcDqv9b4HOA34LC3XtUmUZ9Lp9XQ/8PKqWjWj4871BCFJajfXHzFJkqZggpAktTJBSJJamSAkSa1MEJKkViYIaYaaN6f+cbO8Z5JPT7ePtD2xm6s0Q817rf6+eYuoNHJ2mL6KpCm8C3hqkhuB24GnVdUBSV5G582a84ADgPfQGbj2EuDnwJJmQNNT6bxufozOgKZXV9Vtgz8NqZ2PmKSZOxX416paDPz3SdsOAE6k80r5dwL3Ny/Q+yrw0qbOCuD1VfUfgTcDHxxI1FKPvIOQ+uPqZu6N+5JsBD7flH8TeHrzZt1nAZ/qvBkBgEcPPkxpaiYIqT+63/vzYNf6g3T+v3sUnTkLFg86MKlXPmKSZu4+4PEz2bGZj+PbSV4Ev55H+MDZDE7aWiYIaYaq6gfAV5qJ5N89g594MfDKJN8AbmYEp7vV9s1urpKkVt5BSJJamSAkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWr1/wHDvfk0ooCSRQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -97,12 +97,12 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -118,12 +118,9 @@ " values = model.simulate(k, times)\n", " plt.step(times, values)\n", "\n", - "y_vals = []\n", - "for i in times:\n", - " y = n_0*math.exp(-k*i)\n", - " y_vals.append(y)\n", + "mean = model.DeterministicMean(k, times)\n", " \n", - "plt.plot(times, y_vals, label = 'stochastic mean of A(t)')\n", + "plt.plot(times, mean, label = 'deterministic mean of A(t)')\n", "plt.title('stochastic degradation across different iterations')\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", @@ -133,7 +130,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Determine exact times of single reactions according to the Gillespie algorithm (shown above) and plot step function" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "[time, mol_count] = model.StochasticSimulationAlgorithm(0.1)\n", + "\n", + "plt.step(time, mol_count)\n", + "plt.xlabel('time')\n", + "plt.ylabel('Molecule count')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [], "source": [] From 39a7d4a190a60704c1a0a0b9bb79f500254c0c67 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 1 Aug 2019 17:09:12 +0100 Subject: [PATCH 17/56] updated stochastic degradation PINTS code --- pints/toy/_stochastic_decay_model.py | 69 ---------------------------- 1 file changed, 69 deletions(-) delete mode 100644 pints/toy/_stochastic_decay_model.py diff --git a/pints/toy/_stochastic_decay_model.py b/pints/toy/_stochastic_decay_model.py deleted file mode 100644 index a9b5737cb..000000000 --- a/pints/toy/_stochastic_decay_model.py +++ /dev/null @@ -1,69 +0,0 @@ -# -# Logistic toy model. -# -# This file is part of PINTS. -# Copyright (c) 2017-2019, University of Oxford. -# For licensing information, see the LICENSE file distributed with the PINTS -# software package. -# -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals -import numpy as np -import pints - -from . import ToyModel - - -class StochasticDegredationModel(pints.ForwardModel, ToyModel): - - """ - Stochastic decay model of a single chemical reaction [1]. - - .. math:: - - - Has one parameter: Rate constant :math:`k`. - The initial concentration :math:`A(0) = n_0` can be set using the - (optional) named constructor arg ``initial_concentration`` - - [1] Erban et al., 2007 - - *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. - """ - - def __init__(self, initial_concentration=20): - super(StochasticDegredationModel, self).__init__() - self._n0 = float(initial_concentration) - if self._n0 <= 0: - raise ValueError('Initial concentration must be positive.') - - def n_parameters(self): - """ See :meth:`pints.ForwardModel.n_parameters()`. """ - return 1 - - def simulate(self, parameter): - """ See :meth:`pints.ForwardModel.simulate()`. """ - if parameter <= 0: - raise ValueError('rate constant must be postive') - - A = self._n0 - k = float(parameter) - - t = 0 - mol_conc = [] - time = [] - - while A > 0: - r = np.random.uniform(0, 1) - tao = (1 / (A * k)) * np.log(1 / r) - t += tao - time.append(t) - A = A - 1 - mol_conc.append(A) - - return mol_conc, time - - def suggested_parameter(self): - """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - return 0.1 - From 4e4087f95cd1840a46457b9f9eb10164ce2cb0db Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 1 Aug 2019 17:12:34 +0100 Subject: [PATCH 18/56] updated stochastic degradation PINTS code --- pints/toy/_stochastic_degradation_model.py | 78 ++++++++++++++++------ 1 file changed, 56 insertions(+), 22 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 63d61677f..27af170be 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -1,5 +1,5 @@ # -# Logistic toy model. +# Stochastic degradation toy model. # # This file is part of PINTS. # Copyright (c) 2017-2019, University of Oxford. @@ -9,7 +9,6 @@ from __future__ import absolute_import, division from __future__ import print_function, unicode_literals import numpy as np -import scipy from scipy.interpolate import interp1d import pints @@ -19,11 +18,20 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): """ - Stochastic decay model of a single chemical reaction [1]. - - Time until next reaction... + Stochastic degradation model of a single chemical reaction starting from + an initial concentration n_0 and degrading to 0 according to the following + model: .. math:: - $\tau = \frac{1}{A(t)k}*\ln{\frac{1}{r}}$ + $A rightarrow{\text{k}} 0 $ [1] + + The model is simulated according to the Gillespie algorithm [2]: + 1. Sample a random value r from a uniform distribution: r ~ unif(0,1) + 2. Calculate the time ($\tau$) until the next single reaction as follows: + .. math:: + $\tau = \frac{1}{A(t)k}*ln{\frac{1}{r}}$ [1] + 3. Update the molecule count at time t + .. math:: $\tau$ as: + .. math:: $A(t + \tau) = A(t)-1$ + 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. :math:`r` is a random variable, which is part of the stochastic model @@ -31,6 +39,7 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): (optional) named constructor arg ``initial_concentration`` [1] Erban et al., 2007 + [2] Gillespie, 1976 *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. """ @@ -48,43 +57,68 @@ def n_parameters(self): def simulate(self, parameters, times): """ See :meth:`pints.ForwardModel.simulate()`. """ if parameters <= 0: - raise ValueError('rate constant must be positive') + raise ValueError('Rate constant must be positive.') - k = np.array([float(parameters)]) times = np.asarray(times) if np.any(times < 0): raise ValueError('Negative times are not allowed.') if self._n0 == 0: return np.zeros(times.shape) - a = np.array([float(self._n0)]) + [time, mol_count] = self.StochasticSimulationAlgorithm(parameters) + + # Interpolate as step function, decreasing mol_count by 1 at each + # reaction time point + f1 = interp1d(time, mol_count, kind='previous') + + # Compute concentration ('a') values at given time points using f1 + # at any time beyond the last reaction, concentration = 0 + values = f1(times[np.where(times <= max(time))]) + zero_vector = np.zeros(len(times[np.where(times > max(time))])) + values = np.concatenate((values, zero_vector)) + + return values + + def StochasticSimulationAlgorithm(self, parameters): t = 0 - mol_conc = [a] + if parameters <= 0: + raise ValueError('Rate constant must be positive.') + k = np.array([float(parameters)]) + + a = np.array([float(self._n0)]) + mol_count = [a[0]] time = [t] # Run stochastic degradation algorithm, calculating time until next # reaction and decreasing concentration by 1 at that time - while a > 0: + while a[0] > 0: r = np.random.uniform(0, 1) tao = ((1 / (a * k)) * np.log(1 / r))[0] t += tao time.append(t) - a = a - 1 - mol_conc.append(a[0]) + a[0] = a[0] - 1 + mol_count.append(a[0]) - # Interpolate as step function, decreasing mol_conc by 1 at each - # reaction time point - f1 = interp1d(time, mol_conc, kind='previous') + return time, mol_count - # Compute concentration ('a') values at given time points using f1 - # at any time beyond the last reaction, concentration = 0 - values = f1(times[np.where(times <= max(time))]) - zero_vector = np.zeros(len(times[np.where(times > max(time))])) - values = np.concatenate((values, zero_vector)) + def DeterministicMean(self, parameters, times): + if parameters <= 0: + raise ValueError('Rate constant must be positive.') + k = parameters - return values + times = np.asarray(times) + if np.any(times < 0): + raise ValueError('Negative times are not allowed.') + + mean = self._n0*np.exp(-k*times) + + return mean def suggested_parameter(self): """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ return 0.1 + def suggested_times(self): + """ See "meth:`pints.toy.ToyModel.suggested_times()`.""" + return np.linspace(0, 100, 101) + From 51efd2dde79256bf47026cd2ffd3c8e6c775555d Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 1 Aug 2019 17:15:48 +0100 Subject: [PATCH 19/56] stochastic degradation unit test, work in progress --- .../test_toy_stochastic_degradation_model.py | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 pints/tests/test_toy_stochastic_degradation_model.py diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py new file mode 100644 index 000000000..2783bb0ad --- /dev/null +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# +# Tests if the stochastic degradation (toy) model works. +# +# This file is part of PINTS. +# Copyright (c) 2017-2018, University of Oxford. +# For licensing information, see the LICENSE file distributed with the PINTS +# software package. +# +import unittest +import numpy as np +import pints +import pints.toy + + +class TestStochasticDegradation(unittest.TestCase): + """ + Tests if the stochastic degradation (toy) model works. + """ + + def test_start_with_zero(self): + # Test the special case where the initial concentration is zero + model = pints.toy.StochasticDegradationModel(0) + times = [0, 1, 2, 100, 1000] + parameters = 0.1 + values = model.simulate(parameters, times) + self.assertEqual(len(values), len(times)) + self.assertTrue(np.all(values == np.zeros(5))) + + def test_start_with_twenty(self): + # Run small simulation + model = pints.toy.StochasticDegradationModel(20) + times = [0, 1, 2, 100, 1000] + parameters = 0.1 + values = model.simulate(parameters, times) + self.assertEqual(len(values), len(times)) + self.assertEqual(values[0], 20) + self.assertEqual(values[-1], 0) + + def test_suggested(self): + model = pints.toy.StochasticDegradationModel(20) + times = model.suggested_times() + parameters = model.suggested_parameters() + self.assertTrue(np.all(times == np.linspace(0, 100, 101))) + self.assertEqual(parameters, 0.1) + values = model.simulate(parameters, times) + self.assertEqual(values[0], 20) + self.assertEqual(values[-1], 0) + + def test_errors(self): + model = pints.toy.StochasticDegradationModel(20) + times = np.linspace(0, 100, 101) + parameters = -0.1 + self.assertRaises(ValueError, model.simulate, parameters, times) + times_2 = np.linspace(-10, 10, 21) + parameters_2 = 0.1 + self.assertRaises(ValueError, model.simulate, parameters_2, times_2) + + # Initial value can't be negative + self.assertRaises(ValueError, pints.toy.StochasticDegradationModel, -1) + + +if __name__ == '__main__': + unittest.main() \ No newline at end of file From e86b97a99ea0c31cfef78fe95acb0ba5f2e4dbfe Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 13:59:52 +0100 Subject: [PATCH 20/56] updated unit test for stochastic degradation model --- .../test_toy_stochastic_degradation_model.py | 48 +++++++++++++++++-- 1 file changed, 45 insertions(+), 3 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 2783bb0ad..ac2200fb7 100644 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -3,7 +3,7 @@ # Tests if the stochastic degradation (toy) model works. # # This file is part of PINTS. -# Copyright (c) 2017-2018, University of Oxford. +# Copyright (c) 2017-2019, University of Oxford. # For licensing information, see the LICENSE file distributed with the PINTS # software package. # @@ -22,7 +22,7 @@ def test_start_with_zero(self): # Test the special case where the initial concentration is zero model = pints.toy.StochasticDegradationModel(0) times = [0, 1, 2, 100, 1000] - parameters = 0.1 + parameters = [0.1] values = model.simulate(parameters, times) self.assertEqual(len(values), len(times)) self.assertTrue(np.all(values == np.zeros(5))) @@ -31,7 +31,7 @@ def test_start_with_twenty(self): # Run small simulation model = pints.toy.StochasticDegradationModel(20) times = [0, 1, 2, 100, 1000] - parameters = 0.1 + parameters = [0.1] values = model.simulate(parameters, times) self.assertEqual(len(values), len(times)) self.assertEqual(values[0], 20) @@ -47,14 +47,56 @@ def test_suggested(self): self.assertEqual(values[0], 20) self.assertEqual(values[-1], 0) + def test_simulate_stochastically(self): + parameters = [0.1] + time, mol_count = model.simulate_stochastically(parameters) + self.assertTrue(np.all(mol_count == + np.array(range(20, -1, -1)))) + + def test_interpolate_function(self): + model = pints.toy.StochasticDegradationModel(20) + times = np.linspace(0, 100, 101) + parameters = [0.1] + + values = model.simulate(parameters, times) + # Check exact time points from stochastic simulation + self.assertTrue(np.all(model._interp_func(self._time) == + self._mol_count)) + + # Check simulate function returns expected values + self.assertTrue(np.all(values[np.where(times < self._time[1])] == 20)) + + # Check interpolation function works as expected + self.assertTrue(model._interp_func(np.random.uniform(self._time[0], + self._time[1])) == 20) + self.assertTrue(model._interp_func(np.random.uniform(self._time[1], + self._time[2])) == 19) + + def test_errors(self): model = pints.toy.StochasticDegradationModel(20) + # parameters, times cannot be negative times = np.linspace(0, 100, 101) parameters = -0.1 self.assertRaises(ValueError, model.simulate, parameters, times) + self.assertRaises(ValueError, model.deterministic_mean, parameters, + times) + self.assertRaises(ValueError, model.simulate_stochastically, + parameters) + times_2 = np.linspace(-10, 10, 21) parameters_2 = 0.1 self.assertRaises(ValueError, model.simulate, parameters_2, times_2) + self.assertRaises(ValueError, model.deterministic_mean, parameters_2, + times_2) + + # this model should have 1 parameter + parameters_3 = [0.1, 1] + self.assertRaises(ValueError, model.simulate, parameters_3, times) + self.assertRaises(ValueError, model.deterministic_mean, parameters_3, + times) + self.assertRaises(ValueError, model.simulate_stochastically, + parameters_3, times) # Initial value can't be negative self.assertRaises(ValueError, pints.toy.StochasticDegradationModel, -1) From ff66e607edd6102da44ebd3cc027f5be6281cda3 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 14:02:34 +0100 Subject: [PATCH 21/56] updated stochastic degradation PINTS code --- pints/toy/_stochastic_degradation_model.py | 69 +++++++++++++--------- 1 file changed, 42 insertions(+), 27 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 27af170be..cd8e3baba 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -19,13 +19,13 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): """ Stochastic degradation model of a single chemical reaction starting from - an initial concentration n_0 and degrading to 0 according to the following - model: + an initial concentration :math:: n0 and degrading to 0 according to the + following model: .. math:: $A rightarrow{\text{k}} 0 $ [1] The model is simulated according to the Gillespie algorithm [2]: - 1. Sample a random value r from a uniform distribution: r ~ unif(0,1) + 1. Sample a random value r from a uniform distribution: :math:: r ~ unif(0,1) 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: $\tau = \frac{1}{A(t)k}*ln{\frac{1}{r}}$ [1] @@ -50,13 +50,21 @@ def __init__(self, initial_concentration=20): if self._n0 < 0: raise ValueError('Initial concentration cannot be negative.') + self._interp_func = None + self._mol_count = [] + self._time = [] + def n_parameters(self): """ See :meth:`pints.ForwardModel.n_parameters()`. """ return 1 def simulate(self, parameters, times): """ See :meth:`pints.ForwardModel.simulate()`. """ - if parameters <= 0: + if len(parameters) != self.n_parameters(): + raise ValueError('This model should have only 1 parameter.') + k = parameters[0] + + if k <= 0: raise ValueError('Rate constant must be positive.') times = np.asarray(times) @@ -65,58 +73,65 @@ def simulate(self, parameters, times): if self._n0 == 0: return np.zeros(times.shape) - [time, mol_count] = self.StochasticSimulationAlgorithm(parameters) + time, mol_count = self.simulate_stochastically(parameters) # Interpolate as step function, decreasing mol_count by 1 at each # reaction time point - f1 = interp1d(time, mol_count, kind='previous') + self._interp_func = interp1d(time, mol_count, kind='previous') - # Compute concentration ('a') values at given time points using f1 + # Compute concentration values at given time points using f1 # at any time beyond the last reaction, concentration = 0 - values = f1(times[np.where(times <= max(time))]) + values = self._interp_func(times[np.where(times <= max(time))]) zero_vector = np.zeros(len(times[np.where(times > max(time))])) values = np.concatenate((values, zero_vector)) return values - def StochasticSimulationAlgorithm(self, parameters): + def simulate_stochastically(self, parameters): + """ Stochastic simulation according to Gillespie algorithm""" + if len(parameters) != self.n_parameters(): + raise ValueError('This model should have only 1 parameter.') + k = parameters[0] t = 0 - if parameters <= 0: + if k <= 0: raise ValueError('Rate constant must be positive.') - k = np.array([float(parameters)]) - a = np.array([float(self._n0)]) - mol_count = [a[0]] - time = [t] + a = self._n0 + self._mol_count = [a] + self._time = [t] # Run stochastic degradation algorithm, calculating time until next # reaction and decreasing concentration by 1 at that time - while a[0] > 0: + while a > 0: r = np.random.uniform(0, 1) - tao = ((1 / (a * k)) * np.log(1 / r))[0] - t += tao - time.append(t) - a[0] = a[0] - 1 - mol_count.append(a[0]) + t += (1 / (a * k)) * np.log(1 / r) + self._time.append(t) + a = a - 1 + self._mol_count.append(a) + + return self._time, self._mol_count - return time, mol_count + def deterministic_mean(self, parameters, times): + """ Calculates deterministic mean of infinitely many stochastic + simulations, which follows :math:: n0*exp(-kt)""" + if len(parameters) != self.n_parameters(): + raise ValueError('This model should have only 1 parameter.') + k = parameters[0] - def DeterministicMean(self, parameters, times): - if parameters <= 0: + if k <= 0: raise ValueError('Rate constant must be positive.') - k = parameters times = np.asarray(times) if np.any(times < 0): raise ValueError('Negative times are not allowed.') - mean = self._n0*np.exp(-k*times) + mean = self._n0 * np.exp(-k * times) return mean - def suggested_parameter(self): + def suggested_parameters(self): """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - return 0.1 + return np.array([0.1]) def suggested_times(self): """ See "meth:`pints.toy.ToyModel.suggested_times()`.""" From 26adf7ecdc5c4486747c63fce3bdd80581376fbe Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 14:51:59 +0100 Subject: [PATCH 22/56] updated stochastic degradation model example notebook --- .../toy-model-stochastic-degradation.ipynb | 40 ++++++------------- 1 file changed, 13 insertions(+), 27 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index a081c91ec..c6a7f6111 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -52,24 +52,24 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "times = np.linspace(0, 100, 100)\n", - "k = 0.1\n", + "k = [0.1]\n", "\n", "values = model.simulate(k, times)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 65, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAZaElEQVR4nO3dfbQlVXnn8e/PBhxFCSANQkPb6DBEwpLWuQMoxkFUAgyxMwkG8A1fOxo1YnRGzMyIaJxlYsSMomAHWtBRxBdQjMjLIhjUIEODDfJmIIjSdoduBbtRfEOe+ePUDYdL3b6nb99zzr3nfj9rnXWqdu069dQquE9X7dp7p6qQJGmiRw07AEnS7GSCkCS1MkFIklqZICRJrUwQkqRW2ww7gJm0yy671JIlS4YdhiTNGddee+2Pqmph27aRShBLlixh1apVww5DkuaMJN+fbJuPmCRJrUwQkqRWJghJUisThCSplQlCktSqbwkiyV5JrkhyS5Kbkry5Kd85yWVJbmu+d5pk/xOaOrclOaFfcUqS2vXzDuIB4K1V9VTgYOANSfYDTgIur6p9gMub9YdJsjNwMnAQcCBw8mSJRJLUH31LEFW1rqqua5bvA24BFgHLgHOaaucAf9Cy++8Bl1XVPVV1L3AZcES/Yj3lyzdxypdv6tfPS9KcNJCOckmWAE8HrgZ2q6p10EkiSXZt2WURcFfX+pqmrO23lwPLARYvXjyt+G5eu2la+0nSKOt7I3WSxwFfAE6sql7/EqelrHVmo6paUVVjVTW2cGFrb3FJ0jT0NUEk2ZZOcvhUVZ3fFN+dZPdm++7A+pZd1wB7da3vCaztZ6ySpIfr51tMAc4CbqmqU7s2XQiMv5V0AvCllt0vAQ5PslPTOH14UyZJGpB+3kEcArwMOCzJ6uZzFPA+4AVJbgNe0KyTZCzJmQBVdQ/wHuCa5vPupkySNCB9a6Suqm/Q3pYA8LyW+quA13StrwRW9ic6SdJU7EktSWplgpAktTJBSJJajdSMclvj5nWbOPZjVwGwbOkiXnzQ9DrdSdKoMEHQSQjjbl7X6ctngpA035kg6CSD8YQwfhchSfOdbRCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFYmCElSq74NtZFkJXA0sL6q9m/KzgP2barsCPykqpa27HsncB/wG+CBqhrrV5ySpHb9HIvpbOA04BPjBVV17Phykg8AGzez/3Or6kd9i06StFn9nHL0yiRL2rYlCfDHwGH9Or4kaesMqw3id4G7q+q2SbYXcGmSa5Ms39wPJVmeZFWSVRs2bJjxQCVpvhpWgjgeOHcz2w+pqmcARwJvSPKcySpW1YqqGquqsYULF850nJI0bw08QSTZBvhD4LzJ6lTV2uZ7PXABcOBgopMkjRvGHcTzgVurak3bxiTbJ3n8+DJwOHDjAOOTJNHHBJHkXOAqYN8ka5K8utl0HBMeLyXZI8lFzepuwDeSXA/8P+ArVXVxv+JsMz4/9bEfu4pPX/2DQR5akmaNfr7FdPwk5a9oKVsLHNUs3wEc0K+4puL81JLU4ZzUEzg/tSR1ONSGJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFb9nFFuZZL1SW7sKntXkh8mWd18jppk3yOSfDfJ7UlO6leMkqTJ9fMO4mzgiJbyD1bV0uZz0cSNSRYAHwGOBPYDjk+yXx/jlCS16OeUo1cmWTKNXQ8Ebm+mHiXJZ4BlwM0zF13vxuennmjZ0kVORSpppA2jDeKNSW5oHkHt1LJ9EXBX1/qapqxVkuVJViVZtWHDhhkNdNnSRey3+w6PKL953Sa+tPqHM3osSZptBj0n9enAe4Bqvj8AvGpCnbTsV5P9YFWtAFYAjI2NTVpvOrrnp+7mXNWS5oOB3kFU1d1V9ZuqehD4OzqPkyZaA+zVtb4nsHYQ8UmSHjLQBJFk967V/wrc2FLtGmCfJHsn2Q44DrhwEPFJkh7St0dMSc4FDgV2SbIGOBk4NMlSOo+M7gT+pKm7B3BmVR1VVQ8keSNwCbAAWFlVN/UrTklSu36+xXR8S/FZk9RdCxzVtX4R8IhXYCVJg2NPaklSqy1KEEm2bzqySZJG3GYTRJJHJXlxkq8kWQ/cCqxLclOS9yfZZzBhSpIGbao7iCuApwDvAJ5YVXtV1a7A7wLfAt6X5KV9jlGSNARTNVI/v6p+PbGwqu4BvgB8Icm2fYlMkjRUm00Q3cmhaXvYrXufqvpBWwKRJM19Pb3mmuRNdPox3A082BQX8LQ+xSVJGrJe+0G8Gdi3qn7cz2AkSbNHr6+53gVs7GcgkqTZpdc7iDuAryX5CvDL8cKqOrUvUUmShq7XBPGD5rNd85EkjbieEkRVnQKQ5PGd1fppX6OSJA1dr28x7Q98Eti5Wf8R8PL5PMqqU5FKGnW9PmJaAfx5VV0BkORQOhP+PKtPcc1qy5a2z4B687pNACYISSOh1wSx/XhyAKiqryXZvk8xzXpORSppPuj1Ndc7kvyvJEuaz/8Evre5HZKsTLI+yY1dZe9PcmuSG5JckGTHSfa9M8l3kqxOsqr305EkzZReE8SrgIXA+cAFzfIrp9jnbOCICWWXAftX1dOAf6YzCOBknltVS6tqrMcYJUkzqNe3mO4F/mxLfriqrkyyZELZpV2r3wKO2ZLflCQNzmYTRJK/raoTk3yZzthLD1NVL9yKY78KOG+SbQVcmqSAj1XVis3EuBxYDrB4sY3DkjRTprqD+GTz/TczedAk/wN4APjUJFUOqaq1SXYFLktya1Vd2VaxSR4rAMbGxh6RxCRJ07PZNoiqurZZXFpV/9j9AZZO54BJTgCOBl5SVa1/0KtqbfO9nk6bx4HTOZYkafp6baQ+oaXsFVt6sCRHAG8HXlhV909SZ/umxzbNq7SHAze21ZUk9c9UbRDHAy8G9k5yYdemxwObHfo7ybnAocAuSdbQmU/iHcCj6Tw2AvhWVb0uyR7AmVV1FJ1JiS5otm8DfLqqLp7GuQ1Fdw9re1VLmsumaoP4J2AdsAvwga7y+4AbNrdjVR3fUnzWJHXXAkc1y3cAB0wR16zU3cPaXtWS5rqpphz9PvB94JmDCWdu6+5hba9qSXNdT20QSQ5Ock2Snyb5VZLfJNnU7+AkScPTayP1acDxwG3AY4DXAB/uV1CSpOHrdbA+qur2JAuq6jfAx5P8Ux/jkiQNWa8J4v4k2wGrk/w1nYbreTuaqyTNB70+YnpZU/eNwM+AvYA/6ldQkqThm/IOIskC4L1V9VLgF8ApfY9KkjR0U95BNG0OC5tHTJKkeaLXNog7gW82val/Nl5YVaf2IyhJ0vD1miDWNp9H0RlmA1qG/5YkjY5eE8TNVfW57oIkL+pDPJKkWaLXt5japgbd3HShkqQ5bqrRXI+kM4jeoiQf6tq0A50JfyRJI2qqR0xrgVXAC4Fru8rvA97Sr6AkScM31Wiu1wPXJ/l0Vf16QDFJkmaBXhupD0zyLuBJzT4Bqqqe3K/AJEnD1Wsj9VnAqcCzgf8EjDXfm5VkZZL1SW7sKts5yWVJbmu+d5pk3xOaOrc181hLkgao1wSxsaq+WlXrq+rH458e9jsbOGJC2UnA5VW1D3B5s/4wSXamM0XpQcCBwMmTJRJJUn/0+ojpiiTvB84HfjleWFXXbW6nqroyyZIJxcvozFUNcA7wNeDtE+r8HnBZVd0DkOQyOonm3B7jnRWcn1rSXNZrgjio+R7rKivgsGkcc7eqWgdQVeuS7NpSZxFwV9f6mqbsEZIsB5YDLF48e/4AOz+1pLmupwRRVc/tdyATpC2MtopVtQJYATA2NjZrhv9wfmpJc12vc1LvluSsJF9t1vdL8uppHvPuJLs3v7M7sL6lzho6c06M25NOnwxJ0oD02kh9NnAJsEez/s/AidM85oXA+FtJJwBfaqlzCXB4kp2axunDmzJJ0oD0miB2qarPAg8CVNUDwG+m2inJucBVwL5J1jR3He8DXpDkNuAFzTpJxpKc2fz+PcB7gGuaz7vHG6wlSYPRayP1z5I8gaYdIMnBwMapdqqq4yfZ9LyWuquA13StrwRW9hifJGmG9Zog/pzOo6GnJPkmsBA4pm9RSZKGrte3mK5L8p+Bfem8YfRdx2aSpNHW61tMbwAeV1U3VdWNwOOS/Gl/Q5MkDVOvjdSvraqfjK9U1b3Aa/sT0mga71V97Meu4tNX/2DY4UjSlHptg3hUklTVeCP1AmC7/oU1WuxVLWku6jVBXAJ8NskZdN5keh1wcd+iGjH2qpY0F/WaIN4O/AnwejqN1JcCZ/YrKEnS8PX6FtODwOnNR5I0D/SUIJIcArwLZ5STpHmj10dMZwFvAa6lhyE2JElzX68JYmNVfbWvkUiSZpW+zignSZq7hjGjnCRpDpitM8qNtO65qsH5qiXNTr2+xfRbwMnAc5qif6QzR8OUQ37r4bp7VYM9qyXNXr0+YloJ3Aj8cbP+MuDjwB/2I6hR1t2rGuxZLWn26nWwvqdU1clVdUfzOQWYVh+IJPsmWd312ZTkxAl1Dk2ysavOO6dzLEnS9PV6B/HzJM+uqm/Av3Wc+/l0DlhV3wWWNr+zAPghcEFL1a9X1dHTOYYkaev1miBeD5zTtEUA3Au8YgaO/zzgX6rq+zPwW5KkGdTrW0yrgQOS7NCsb5qh4x8HnDvJtmcmuR5YC7ytqm5qq5RkObAcYPFiG3olaab0OqPc/06yY1VtqqpNSXZK8pdbc+Ak2wEvBD7Xsvk64ElVdQDwYeCLk/1OVa2oqrGqGlu4cOHWhCRJ6tJrI/WRLTPKHbWVxz4SuK6q7p64oUlEP22WLwK2TbLLVh5PkrQFek0QC5I8enwlyWOAR2+mfi+OZ5LHS0memCTN8oFNnD/eyuNJkrZAr43U/xe4PMnH6Qyx8SrgnOkeNMljgRfQmYRovOx1AFV1BnAM8PokD9B5W+q48elOR1F3z2p7VUuaLXptpP7rJDcAz6czF8R7quqS6R60qu4HnjCh7Iyu5dOA06b7+3OJ81VLmq02myCSZPxf7lV1MS3zUHfX0ZZzvmpJs9VUbRBXJHlTkof9kzbJdkkOS3IOcEL/wpMkDctUj5iOoNPecG6SvYGfAI+hk1guBT7Y9JGQJI2YzSaIqvoF8FHgo0m2BXYBft79yqskaTT1+hYTVfVrYF0fY5EkzSK99oOQJM0zJghJUqtpJYgkhyT5yEwHI0maPXpug0iyFHgxnVnlvgec36+gJEnDN1VHuf9AZ0ju4+mMhXQekKp67gBikyQN0VR3ELcCXwd+v6puB0jylr5HJUkauqnaIP4I+Fc6Par/Lsnz6IzFJEkacZtNEFV1QVUdC/w28DXgLcBuSU5PcvgA4pMkDUlPbzFV1c+q6lNVdTSwJ7AaOKmvkUmShmqLX3Otqnuq6mNVdVg/ApIkzQ5D6yiX5M4k30myOsmqlu1J8qEktye5IckzhhGnJM1XPfeD6JPnVtWPJtl2JLBP8zkIOL35liQNwLATxOYsAz7RTEb0rSQ7Jtm9qkZ6wMDu6Ue7ORWppEEb5lhMBVya5Noky1u2LwLu6lpf05Q9TJLlSVYlWbVhw4Y+hToYy5YuYr/dd3hE+c3rNvGl1T8cQkSS5rNh3kEcUlVrk+wKXJbk1qq6smt7W3+LR0xtWlUrgBUAY2Njc3rq0+7pR7s5FamkYRjaHURVrW2+1wMXAAdOqLIG2KtrfU9g7WCikyQNJUEk2T7J48eXgcOBGydUuxB4efM208HAxlFvf5Ck2WRYj5h2Ay5IMh7Dp6vq4iSvA6iqM4CLgKOA24H7gVcOKVZJmpeGkiCq6g7ggJbyM7qWC3jDIOOSJD3EGeUkSa1MEJKkViYISVKr2dyTWl0m62E9GXteS9paJog5YNnSR3Qg36yb120CMEFI2iomiDlgsh7Wk7HntaSZYBuEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFb2gxhRW9rzupu9sCWBCWIkbWnP6272wpY0zgQxgra053U3e2FLGjfwNogkeyW5IsktSW5K8uaWOocm2ZhkdfN556DjlKT5bhh3EA8Ab62q65p5qa9NcllV3Tyh3ter6ughxCdJYgh3EFW1rqqua5bvA24Bpv/QXJLUF0N9zTXJEuDpwNUtm5+Z5PokX03yO5v5jeVJViVZtWHDhj5FKknzz9ASRJLHAV8ATqyqTRM2Xwc8qaoOAD4MfHGy36mqFVU1VlVjCxcu7F/AkjTPDCVBJNmWTnL4VFWdP3F7VW2qqp82yxcB2ybZZcBhStK8Noy3mAKcBdxSVadOUueJTT2SHEgnzh8PLkpJ0jDeYjoEeBnwnSSrm7K/ABYDVNUZwDHA65M8APwcOK6qagixzktb0wt70Oz1LfXPwBNEVX0DyBR1TgNOG0xE6rY1vbAHzV7fUn/Zk1oPszW9sAdtrtzlSHOVo7lKklqZICRJrUwQkqRWJghJUisThCSplQlCktTKBCFJamU/CM1p0+n1be9rqTcmCM1Z0+n1be9rqXcmCM1Z0+n1be9rqXe2QUiSWpkgJEmtTBCSpFYmCElSKxOEJKnVsOakPiLJd5PcnuSklu2PTnJes/3qJEsGH6UkzW/DmJN6AfAR4EhgP+D4JPtNqPZq4N6q+vfAB4G/GmyUkqRh9IM4ELi9qu4ASPIZYBlwc1edZcC7muXPA6clifNSaybMpTm3pV7st8cOnPz7vzPjvzuMBLEIuKtrfQ1w0GR1quqBJBuBJwA/mvhjSZYDywEWL7Z3rDZvLs25LQ3bMBJEWsom3hn0UqdTWLUCWAEwNjbmHYY2ay7NuS0N2zAaqdcAe3Wt7wmsnaxOkm2A3wLuGUh0kiRgOAniGmCfJHsn2Q44DrhwQp0LgROa5WOAf7D9QZIGa+CPmJo2hTcClwALgJVVdVOSdwOrqupC4Czgk0lup3PncNyg45Sk+W4oo7lW1UXARRPK3tm1/AvgRYOOS5L0EHtSS5JamSAkSa1MEJKkViYISVKrjNLbo0k2AN+f5u670NJTe8R5zqNvvp0veM5b6klVtbBtw0gliK2RZFVVjQ07jkHynEfffDtf8Jxnko+YJEmtTBCSpFYmiIesGHYAQ+A5j775dr7gOc8Y2yAkSa28g5AktTJBSJJazfsEkeSIJN9NcnuSk4YdTz8k2SvJFUluSXJTkjc35TsnuSzJbc33TsOOdaYlWZDk20n+vlnfO8nVzTmf1ww5PzKS7Jjk80luba73M0f9Oid5S/Pf9Y1Jzk3y70btOidZmWR9khu7ylqvazo+1PxNuyHJM6Z73HmdIJIsAD4CHAnsBxyfZL/hRtUXDwBvraqnAgcDb2jO8yTg8qraB7i8WR81bwZu6Vr/K+CDzTnfC7x6KFH1z/8BLq6q3wYOoHPuI3udkywC/gwYq6r96UwhcByjd53PBo6YUDbZdT0S2Kf5LAdOn+5B53WCAA4Ebq+qO6rqV8BngGVDjmnGVdW6qrquWb6Pzh+NRXTO9Zym2jnAHwwnwv5IsifwX4Azm/UAhwGfb6qM1Dkn2QF4Dp35VKiqX1XVTxjx60xn2oLHNLNPPhZYx4hd56q6kkfOqjnZdV0GfKI6vgXsmGT36Rx3vieIRcBdXetrmrKRlWQJ8HTgamC3qloHnSQC7Dq8yPrib4H/DjzYrD8B+ElVPdCsj9r1fjKwAfh481jtzCTbM8LXuap+CPwN8AM6iWEjcC2jfZ3HTXZdZ+zv2nxPEGkpG9n3fpM8DvgCcGJVbRp2PP2U5GhgfVVd213cUnWUrvc2wDOA06vq6cDPGKHHSW2a5+7LgL2BPYDt6TximWiUrvNUZuy/8/meINYAe3Wt7wmsHVIsfZVkWzrJ4VNVdX5TfPf4rWfzvX5Y8fXBIcALk9xJ59HhYXTuKHZsHkXA6F3vNcCaqrq6Wf88nYQxytf5+cD3qmpDVf0aOB94FqN9ncdNdl1n7O/afE8Q1wD7NG88bEencevCIcc045pn72cBt1TVqV2bLgROaJZPAL406Nj6pareUVV7VtUSOtf1H6rqJcAVwDFNtVE7538F7kqyb1P0POBmRvg603m0dHCSxzb/nY+f88he5y6TXdcLgZc3bzMdDGwcfxS1peZ9T+okR9H5l+UCYGVVvXfIIc24JM8Gvg58h4eex/8FnXaIzwKL6fyP9qKqmtgQNuclORR4W1UdneTJdO4odga+Dby0qn45zPhmUpKldBrltwPuAF5J5x+CI3udk5wCHEvnbb1vA6+h88x9ZK5zknOBQ+kM6303cDLwRVqua5MoT6Pz1tP9wCuratW0jjvfE4Qkqd18f8QkSZqECUKS1MoEIUlqZYKQJLUyQUiSWpkgpGlqRk7902Z5jySfn2ofaS7xNVdpmppxrf6+GUVUGjnbTF1F0iTeBzwlyWrgNuCpVbV/klfQGVlzAbA/8AE6HddeBvwSOKrp0PQUOsPNL6TToem1VXXr4E9DaucjJmn6TgL+paqWAv9twrb9gRfTGVL+vcD9zQB6VwEvb+qsAN5UVf8ReBvw0YFELfXIOwipP65o5t64L8lG4MtN+XeApzUj6z4L+FxnZAQAHj34MKXJmSCk/uge9+fBrvUH6fx/9yg6cxYsHXRgUq98xCRN333A46ezYzMfx/eSvAj+bR7hA2YyOGlrmSCkaaqqHwPfbCaSf/80fuIlwKuTXA/cxAhOd6u5zddcJUmtvIOQJLUyQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1Or/A1RpFPC8EvOdAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -92,17 +92,17 @@ "metadata": {}, "source": [ "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007):\n", - "$$n_0exp[-kt]$$\n" + "$$ n_0exp[-kt] $$\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 66, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -118,7 +118,7 @@ " values = model.simulate(k, times)\n", " plt.step(times, values)\n", "\n", - "mean = model.DeterministicMean(k, times)\n", + "mean = model.deterministic_mean(k, times)\n", " \n", "plt.plot(times, mean, label = 'deterministic mean of A(t)')\n", "plt.title('stochastic degradation across different iterations')\n", @@ -128,13 +128,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -144,12 +137,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 67, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -161,20 +154,13 @@ } ], "source": [ - "[time, mol_count] = model.StochasticSimulationAlgorithm(0.1)\n", + "time, mol_count = model.simulate_stochastically([0.1])\n", "\n", "plt.step(time, mol_count)\n", "plt.xlabel('time')\n", "plt.ylabel('Molecule count')\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 04137696155431eb99b67fe38fb531897c3001eb Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 14:55:23 +0100 Subject: [PATCH 23/56] updated stochastic degradation model example notebook --- examples/toy-model-stochastic-degradation.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index c6a7f6111..ad73aba1a 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -91,8 +91,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007):\n", - "$$ n_0exp[-kt] $$\n" + "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0exp[-kt] $\n" ] }, { From 9485a27a20582f29ca5c447872cdc8addf07fdc7 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 17:08:10 +0100 Subject: [PATCH 24/56] updated stochastic degradation example notebook --- .../toy-model-stochastic-degradation.ipynb | 34 +++++++++++-------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index ad73aba1a..b72d82d3e 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -64,12 +64,12 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -91,17 +91,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0exp[-kt] $\n" + "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the concentration values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $\n" ] }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -131,17 +131,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Determine exact times of single reactions according to the Gillespie algorithm (shown above) and plot step function" + "The deterministic mean (from above) is plotted with the deterministic standard deviation. \n", + "The deterministic variance of this model is given by: $e^{-2kt}(-1 + e^{kt})n_0$" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -153,11 +154,14 @@ } ], "source": [ - "time, mol_count = model.simulate_stochastically([0.1])\n", + "mean = model.deterministic_mean(k, times)\n", + "variance = model.deterministic_variance(k, times)\n", + "std_dev = np.sqrt(variance)\n", "\n", - "plt.step(time, mol_count)\n", - "plt.xlabel('time')\n", - "plt.ylabel('Molecule count')\n", + "plt.plot(times, mean, '-', label = 'mean')\n", + "plt.plot(times, mean + std_dev, '--', label = 'standard deviation upper bound')\n", + "plt.plot(times, mean - std_dev, '--', label = 'standard deviation lower bound')\n", + "plt.legend(loc = 'upper right')\n", "plt.show()" ] } From a1f4c2f6caf10d3b83a8e561e32f38a3726556c0 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 17:10:39 +0100 Subject: [PATCH 25/56] updated stochastic degradation model PINTS code --- pints/toy/_stochastic_degradation_model.py | 56 ++++++++++++---------- 1 file changed, 32 insertions(+), 24 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index cd8e3baba..54745b434 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -25,7 +25,8 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): $A rightarrow{\text{k}} 0 $ [1] The model is simulated according to the Gillespie algorithm [2]: - 1. Sample a random value r from a uniform distribution: :math:: r ~ unif(0,1) + 1. Sample a random value r from a uniform distribution: + :math:: r ~ unif(0,1) 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: $\tau = \frac{1}{A(t)k}*ln{\frac{1}{r}}$ [1] @@ -73,29 +74,7 @@ def simulate(self, parameters, times): if self._n0 == 0: return np.zeros(times.shape) - time, mol_count = self.simulate_stochastically(parameters) - - # Interpolate as step function, decreasing mol_count by 1 at each - # reaction time point - self._interp_func = interp1d(time, mol_count, kind='previous') - - # Compute concentration values at given time points using f1 - # at any time beyond the last reaction, concentration = 0 - values = self._interp_func(times[np.where(times <= max(time))]) - zero_vector = np.zeros(len(times[np.where(times > max(time))])) - values = np.concatenate((values, zero_vector)) - - return values - - def simulate_stochastically(self, parameters): - """ Stochastic simulation according to Gillespie algorithm""" - if len(parameters) != self.n_parameters(): - raise ValueError('This model should have only 1 parameter.') - k = parameters[0] t = 0 - if k <= 0: - raise ValueError('Rate constant must be positive.') - a = self._n0 self._mol_count = [a] self._time = [t] @@ -109,7 +88,18 @@ def simulate_stochastically(self, parameters): a = a - 1 self._mol_count.append(a) - return self._time, self._mol_count + # Interpolate as step function, decreasing mol_count by 1 at each + # reaction time point + self._interp_func = interp1d(self._time, self._mol_count, + kind='previous') + + # Compute concentration values at given time points using f1 + # at any time beyond the last reaction, concentration = 0 + values = self._interp_func(times[np.where(times <= max(self._time))]) + zero_vector = np.zeros(len(times[np.where(times > max(self._time))])) + values = np.concatenate((values, zero_vector)) + + return values def deterministic_mean(self, parameters, times): """ Calculates deterministic mean of infinitely many stochastic @@ -129,6 +119,24 @@ def deterministic_mean(self, parameters, times): return mean + def deterministic_variance(self, parameters, times): + """ Calculates deterministic variance of infinitely many stochastic + simulations, which follows :math:: exp(-2kt)(-1 + exp(kt)) * n0""" + if len(parameters) != self.n_parameters(): + raise ValueError('This model should have only 1 parameter.') + k = parameters[0] + + if k <= 0: + raise ValueError('Rate constant must be positive.') + + times = np.asarray(times) + if np.any(times < 0): + raise ValueError('Negative times are not allowed.') + + variance = np.exp(-2 * k * times) * (-1 + np.exp(k * times)) * self._n0 + + return variance + def suggested_parameters(self): """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ return np.array([0.1]) From 7293e154dcb18facac271a772fcb1c6d4afa62ee Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 2 Aug 2019 17:12:09 +0100 Subject: [PATCH 26/56] updated stochastic degradation model unit tests --- .../test_toy_stochastic_degradation_model.py | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index ac2200fb7..276f18254 100644 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -47,31 +47,29 @@ def test_suggested(self): self.assertEqual(values[0], 20) self.assertEqual(values[-1], 0) - def test_simulate_stochastically(self): - parameters = [0.1] - time, mol_count = model.simulate_stochastically(parameters) - self.assertTrue(np.all(mol_count == - np.array(range(20, -1, -1)))) - - def test_interpolate_function(self): + def test_simulate(self): model = pints.toy.StochasticDegradationModel(20) - times = np.linspace(0, 100, 101) parameters = [0.1] - + times = np.linspace(0, 100, 101) values = model.simulate(parameters, times) + + # Test output of Gillespie algorithm + self.assertTrue(np.all(self._mol_count == + np.array(range(20, -1, -1)))) + + # Test interpolation function # Check exact time points from stochastic simulation - self.assertTrue(np.all(model._interp_func(self._time) == + self.assertTrue(np.all(self._interp_func(self._time) == self._mol_count)) # Check simulate function returns expected values self.assertTrue(np.all(values[np.where(times < self._time[1])] == 20)) # Check interpolation function works as expected - self.assertTrue(model._interp_func(np.random.uniform(self._time[0], - self._time[1])) == 20) - self.assertTrue(model._interp_func(np.random.uniform(self._time[1], - self._time[2])) == 19) - + self.assertTrue(self._interp_func(np.random.uniform(self._time[0], + self._time[1])) == 20) + self.assertTrue(self._interp_func(np.random.uniform(self._time[1], + self._time[2])) == 19) def test_errors(self): model = pints.toy.StochasticDegradationModel(20) @@ -81,21 +79,23 @@ def test_errors(self): self.assertRaises(ValueError, model.simulate, parameters, times) self.assertRaises(ValueError, model.deterministic_mean, parameters, times) - self.assertRaises(ValueError, model.simulate_stochastically, - parameters) + self.assertRaises(ValueError, model.deterministic_variance, parameters + times) times_2 = np.linspace(-10, 10, 21) parameters_2 = 0.1 self.assertRaises(ValueError, model.simulate, parameters_2, times_2) self.assertRaises(ValueError, model.deterministic_mean, parameters_2, times_2) + self.assertRaises(ValueError, model.deterministic_variance, + parameters_2, times_2) # this model should have 1 parameter parameters_3 = [0.1, 1] self.assertRaises(ValueError, model.simulate, parameters_3, times) self.assertRaises(ValueError, model.deterministic_mean, parameters_3, times) - self.assertRaises(ValueError, model.simulate_stochastically, + self.assertRaises(ValueError, model.deterministic_variance, parameters_3, times) # Initial value can't be negative From 696475e08233dfa70e2439b70204ea174968bd5e Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 13:17:09 -0400 Subject: [PATCH 27/56] updated stochastic degradation example notebook --- .../toy-model-stochastic-degradation.ipynb | 55 +++++++++---------- 1 file changed, 25 insertions(+), 30 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index b72d82d3e..332c0f039 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -8,11 +8,11 @@ "\n", "This example shows how the stochastic degradation model can be used.\n", "This model describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react.\n", - "The substance degrades starting from an initial concentration, n_0, to 0 following a rate constant, k, according to the following model (Erban et al., 2007):\n", + "The substance degrades starting from an initial concentration, $n_0$, to 0 following a rate constant, $k$, according to the following model (Erban et al., 2007):\n", " $$A \\xrightarrow{\\text{k}} \\emptyset$$\n", "\n", "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)\n", - " 1. Sample a random value r from a uniform distribution: r ~ unif(0,1)\n", + " 1. Sample a random value r from a uniform distribution: $r \\sim uniform(0,1)$\n", " 2. Calculate the time ($\\tau$) until the next single reaction as follows (Erban et al., 2007):\n", " $$ \\tau = \\frac{1}{A(t)k} \\ln{\\big[\\frac{1}{r}\\big]} $$\n", " 3. Update the molecule count at time t + $\\tau$ as: $ A(t + \\tau) = A(t) - 1 $\n", @@ -42,34 +42,12 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "n_0 = 20\n", - "model = pints.toy.StochasticDegradationModel(n_0)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "times = np.linspace(0, 100, 100)\n", - "k = [0.1]\n", - "\n", - "values = model.simulate(k, times)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -81,9 +59,17 @@ } ], "source": [ + "n_0 = 20\n", + "model = pints.toy.StochasticDegradationModel(n_0)\n", + "\n", + "times = np.linspace(0, 100, 100)\n", + "k = [0.1]\n", + "\n", + "values = model.simulate(k, times)\n", + "\n", "plt.step(times, values)\n", "plt.xlabel('time')\n", - "plt.ylabel('A (concentration)')\n", + "plt.ylabel('concentration (A(t))')\n", "plt.show()" ] }, @@ -137,12 +123,12 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -158,12 +144,21 @@ "variance = model.deterministic_variance(k, times)\n", "std_dev = np.sqrt(variance)\n", "\n", - "plt.plot(times, mean, '-', label = 'mean')\n", + "plt.plot(times, mean, '-', label = 'deterministic mean of A(t)')\n", "plt.plot(times, mean + std_dev, '--', label = 'standard deviation upper bound')\n", "plt.plot(times, mean - std_dev, '--', label = 'standard deviation lower bound')\n", "plt.legend(loc = 'upper right')\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From a7966a645718d20ecf2ce941bac755d68c7dbe9d Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 17:53:41 -0400 Subject: [PATCH 28/56] updated stochastic degradation model PINTS code --- pints/toy/_stochastic_degradation_model.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 54745b434..25b6ca969 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -61,6 +61,7 @@ def n_parameters(self): def simulate(self, parameters, times): """ See :meth:`pints.ForwardModel.simulate()`. """ + parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') k = parameters[0] @@ -104,6 +105,7 @@ def simulate(self, parameters, times): def deterministic_mean(self, parameters, times): """ Calculates deterministic mean of infinitely many stochastic simulations, which follows :math:: n0*exp(-kt)""" + parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') k = parameters[0] @@ -122,6 +124,7 @@ def deterministic_mean(self, parameters, times): def deterministic_variance(self, parameters, times): """ Calculates deterministic variance of infinitely many stochastic simulations, which follows :math:: exp(-2kt)(-1 + exp(kt)) * n0""" + parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') k = parameters[0] From 1e054cc1762aec4d29d12b06aefe56a06e4ae31c Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 17:57:04 -0400 Subject: [PATCH 29/56] updated stochastic degradation model unit test --- .../test_toy_stochastic_degradation_model.py | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 276f18254..de943bada 100644 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -20,7 +20,8 @@ class TestStochasticDegradation(unittest.TestCase): def test_start_with_zero(self): # Test the special case where the initial concentration is zero - model = pints.toy.StochasticDegradationModel(0) + from pints.toy import StochasticDegradationModel + model = StochasticDegradationModel(0) times = [0, 1, 2, 100, 1000] parameters = [0.1] values = model.simulate(parameters, times) @@ -54,36 +55,36 @@ def test_simulate(self): values = model.simulate(parameters, times) # Test output of Gillespie algorithm - self.assertTrue(np.all(self._mol_count == + self.assertTrue(np.all(model._mol_count == np.array(range(20, -1, -1)))) # Test interpolation function # Check exact time points from stochastic simulation - self.assertTrue(np.all(self._interp_func(self._time) == - self._mol_count)) + self.assertTrue(np.all(model._interp_func(model._time) == + model._mol_count)) # Check simulate function returns expected values - self.assertTrue(np.all(values[np.where(times < self._time[1])] == 20)) + self.assertTrue(np.all(values[np.where(times < model._time[1])] == 20)) # Check interpolation function works as expected - self.assertTrue(self._interp_func(np.random.uniform(self._time[0], - self._time[1])) == 20) - self.assertTrue(self._interp_func(np.random.uniform(self._time[1], - self._time[2])) == 19) + self.assertTrue(model._interp_func(np.random.uniform(model._time[0], + model._time[1])) == 20) + self.assertTrue(model._interp_func(np.random.uniform(model._time[1], + model._time[2])) == 19) def test_errors(self): model = pints.toy.StochasticDegradationModel(20) # parameters, times cannot be negative times = np.linspace(0, 100, 101) - parameters = -0.1 + parameters = [-0.1] self.assertRaises(ValueError, model.simulate, parameters, times) self.assertRaises(ValueError, model.deterministic_mean, parameters, times) - self.assertRaises(ValueError, model.deterministic_variance, parameters + self.assertRaises(ValueError, model.deterministic_variance, parameters, times) times_2 = np.linspace(-10, 10, 21) - parameters_2 = 0.1 + parameters_2 = [0.1] self.assertRaises(ValueError, model.simulate, parameters_2, times_2) self.assertRaises(ValueError, model.deterministic_mean, parameters_2, times_2) @@ -103,4 +104,4 @@ def test_errors(self): if __name__ == '__main__': - unittest.main() \ No newline at end of file + unittest.main() From 31ae152d6a4efbb3cd1907d307340a9126ab86c9 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 18:13:04 -0400 Subject: [PATCH 30/56] updated stochastic degradation model PINTS code --- pints/toy/_stochastic_degradation_model.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 25b6ca969..c72b5b136 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -39,8 +39,11 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): The initial concentration :math:`A(0) = n_0` can be set using the (optional) named constructor arg ``initial_concentration`` - [1] Erban et al., 2007 - [2] Gillespie, 1976 + [1] A Practical Guide to Stochastic Simulations of Reaction Diffusion + Processes. Erban, Radek (2007). arXiv:0704.1908 [q-bio.SC] + [2] A general method for numerically simulating the stochastic time + evolution of coupled chemical reactions. Gillespie, Daniel (1976). + Journal of Computational Physics *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. """ From 698ca90fd91075cba3e803d68c652f5340410443 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 18:15:45 -0400 Subject: [PATCH 31/56] updated toy/__init__ added imported StochasticDegradationModel --- pints/toy/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pints/toy/__init__.py b/pints/toy/__init__.py index 948738a2e..5d4e58c0b 100644 --- a/pints/toy/__init__.py +++ b/pints/toy/__init__.py @@ -32,3 +32,4 @@ from ._simple_egg_box import SimpleEggBoxLogPDF # noqa from ._sir_model import SIRModel # noqa from ._twisted_gaussian_banana import TwistedGaussianLogPDF # noqa +from ._stochastic_degradation_model import StochasticDegradationModel # noqa From 0ce40126c0a8a9fa80e6d8e7aaf782ca843a5b02 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 20:15:44 -0400 Subject: [PATCH 32/56] updated example notebook readme --- examples/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/README.md b/examples/README.md index 748016ffa..de4c068c9 100644 --- a/examples/README.md +++ b/examples/README.md @@ -81,6 +81,7 @@ relevant code. - [Lotka-Volterra predator-prey model](./toy-model-lotka-volterra.ipynb) - [Repressilator model](./toy-model-repressilator.ipynb) - [SIR Epidemiology model](./toy-model-sir.ipynb) +- [Stochastic Degradation model](./toy-model-stochastic-degradation.ipynb) ### Distributions - [Annulus](./toy-distribution-annulus.ipynb) From f39bb38e01ed39e58ad07ac9d7aa5bdcfbf9bc92 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 20:29:22 -0400 Subject: [PATCH 33/56] stochastic degradation rst file --- docs/source/toy/stochastic_degradation_model.rst | 3 +++ pints/tests/stochastic_degradation_model.rst | 0 2 files changed, 3 insertions(+) create mode 100644 docs/source/toy/stochastic_degradation_model.rst create mode 100644 pints/tests/stochastic_degradation_model.rst diff --git a/docs/source/toy/stochastic_degradation_model.rst b/docs/source/toy/stochastic_degradation_model.rst new file mode 100644 index 000000000..1eb6a1191 --- /dev/null +++ b/docs/source/toy/stochastic_degradation_model.rst @@ -0,0 +1,3 @@ +.. currentmodule:: pints.toy + +.. autoclass:: StochasticDegradationModel \ No newline at end of file diff --git a/pints/tests/stochastic_degradation_model.rst b/pints/tests/stochastic_degradation_model.rst new file mode 100644 index 000000000..e69de29bb From 46bc1f115dc2121974bcc5f2bd74fa6dfbdaabac Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 20:48:22 -0400 Subject: [PATCH 34/56] updated stochastci degradation model PINTS code --- pints/toy/_stochastic_degradation_model.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index c72b5b136..4633e8e03 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -150,4 +150,3 @@ def suggested_parameters(self): def suggested_times(self): """ See "meth:`pints.toy.ToyModel.suggested_times()`.""" return np.linspace(0, 100, 101) - From 5dd0fe5372d6f25cdde19c73e759b62852745b20 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 20:50:09 -0400 Subject: [PATCH 35/56] updated stochastic degradation unit test --- pints/tests/test_toy_stochastic_degradation_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index de943bada..a9160aca0 100644 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -68,9 +68,9 @@ def test_simulate(self): # Check interpolation function works as expected self.assertTrue(model._interp_func(np.random.uniform(model._time[0], - model._time[1])) == 20) + model._time[1])) == 20) self.assertTrue(model._interp_func(np.random.uniform(model._time[1], - model._time[2])) == 19) + model._time[2])) == 19) def test_errors(self): model = pints.toy.StochasticDegradationModel(20) From 30c21b312effc2a0864fa922d9a4d768a19925cd Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Thu, 8 Aug 2019 21:19:33 -0400 Subject: [PATCH 36/56] updated stochastic degradation rst file --- docs/source/toy/stochastic_degradation_model.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/toy/stochastic_degradation_model.rst b/docs/source/toy/stochastic_degradation_model.rst index 1eb6a1191..477a1fa50 100644 --- a/docs/source/toy/stochastic_degradation_model.rst +++ b/docs/source/toy/stochastic_degradation_model.rst @@ -1,3 +1,3 @@ .. currentmodule:: pints.toy -.. autoclass:: StochasticDegradationModel \ No newline at end of file +.. autoclass:: StochasticDegradationModel From d6dd539a18ea64914f517bda258e0137bd35e566 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 9 Aug 2019 10:34:05 -0400 Subject: [PATCH 37/56] index rst file --- docs/source/toy/index.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/toy/index.rst b/docs/source/toy/index.rst index bfe21c344..361782d98 100644 --- a/docs/source/toy/index.rst +++ b/docs/source/toy/index.rst @@ -34,4 +34,6 @@ Some toy classes provide extra functionality defined in the simple_egg_box_logpdf toy_classes twisted_gaussian_logpdf + stochastic_degradation_model + From 0a663584994af1046f6b22b10432455470c7b358 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 9 Aug 2019 10:42:44 -0400 Subject: [PATCH 38/56] updated stochastic degradation model --- pints/toy/_stochastic_degradation_model.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 4633e8e03..a3d76972c 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -28,8 +28,8 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): 1. Sample a random value r from a uniform distribution: :math:: r ~ unif(0,1) 2. Calculate the time ($\tau$) until the next single reaction as follows: - .. math:: - $\tau = \frac{1}{A(t)k}*ln{\frac{1}{r}}$ [1] + .. math:: + $\tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} $ [1] 3. Update the molecule count at time t + .. math:: $\tau$ as: .. math:: $A(t + \tau) = A(t)-1$ 4. Return to step (1) until molecule count reaches 0 @@ -121,7 +121,6 @@ def deterministic_mean(self, parameters, times): raise ValueError('Negative times are not allowed.') mean = self._n0 * np.exp(-k * times) - return mean def deterministic_variance(self, parameters, times): @@ -140,7 +139,6 @@ def deterministic_variance(self, parameters, times): raise ValueError('Negative times are not allowed.') variance = np.exp(-2 * k * times) * (-1 + np.exp(k * times)) * self._n0 - return variance def suggested_parameters(self): From 9a6424b24ecd621fcb461eafa005813f2eb741b8 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Fri, 9 Aug 2019 11:22:33 -0400 Subject: [PATCH 39/56] updated stochastic degradation model --- pints/toy/_stochastic_degradation_model.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index a3d76972c..f8105a380 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -22,16 +22,18 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): an initial concentration :math:: n0 and degrading to 0 according to the following model: .. math:: - $A rightarrow{\text{k}} 0 $ [1] + \\A \rightarrow{\text{k}} 0 [1] \\\\ The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: - :math:: r ~ unif(0,1) + :math:: + \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: - $\tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} $ [1] - 3. Update the molecule count at time t + .. math:: $\tau$ as: - .. math:: $A(t + \tau) = A(t)-1$ + \\ \tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + 3. Update the molecule count at time t + .. math:: \\tau as: + .. math:: + \\A(t + \tau) = A(t)-1 \\\\ 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From 707fa98037cdca1563130981a0329fae8c3eab6b Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:10:24 -0400 Subject: [PATCH 40/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index f8105a380..7b7896f51 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -22,18 +22,18 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): an initial concentration :math:: n0 and degrading to 0 according to the following model: .. math:: - \\A \rightarrow{\text{k}} 0 [1] \\\\ + \\A \rightarrow{\text{k}} 0 [1] \\\\ The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: :math:: - \\r ~ unif(0,1) \\ + \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: - \\ \tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + \\ \tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ 3. Update the molecule count at time t + .. math:: \\tau as: .. math:: - \\A(t + \tau) = A(t)-1 \\\\ + \\A(t + \tau) = A(t)-1 \\\\ 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From 138b75652dd1c524baa8893202329639d4118c6e Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:22:19 -0400 Subject: [PATCH 41/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 7b7896f51..47de6bc04 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -22,18 +22,18 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): an initial concentration :math:: n0 and degrading to 0 according to the following model: .. math:: - \\A \rightarrow{\text{k}} 0 [1] \\\\ + A \\rightarrow{k} 0 [1] \\\\ The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: :math:: - \\r ~ unif(0,1) \\ + \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: - \\ \tau = \frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ 3. Update the molecule count at time t + .. math:: \\tau as: .. math:: - \\A(t + \tau) = A(t)-1 \\\\ + \\A(t + \\tau) = A(t)-1 \\\\ 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From 77ae6d1337d9592bc73167dfa9a9c7ecf4d009c5 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:28:04 -0400 Subject: [PATCH 42/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 47de6bc04..bfc367353 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -21,19 +21,15 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): Stochastic degradation model of a single chemical reaction starting from an initial concentration :math:: n0 and degrading to 0 according to the following model: - .. math:: - A \\rightarrow{k} 0 [1] \\\\ + .. math:: A \\rightarrow{k} 0 [1] \\\\ The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: - :math:: - \\r ~ unif(0,1) \\ + :math:: \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: - .. math:: - \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + .. math:: \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ 3. Update the molecule count at time t + .. math:: \\tau as: - .. math:: - \\A(t + \\tau) = A(t)-1 \\\\ + .. math:: \\A(t + \\tau) = A(t)-1 \\\\ 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From 642637544c9611159319b36b80eab2e3be3d8940 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:31:53 -0400 Subject: [PATCH 43/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index bfc367353..fde9d1025 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -27,9 +27,9 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): 1. Sample a random value r from a uniform distribution: :math:: \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: - .. math:: \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + :math:: \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ 3. Update the molecule count at time t + .. math:: \\tau as: - .. math:: \\A(t + \\tau) = A(t)-1 \\\\ + :math:: \\A(t + \\tau) = A(t)-1 \\\\ 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From bf5ea3cea6a25b339c812790b3ef72ea8a4c1382 Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:37:05 -0400 Subject: [PATCH 44/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index fde9d1025..c93dfcae7 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -21,15 +21,24 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): Stochastic degradation model of a single chemical reaction starting from an initial concentration :math:: n0 and degrading to 0 according to the following model: - .. math:: A \\rightarrow{k} 0 [1] \\\\ + .. math:: + + A \\rightarrow{k} 0 [1] \\\\ The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: - :math:: \\r ~ unif(0,1) \\ + .. math:: \\r ~ unif(0,1) \\ + 2. Calculate the time ($\tau$) until the next single reaction as follows: - :math:: \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + .. math:: + + \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + 3. Update the molecule count at time t + .. math:: \\tau as: - :math:: \\A(t + \\tau) = A(t)-1 \\\\ + .. math:: + + \\A(t + \\tau) = A(t)-1 \\\\ + 4. Return to step (1) until molecule count reaches 0 Has one parameter: Rate constant :math:`k`. From 0a9602fe49635eec17d78ee7ffea3653526f25cf Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Tue, 20 Aug 2019 23:46:51 -0400 Subject: [PATCH 45/56] updated sotchastic model code --- pints/toy/_stochastic_degradation_model.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index c93dfcae7..26b07098d 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -27,7 +27,9 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): The model is simulated according to the Gillespie algorithm [2]: 1. Sample a random value r from a uniform distribution: - .. math:: \\r ~ unif(0,1) \\ + .. math:: + + \\r ~ unif(0,1) \\ 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: From 124c7010072a628e4dff65010a0ce289b77e632b Mon Sep 17 00:00:00 2001 From: danielfridman98 Date: Wed, 21 Aug 2019 00:15:04 -0400 Subject: [PATCH 46/56] updated stochastic degradation model code --- pints/toy/_stochastic_degradation_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 26b07098d..b22f89bb8 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -29,14 +29,14 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): 1. Sample a random value r from a uniform distribution: .. math:: - \\r ~ unif(0,1) \\ + \\r ~ unif(0,1) \\\\ 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ - 3. Update the molecule count at time t + .. math:: \\tau as: + 3. Update the molecule count at time t + :math:: \\tau as: .. math:: \\A(t + \\tau) = A(t)-1 \\\\ From 125f2e38e62c23a410310897f79e1c23842b4553 Mon Sep 17 00:00:00 2001 From: ben18785 Date: Fri, 30 Aug 2019 15:14:44 +0100 Subject: [PATCH 47/56] Small changes to style --- docs/source/toy/stochastic_degradation_model.rst | 4 ++++ pints/tests/stochastic_degradation_model.rst | 0 pints/toy/_stochastic_degradation_model.py | 4 +--- 3 files changed, 5 insertions(+), 3 deletions(-) delete mode 100644 pints/tests/stochastic_degradation_model.rst diff --git a/docs/source/toy/stochastic_degradation_model.rst b/docs/source/toy/stochastic_degradation_model.rst index 477a1fa50..048613ed6 100644 --- a/docs/source/toy/stochastic_degradation_model.rst +++ b/docs/source/toy/stochastic_degradation_model.rst @@ -1,3 +1,7 @@ +**************************** +Stochastic degradation model +**************************** + .. currentmodule:: pints.toy .. autoclass:: StochasticDegradationModel diff --git a/pints/tests/stochastic_degradation_model.rst b/pints/tests/stochastic_degradation_model.rst deleted file mode 100644 index e69de29bb..000000000 diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index b22f89bb8..9afdc8d76 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -16,7 +16,6 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): - """ Stochastic degradation model of a single chemical reaction starting from an initial concentration :math:: n0 and degrading to 0 according to the @@ -34,7 +33,7 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: - \\tau &= \\frac{1}{A(t)k} * ln{\frac{1}{r}} [1] \\\\ + \\tau &= \\frac{1}{A(t)k} * ln{\\frac{1}{r}} [1] \\\\ 3. Update the molecule count at time t + :math:: \\tau as: .. math:: @@ -56,7 +55,6 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. """ - def __init__(self, initial_concentration=20): super(StochasticDegradationModel, self).__init__() self._n0 = float(initial_concentration) From 44740d0fe5dc4f472fcf9e5b0ce045103ee716b2 Mon Sep 17 00:00:00 2001 From: ben18785 Date: Fri, 30 Aug 2019 16:28:07 +0100 Subject: [PATCH 48/56] Added tests for mean and variance and changed names to remove deterministic --- .../test_toy_stochastic_degradation_model.py | 33 +++++++++++++++---- pints/toy/_stochastic_degradation_model.py | 4 +-- 2 files changed, 29 insertions(+), 8 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index a9160aca0..77d549184 100644 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -72,31 +72,52 @@ def test_simulate(self): self.assertTrue(model._interp_func(np.random.uniform(model._time[1], model._time[2])) == 19) + def test_mean_variance(self): + # test mean + model = pints.toy.StochasticDegradationModel(10) + v_mean = model.mean([1], [5, 10]) + self.assertEqual(v_mean[0], 10 * np.exp(-5)) + self.assertEqual(v_mean[1], 10 * np.exp(-10)) + + model = pints.toy.StochasticDegradationModel(20) + v_mean = model.mean([5], [7.2]) + self.assertEqual(v_mean[0], 20 * np.exp(-7.2 * 5)) + + # test variance + model = pints.toy.StochasticDegradationModel(10) + v_var = model.variance([1], [5, 10]) + self.assertEqual(v_var[0], 10 * (np.exp(5) - 1.0) / np.exp(10)) + self.assertAlmostEqual(v_var[1], 10 * (np.exp(10) - 1.0) / np.exp(20)) + + model = pints.toy.StochasticDegradationModel(20) + v_var = model.variance([2.0], [2.0]) + self.assertAlmostEqual(v_var[0], 20 * (np.exp(4) - 1.0) / np.exp(8)) + def test_errors(self): model = pints.toy.StochasticDegradationModel(20) # parameters, times cannot be negative times = np.linspace(0, 100, 101) parameters = [-0.1] self.assertRaises(ValueError, model.simulate, parameters, times) - self.assertRaises(ValueError, model.deterministic_mean, parameters, + self.assertRaises(ValueError, model.mean, parameters, times) - self.assertRaises(ValueError, model.deterministic_variance, parameters, + self.assertRaises(ValueError, model.variance, parameters, times) times_2 = np.linspace(-10, 10, 21) parameters_2 = [0.1] self.assertRaises(ValueError, model.simulate, parameters_2, times_2) - self.assertRaises(ValueError, model.deterministic_mean, parameters_2, + self.assertRaises(ValueError, model.mean, parameters_2, times_2) - self.assertRaises(ValueError, model.deterministic_variance, + self.assertRaises(ValueError, model.variance, parameters_2, times_2) # this model should have 1 parameter parameters_3 = [0.1, 1] self.assertRaises(ValueError, model.simulate, parameters_3, times) - self.assertRaises(ValueError, model.deterministic_mean, parameters_3, + self.assertRaises(ValueError, model.mean, parameters_3, times) - self.assertRaises(ValueError, model.deterministic_variance, + self.assertRaises(ValueError, model.variance, parameters_3, times) # Initial value can't be negative diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index 9afdc8d76..fadf638ad 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -112,7 +112,7 @@ def simulate(self, parameters, times): return values - def deterministic_mean(self, parameters, times): + def mean(self, parameters, times): """ Calculates deterministic mean of infinitely many stochastic simulations, which follows :math:: n0*exp(-kt)""" parameters = np.asarray(parameters) @@ -130,7 +130,7 @@ def deterministic_mean(self, parameters, times): mean = self._n0 * np.exp(-k * times) return mean - def deterministic_variance(self, parameters, times): + def variance(self, parameters, times): """ Calculates deterministic variance of infinitely many stochastic simulations, which follows :math:: exp(-2kt)(-1 + exp(kt)) * n0""" parameters = np.asarray(parameters) From fe1595c7a633bb0a1fa9c1194e89ff1bb2ba3815 Mon Sep 17 00:00:00 2001 From: Michael Clerx Date: Sat, 31 Aug 2019 11:28:35 +0100 Subject: [PATCH 49/56] Fixed maths in docstrings. Changed stoch deg model to no longer store local variables in the class. --- .../test_toy_stochastic_degradation_model.py | 0 pints/toy/_stochastic_degradation_model.py | 80 ++++++++++--------- 2 files changed, 42 insertions(+), 38 deletions(-) mode change 100644 => 100755 pints/tests/test_toy_stochastic_degradation_model.py diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py old mode 100644 new mode 100755 diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index fadf638ad..fd1b715ee 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -16,54 +16,54 @@ class StochasticDegradationModel(pints.ForwardModel, ToyModel): - """ + r""" Stochastic degradation model of a single chemical reaction starting from - an initial concentration :math:: n0 and degrading to 0 according to the - following model: + an initial molecule count :math:`A(0)` and degrading to 0 with a fixed rate + :math:`k`: + .. math:: + A \xrightarrow{k} 0 + + Simulations are performed using the Gillespie algorithm [1, 2]: - A \\rightarrow{k} 0 [1] \\\\ + 1. Sample a random value :math:`r` from a uniform distribution - The model is simulated according to the Gillespie algorithm [2]: - 1. Sample a random value r from a uniform distribution: .. math:: + r \sim U(0,1) - \\r ~ unif(0,1) \\\\ + 2. Calculate the time :math:`\tau` until the next single reaction as - 2. Calculate the time ($\tau$) until the next single reaction as follows: .. math:: + \tau = \frac{-\ln(r)}{A(t) k} - \\tau &= \\frac{1}{A(t)k} * ln{\\frac{1}{r}} [1] \\\\ + 3. Update the molecule count :math:`A` at time :math:`t + \tau` as: - 3. Update the molecule count at time t + :math:: \\tau as: .. math:: + A(t + \tau) = A(t) - 1 - \\A(t + \\tau) = A(t)-1 \\\\ + 4. Return to step (1) until the molecule count reaches 0 - 4. Return to step (1) until molecule count reaches 0 + The model has one parameter, the rate constant :math:`k`. - Has one parameter: Rate constant :math:`k`. - :math:`r` is a random variable, which is part of the stochastic model - The initial concentration :math:`A(0) = n_0` can be set using the - (optional) named constructor arg ``initial_concentration`` + The initial molecule count :math:`A(0)` can be set using the optional + constructor argument ``initial_molecule_count`` [1] A Practical Guide to Stochastic Simulations of Reaction Diffusion - Processes. Erban, Radek (2007). arXiv:0704.1908 [q-bio.SC] + Processes. Erban, Chapman, Maini (2007). arXiv:0704.1908v2 [q-bio.SC] + https://arxiv.org/abs/0704.1908 + [2] A general method for numerically simulating the stochastic time - evolution of coupled chemical reactions. Gillespie, Daniel (1976). + evolution of coupled chemical reactions. Gillespie (1976). Journal of Computational Physics + https://doi.org/10.1016/0021-9991(76)90041-3 *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. """ - def __init__(self, initial_concentration=20): + def __init__(self, initial_molecule_count=20): super(StochasticDegradationModel, self).__init__() - self._n0 = float(initial_concentration) + self._n0 = float(initial_molecule_count) if self._n0 < 0: - raise ValueError('Initial concentration cannot be negative.') - - self._interp_func = None - self._mol_count = [] - self._time = [] + raise ValueError('Initial molecule count cannot be negative.') def n_parameters(self): """ See :meth:`pints.ForwardModel.n_parameters()`. """ @@ -85,36 +85,38 @@ def simulate(self, parameters, times): if self._n0 == 0: return np.zeros(times.shape) + # Initial time and count t = 0 a = self._n0 - self._mol_count = [a] - self._time = [t] # Run stochastic degradation algorithm, calculating time until next # reaction and decreasing concentration by 1 at that time + mol_count = [a] + time = [t] while a > 0: r = np.random.uniform(0, 1) - t += (1 / (a * k)) * np.log(1 / r) - self._time.append(t) + t += -np.log(r) / (a * k) a = a - 1 - self._mol_count.append(a) + time.append(t) + mol_count.append(a) # Interpolate as step function, decreasing mol_count by 1 at each # reaction time point - self._interp_func = interp1d(self._time, self._mol_count, - kind='previous') + interp_func = interp1d(time, mol_count, kind='previous') # Compute concentration values at given time points using f1 # at any time beyond the last reaction, concentration = 0 - values = self._interp_func(times[np.where(times <= max(self._time))]) - zero_vector = np.zeros(len(times[np.where(times > max(self._time))])) + values = interp_func(times[np.where(times <= time[-1])]) + zero_vector = np.zeros(len(times[np.where(times > time[-1])])) values = np.concatenate((values, zero_vector)) return values def mean(self, parameters, times): - """ Calculates deterministic mean of infinitely many stochastic - simulations, which follows :math:: n0*exp(-kt)""" + r""" + Returns the deterministic mean of infinitely many stochastic + simulations, which follows :math:`A(0) \exp(-kt)`. + """ parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') @@ -131,8 +133,10 @@ def mean(self, parameters, times): return mean def variance(self, parameters, times): - """ Calculates deterministic variance of infinitely many stochastic - simulations, which follows :math:: exp(-2kt)(-1 + exp(kt)) * n0""" + r""" + Returns the deterministic variance of infinitely many stochastic + simulations, which follows :math:`\exp(-2kt)(-1 + \exp(kt))A(0)`. + """ parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') From fcf3242111a22e27f553d3827a8cabd0ee51ef00 Mon Sep 17 00:00:00 2001 From: Michael Clerx Date: Sat, 31 Aug 2019 11:35:07 +0100 Subject: [PATCH 50/56] Tiny style changes --- .../test_toy_stochastic_degradation_model.py | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 77d549184..3c1e093d4 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -99,26 +99,20 @@ def test_errors(self): times = np.linspace(0, 100, 101) parameters = [-0.1] self.assertRaises(ValueError, model.simulate, parameters, times) - self.assertRaises(ValueError, model.mean, parameters, - times) - self.assertRaises(ValueError, model.variance, parameters, - times) + self.assertRaises(ValueError, model.mean, parameters, times) + self.assertRaises(ValueError, model.variance, parameters, times) times_2 = np.linspace(-10, 10, 21) parameters_2 = [0.1] self.assertRaises(ValueError, model.simulate, parameters_2, times_2) - self.assertRaises(ValueError, model.mean, parameters_2, - times_2) - self.assertRaises(ValueError, model.variance, - parameters_2, times_2) + self.assertRaises(ValueError, model.mean, parameters_2, times_2) + self.assertRaises(ValueError, model.variance, parameters_2, times_2) # this model should have 1 parameter parameters_3 = [0.1, 1] self.assertRaises(ValueError, model.simulate, parameters_3, times) - self.assertRaises(ValueError, model.mean, parameters_3, - times) - self.assertRaises(ValueError, model.variance, - parameters_3, times) + self.assertRaises(ValueError, model.mean, parameters_3, times) + self.assertRaises(ValueError, model.variance, parameters_3, times) # Initial value can't be negative self.assertRaises(ValueError, pints.toy.StochasticDegradationModel, -1) From bbb866706ac7392d4c0c39e126a809523c97a182 Mon Sep 17 00:00:00 2001 From: Michael Clerx Date: Sat, 31 Aug 2019 11:41:45 +0100 Subject: [PATCH 51/56] Updated docs in stoch degrad model. --- pints/tests/test_toy_stochastic_degradation_model.py | 6 +++--- pints/toy/_stochastic_degradation_model.py | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 3c1e093d4..e98e347fc 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -19,7 +19,7 @@ class TestStochasticDegradation(unittest.TestCase): """ def test_start_with_zero(self): - # Test the special case where the initial concentration is zero + # Test the special case where the initial molecule count is zero from pints.toy import StochasticDegradationModel model = StochasticDegradationModel(0) times = [0, 1, 2, 100, 1000] @@ -60,8 +60,8 @@ def test_simulate(self): # Test interpolation function # Check exact time points from stochastic simulation - self.assertTrue(np.all(model._interp_func(model._time) == - model._mol_count)) + self.assertTrue( + np.all(model._interp_func(model._time) == model._mol_count)) # Check simulate function returns expected values self.assertTrue(np.all(values[np.where(times < model._time[1])] == 20)) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index fd1b715ee..dc3ecb898 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -90,7 +90,7 @@ def simulate(self, parameters, times): a = self._n0 # Run stochastic degradation algorithm, calculating time until next - # reaction and decreasing concentration by 1 at that time + # reaction and decreasing molecule count by 1 at that time mol_count = [a] time = [t] while a > 0: @@ -104,8 +104,8 @@ def simulate(self, parameters, times): # reaction time point interp_func = interp1d(time, mol_count, kind='previous') - # Compute concentration values at given time points using f1 - # at any time beyond the last reaction, concentration = 0 + # Compute molecule count values at given time points using f1 + # at any time beyond the last reaction, molecule count = 0 values = interp_func(times[np.where(times <= time[-1])]) zero_vector = np.zeros(len(times[np.where(times > time[-1])])) values = np.concatenate((values, zero_vector)) From dac06749f431bade3eaee7c21e7ce1b383cdfe6f Mon Sep 17 00:00:00 2001 From: ben18785 Date: Sat, 31 Aug 2019 12:58:39 +0100 Subject: [PATCH 52/56] Changes to notebook and tests --- docs/source/toy/index.rst | 6 ++---- examples/toy-model-stochastic-degradation.ipynb | 17 ++++++----------- .../test_toy_stochastic_degradation_model.py | 8 +++----- pints/toy/_stochastic_degradation_model.py | 14 +++++++------- 4 files changed, 18 insertions(+), 27 deletions(-) diff --git a/docs/source/toy/index.rst b/docs/source/toy/index.rst index 361782d98..139760752 100644 --- a/docs/source/toy/index.rst +++ b/docs/source/toy/index.rst @@ -30,10 +30,8 @@ Some toy classes provide extra functionality defined in the parabolic_error repressilator_model rosenbrock - sir_model simple_egg_box_logpdf + sir_model + stochastic_degradation_model toy_classes twisted_gaussian_logpdf - stochastic_degradation_model - - diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index 332c0f039..d4a893f97 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -12,7 +12,7 @@ " $$A \\xrightarrow{\\text{k}} \\emptyset$$\n", "\n", "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)\n", - " 1. Sample a random value r from a uniform distribution: $r \\sim uniform(0,1)$\n", + " 1. Sample a random value r from a uniform distribution: $r \\sim \\text{uniform}(0,1)$\n", " 2. Calculate the time ($\\tau$) until the next single reaction as follows (Erban et al., 2007):\n", " $$ \\tau = \\frac{1}{A(t)k} \\ln{\\big[\\frac{1}{r}\\big]} $$\n", " 3. Update the molecule count at time t + $\\tau$ as: $ A(t + \\tau) = A(t) - 1 $\n", @@ -23,7 +23,9 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "import pints\n", @@ -103,7 +105,7 @@ " values = model.simulate(k, times)\n", " plt.step(times, values)\n", "\n", - "mean = model.deterministic_mean(k, times)\n", + "mean = model.mean(k, times)\n", " \n", "plt.plot(times, mean, label = 'deterministic mean of A(t)')\n", "plt.title('stochastic degradation across different iterations')\n", @@ -152,13 +154,6 @@ "plt.ylabel('concentration (A(t))')\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -177,7 +172,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.6.3" } }, "nbformat": 4, diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index e98e347fc..5d51a0e7d 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -37,16 +37,14 @@ def test_start_with_twenty(self): self.assertEqual(len(values), len(times)) self.assertEqual(values[0], 20) self.assertEqual(values[-1], 0) + self.assertTrue(values[1:] <= values[:-1]) def test_suggested(self): model = pints.toy.StochasticDegradationModel(20) times = model.suggested_times() parameters = model.suggested_parameters() - self.assertTrue(np.all(times == np.linspace(0, 100, 101))) - self.assertEqual(parameters, 0.1) - values = model.simulate(parameters, times) - self.assertEqual(values[0], 20) - self.assertEqual(values[-1], 0) + self.assertTrue(len(times) == 101) + self.assertTrue(parameters > 0) def test_simulate(self): model = pints.toy.StochasticDegradationModel(20) diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index dc3ecb898..d6969c7e2 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -91,23 +91,23 @@ def simulate(self, parameters, times): # Run stochastic degradation algorithm, calculating time until next # reaction and decreasing molecule count by 1 at that time - mol_count = [a] - time = [t] + self._mol_count = [a] + self._time = [t] while a > 0: r = np.random.uniform(0, 1) t += -np.log(r) / (a * k) a = a - 1 - time.append(t) - mol_count.append(a) + self._time.append(t) + self._mol_count.append(a) # Interpolate as step function, decreasing mol_count by 1 at each # reaction time point - interp_func = interp1d(time, mol_count, kind='previous') + interp_func = interp1d(self._time, self._mol_count, kind='previous') # Compute molecule count values at given time points using f1 # at any time beyond the last reaction, molecule count = 0 - values = interp_func(times[np.where(times <= time[-1])]) - zero_vector = np.zeros(len(times[np.where(times > time[-1])])) + values = interp_func(times[np.where(times <= self._time[-1])]) + zero_vector = np.zeros(len(times[np.where(times > self._time[-1])])) values = np.concatenate((values, zero_vector)) return values From 29df351576b8212ae6970358e507e19240a752dd Mon Sep 17 00:00:00 2001 From: ben18785 Date: Sat, 31 Aug 2019 14:39:53 +0100 Subject: [PATCH 53/56] Created intepolation function --- .../test_toy_stochastic_degradation_model.py | 31 ++++++------ pints/toy/_stochastic_degradation_model.py | 48 +++++++++++++------ 2 files changed, 47 insertions(+), 32 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 5d51a0e7d..e94073292 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -11,16 +11,16 @@ import numpy as np import pints import pints.toy +from pints.toy import StochasticDegradationModel +from scipy.interpolate import interp1d class TestStochasticDegradation(unittest.TestCase): """ Tests if the stochastic degradation (toy) model works. """ - def test_start_with_zero(self): # Test the special case where the initial molecule count is zero - from pints.toy import StochasticDegradationModel model = StochasticDegradationModel(0) times = [0, 1, 2, 100, 1000] parameters = [0.1] @@ -47,28 +47,25 @@ def test_suggested(self): self.assertTrue(parameters > 0) def test_simulate(self): - model = pints.toy.StochasticDegradationModel(20) - parameters = [0.1] times = np.linspace(0, 100, 101) - values = model.simulate(parameters, times) - + model = StochasticDegradationModel(20) + time, mol_count = model.simulate_raw([0.1]) + values = model.interpolate_mol_counts(time, mol_count, times) + self.assertTrue(len(time), len(mol_count)) # Test output of Gillespie algorithm - self.assertTrue(np.all(model._mol_count == + self.assertTrue(np.all(mol_count == np.array(range(20, -1, -1)))) - # Test interpolation function - # Check exact time points from stochastic simulation - self.assertTrue( - np.all(model._interp_func(model._time) == model._mol_count)) - # Check simulate function returns expected values - self.assertTrue(np.all(values[np.where(times < model._time[1])] == 20)) + self.assertTrue(np.all(values[np.where(times < time[1])] == 20)) # Check interpolation function works as expected - self.assertTrue(model._interp_func(np.random.uniform(model._time[0], - model._time[1])) == 20) - self.assertTrue(model._interp_func(np.random.uniform(model._time[1], - model._time[2])) == 19) + temp_time = np.random.uniform(time[0], time[1]) + self.assertTrue(model.interpolate_mol_counts(time, mol_count, + [temp_time])[0] == 20) + temp_time = np.random.uniform(time[1], time[2]) + self.assertTrue(model.interpolate_mol_counts(time, mol_count, + [temp_time])[0] == 19) def test_mean_variance(self): # test mean diff --git a/pints/toy/_stochastic_degradation_model.py b/pints/toy/_stochastic_degradation_model.py index d6969c7e2..22e17dd5e 100644 --- a/pints/toy/_stochastic_degradation_model.py +++ b/pints/toy/_stochastic_degradation_model.py @@ -69,8 +69,10 @@ def n_parameters(self): """ See :meth:`pints.ForwardModel.n_parameters()`. """ return 1 - def simulate(self, parameters, times): - """ See :meth:`pints.ForwardModel.simulate()`. """ + def simulate_raw(self, parameters): + """ + Returns raw times, mol counts when reactions occur + """ parameters = np.asarray(parameters) if len(parameters) != self.n_parameters(): raise ValueError('This model should have only 1 parameter.') @@ -79,37 +81,53 @@ def simulate(self, parameters, times): if k <= 0: raise ValueError('Rate constant must be positive.') - times = np.asarray(times) - if np.any(times < 0): - raise ValueError('Negative times are not allowed.') - if self._n0 == 0: - return np.zeros(times.shape) - # Initial time and count t = 0 a = self._n0 # Run stochastic degradation algorithm, calculating time until next # reaction and decreasing molecule count by 1 at that time - self._mol_count = [a] - self._time = [t] + mol_count = [a] + time = [t] while a > 0: r = np.random.uniform(0, 1) t += -np.log(r) / (a * k) a = a - 1 - self._time.append(t) - self._mol_count.append(a) + time.append(t) + mol_count.append(a) + return time, mol_count + def interpolate_mol_counts(self, time, mol_count, output_times): + """ + Takes raw times and inputs and mol counts and outputs interpolated + values at output_times + """ # Interpolate as step function, decreasing mol_count by 1 at each # reaction time point - interp_func = interp1d(self._time, self._mol_count, kind='previous') + interp_func = interp1d(time, mol_count, kind='previous') # Compute molecule count values at given time points using f1 # at any time beyond the last reaction, molecule count = 0 - values = interp_func(times[np.where(times <= self._time[-1])]) - zero_vector = np.zeros(len(times[np.where(times > self._time[-1])])) + values = interp_func(output_times[np.where(output_times <= time[-1])]) + zero_vector = np.zeros( + len(output_times[np.where(output_times > time[-1])]) + ) values = np.concatenate((values, zero_vector)) + return values + + def simulate(self, parameters, times): + """ See :meth:`pints.ForwardModel.simulate()`. """ + times = np.asarray(times) + if np.any(times < 0): + raise ValueError('Negative times are not allowed.') + if self._n0 == 0: + return np.zeros(times.shape) + + # run Gillespie + time, mol_count = self.simulate_raw(parameters) + # interpolate + values = self.interpolate_mol_counts(time, mol_count, times) return values def mean(self, parameters, times): From 9c1d885591732cacf7d61d4a08cc53283109cebe Mon Sep 17 00:00:00 2001 From: ben18785 Date: Sat, 31 Aug 2019 14:46:52 +0100 Subject: [PATCH 54/56] Changed test --- pints/tests/test_toy_stochastic_degradation_model.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index e94073292..1db0aba47 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -12,7 +12,6 @@ import pints import pints.toy from pints.toy import StochasticDegradationModel -from scipy.interpolate import interp1d class TestStochasticDegradation(unittest.TestCase): @@ -60,12 +59,12 @@ def test_simulate(self): self.assertTrue(np.all(values[np.where(times < time[1])] == 20)) # Check interpolation function works as expected - temp_time = np.random.uniform(time[0], time[1]) + temp_time = np.array(np.random.uniform(time[0], time[1])) self.assertTrue(model.interpolate_mol_counts(time, mol_count, - [temp_time])[0] == 20) - temp_time = np.random.uniform(time[1], time[2]) + temp_time)[0] == 20) + temp_time = np.array(np.random.uniform(time[1], time[2])) self.assertTrue(model.interpolate_mol_counts(time, mol_count, - [temp_time])[0] == 19) + temp_time)[0] == 19) def test_mean_variance(self): # test mean From 3a943291836f45c944ce7d2a933f183efb6bfd5e Mon Sep 17 00:00:00 2001 From: ben18785 Date: Sat, 31 Aug 2019 14:49:20 +0100 Subject: [PATCH 55/56] Update test_toy_stochastic_degradation_model.py --- pints/tests/test_toy_stochastic_degradation_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index 1db0aba47..f896bfa4e 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -36,7 +36,7 @@ def test_start_with_twenty(self): self.assertEqual(len(values), len(times)) self.assertEqual(values[0], 20) self.assertEqual(values[-1], 0) - self.assertTrue(values[1:] <= values[:-1]) + self.assertTrue(np.all(values[1:] <= values[:-1])) def test_suggested(self): model = pints.toy.StochasticDegradationModel(20) From 478738592aee5063ccc3210160f7a11a5d11c5ed Mon Sep 17 00:00:00 2001 From: ben18785 Date: Sat, 31 Aug 2019 17:52:44 +0100 Subject: [PATCH 56/56] Updated tests --- .../toy-model-stochastic-degradation.ipynb | 36 ++++++++----------- .../test_toy_stochastic_degradation_model.py | 4 +-- 2 files changed, 17 insertions(+), 23 deletions(-) diff --git a/examples/toy-model-stochastic-degradation.ipynb b/examples/toy-model-stochastic-degradation.ipynb index d4a893f97..53709be67 100644 --- a/examples/toy-model-stochastic-degradation.ipynb +++ b/examples/toy-model-stochastic-degradation.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": { "collapsed": true }, @@ -44,19 +44,17 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEKCAYAAAAB0GKPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -84,19 +82,17 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEWCAYAAAB1xKBvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDGOMMSX5f19JBwVJixKmAAAAAElFTkSuQmCC\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -125,25 +121,23 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEKCAYAAAAB0GKPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nlFJKdYoGDKWUUp3y/44wXxLnlmdMAAAAAElFTkSuQmCC\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "mean = model.deterministic_mean(k, times)\n", - "variance = model.deterministic_variance(k, times)\n", + "mean = model.mean(k, times)\n", + "variance = model.variance(k, times)\n", "std_dev = np.sqrt(variance)\n", "\n", "plt.plot(times, mean, '-', label = 'deterministic mean of A(t)')\n", diff --git a/pints/tests/test_toy_stochastic_degradation_model.py b/pints/tests/test_toy_stochastic_degradation_model.py index f896bfa4e..4e00cf74a 100755 --- a/pints/tests/test_toy_stochastic_degradation_model.py +++ b/pints/tests/test_toy_stochastic_degradation_model.py @@ -59,10 +59,10 @@ def test_simulate(self): self.assertTrue(np.all(values[np.where(times < time[1])] == 20)) # Check interpolation function works as expected - temp_time = np.array(np.random.uniform(time[0], time[1])) + temp_time = np.array([np.random.uniform(time[0], time[1])]) self.assertTrue(model.interpolate_mol_counts(time, mol_count, temp_time)[0] == 20) - temp_time = np.array(np.random.uniform(time[1], time[2])) + temp_time = np.array([np.random.uniform(time[1], time[2])]) self.assertTrue(model.interpolate_mol_counts(time, mol_count, temp_time)[0] == 19)