From 487ec5b07c64100412c431ce886823df0d8b7b21 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Fri, 29 Oct 2021 16:56:37 +0100 Subject: [PATCH 01/41] Docs + boilerplate code --- docs/source/abc_samplers/base_class.rst | 8 +++ docs/source/abc_samplers/index.rst | 7 ++ docs/source/index.rst | 1 + pints/_abc/__init__.py | 92 +++++++++++++++++++++++++ 4 files changed, 108 insertions(+) create mode 100644 docs/source/abc_samplers/base_class.rst create mode 100644 docs/source/abc_samplers/index.rst create mode 100644 pints/_abc/__init__.py diff --git a/docs/source/abc_samplers/base_class.rst b/docs/source/abc_samplers/base_class.rst new file mode 100644 index 0000000000..e70b022bb8 --- /dev/null +++ b/docs/source/abc_samplers/base_class.rst @@ -0,0 +1,8 @@ +********************** +ABC sampler base class +********************** + +.. currentmodule:: pints + +.. autoclass:: ABCSampler +.. autoclass:: ABCController \ No newline at end of file diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst new file mode 100644 index 0000000000..61d7e39427 --- /dev/null +++ b/docs/source/abc_samplers/index.rst @@ -0,0 +1,7 @@ +************ +ABC samplers +************ + +.. toctree:: + + base_class \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index 38d9e9e23b..7dfb4af325 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -23,6 +23,7 @@ Contents .. toctree:: + abc_samplers/index boundaries core_classes_and_methods diagnostics diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py new file mode 100644 index 0000000000..6a21c7b633 --- /dev/null +++ b/pints/_abc/__init__.py @@ -0,0 +1,92 @@ + + +class ABCSampler(pints.Loggable, pints.TunableMethod): + """ + Bla bla bla + """ + + def name(self): + """ + Something Something + """ + raise NotImplementedError + + def ask(self): + """ + Something Something + """ + raise NotImplementedError + + def tell(self, x): + """ + Something Something + """ + raise NotImplementedError + + +# First do the interface i guess +class ABCController(object): + """ + Explanations + """ + + + def set_log_interval(self, iters=20, warm_up=3): + iters = int(iters) + if iters < 1: + raise ValueError("Interval must be greater than 0") + + warm_up = max(0, int(warm_up)) + self._message_interval = iters + self._message_warm_up = warm_up + + def set_log_to_file(self, filename=None, csv=False): + if filename: + self._log_filename = str(filename) + self._log_csv = True if csv else False + else: + self._log_filename = None + self._log_csv = False + + def set_log_to_screen(self, enabled): + self._log_to_screen = True if enabled else False + + def max_iterations(self): + return self._max_iterations + + def n_target(self): + return self._n_target + + def parallel(self): + return self._n_workers if self._parallel else False + + def run(self): + print("main logic here") + + def log_filename(self): + return self._log_filename + + def sampler(self): + return self._sampler + + def set_max_iterations(self, iterations=10000): + if iterations is None: + iterations = int(iterations) + if iterations < 0: + raise ValueError('Maximum number of iterations cannot be negative.') + self._max_iterations = iterations + + def set_nr_samples(self, n_samples=500): + self._n_samples = n_samples + + def set_parallel(self, parallel=False): + if parallel is True: + self._n_workers = int(parallel) + self._parallel = True + + elif parallel >= 1: + self._parallel = True + self._n_workers = int(parallel) + else + self._parallel = False + self._n_workers = 1 From 4eae8b958612ed5b31c9c5ee819da7d602d15ee7 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 00:24:25 +0000 Subject: [PATCH 02/41] Added rejection ABC + ipynb --- .../{base_class.rst => base_classes.rst} | 2 + docs/source/abc_samplers/index.rst | 3 +- docs/source/abc_samplers/rejection_abc.rst | 7 + docs/source/index.rst | 6 +- examples/README.md | 3 + examples/sampling/rejection-abc.ipynb | 155 ++++++++++ pints/__init__.py | 9 + pints/_abc/__init__.py | 284 +++++++++++++++++- pints/_abc/_abc_rejection.py | 82 +++++ 9 files changed, 533 insertions(+), 18 deletions(-) rename docs/source/abc_samplers/{base_class.rst => base_classes.rst} (98%) create mode 100644 docs/source/abc_samplers/rejection_abc.rst create mode 100644 examples/sampling/rejection-abc.ipynb create mode 100644 pints/_abc/_abc_rejection.py diff --git a/docs/source/abc_samplers/base_class.rst b/docs/source/abc_samplers/base_classes.rst similarity index 98% rename from docs/source/abc_samplers/base_class.rst rename to docs/source/abc_samplers/base_classes.rst index e70b022bb8..58473c7658 100644 --- a/docs/source/abc_samplers/base_class.rst +++ b/docs/source/abc_samplers/base_classes.rst @@ -4,5 +4,7 @@ ABC sampler base class .. currentmodule:: pints + .. autoclass:: ABCSampler + .. autoclass:: ABCController \ No newline at end of file diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst index 61d7e39427..7d6a74487c 100644 --- a/docs/source/abc_samplers/index.rst +++ b/docs/source/abc_samplers/index.rst @@ -4,4 +4,5 @@ ABC samplers .. toctree:: - base_class \ No newline at end of file + base_classes + rejection_abc \ No newline at end of file diff --git a/docs/source/abc_samplers/rejection_abc.rst b/docs/source/abc_samplers/rejection_abc.rst new file mode 100644 index 0000000000..4bbf4632a4 --- /dev/null +++ b/docs/source/abc_samplers/rejection_abc.rst @@ -0,0 +1,7 @@ +********************* +Rejection ABC sampler +********************* + +.. currentmodule:: pints + +.. autoclass:: RejectionABC \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index 7dfb4af325..9aa8e6e15c 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -78,10 +78,10 @@ Sampling - SMC -#. Likelihood free sampling (Need distance between data and states, e.g. least squares?) +#. :class:`ABC sampling` - - ABC-MCMC - - ABC-SMC + - :class:`RejectionABC`, requires a :class:`LogPrior` that can be sampled + from and an error measure. #. 1st order sensitivity MCMC samplers (Need derivatives of :class:`LogPDF`) diff --git a/examples/README.md b/examples/README.md index dcd063b8a6..84b4f4e423 100644 --- a/examples/README.md +++ b/examples/README.md @@ -77,6 +77,9 @@ relevant code. - [Ellipsoidal nested sampling](./sampling/nested-ellipsoidal-sampling.ipynb) - [Rejection nested sampling](./sampling/nested-rejection-sampling.ipynb) +### ABC +- [Rejection ABC sampling](./sampling/rejection-abc.ipynb) + ### Analysing sampling results - [Autocorrelation](./plotting/mcmc-autocorrelation.ipynb) - [Customise analysis plots](./plotting/customise-pints-plots.ipynb) diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb new file mode 100644 index 0000000000..7fa0a61aa5 --- /dev/null +++ b/examples/sampling/rejection-abc.ipynb @@ -0,0 +1,155 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rejection ABC\n", + "This example shows you how to perform rejection ABC on a time series from the stochastic degradation model.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pints\n", + "import pints.toy as toy\n", + "import pints.plot\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Load a forward model\n", + "model = toy.StochasticDegradationModel()\n", + "\n", + "# Create some toy data\n", + "real_parameters = model.suggested_parameters()\n", + "times = np.linspace(0, 10, 100)\n", + "values = model.simulate(real_parameters, times)\n", + "\n", + "# Create an object with links to the model and time series\n", + "problem = pints.SingleOutputProblem(model, times, values)\n", + "\n", + "# Create a uniform prior parameter\n", + "log_prior = pints.UniformLogPrior([0.0], [0.3])\n", + "\n", + "\n", + "# Set the error measure to be used to compare simulated to observed data\n", + "error_measure = pints.RootMeanSquaredError(problem)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fit using Rejection ABC" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Rejection ABC\n", + "Running in sequential mode.\n", + "Iter. Eval. Acceptance rate Time m:s\n", + "1 40 0.025 0:00.0\n", + "2 56 0.0357142857 0:00.0\n", + "3 84 0.0357142857 0:00.0\n", + "20 879 0.0227531286 0:00.3\n", + "40 1864 0.0214592275 0:00.6\n", + "60 2591 0.0231570822 0:00.8\n", + "80 3392 0.0235849057 0:01.0\n", + "100 4361 0.0229305205 0:01.3\n", + "120 5177 0.0231794476 0:01.5\n", + "140 6446 0.0217188954 0:01.8\n", + "160 7379 0.0216831549 0:02.0\n", + "180 8424 0.0213675214 0:02.3\n", + "200 9347 0.0213972398 0:02.6\n", + "Halting: target number of samples (200) reached.\n", + "Done\n" + ] + } + ], + "source": [ + "abc = pints.ABCController(error_measure, log_prior)\n", + "\n", + "# set threshold\n", + "abc.sampler().set_threshold(1)\n", + "\n", + "# set target number of samples\n", + "abc.set_nr_samples(200)\n", + "\n", + "# log to screen\n", + "abc.set_log_to_screen(True)\n", + "\n", + "print('Running...')\n", + "samples = abc.run()\n", + "print('Done')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot approximate posterior vs actual parameter value" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(samples[:,0], color=\"blue\", label=\"Samples\")\n", + "plt.vlines(x=model.suggested_parameters(), linestyles='dashed', ymin=0, ymax=50, label=\"Actual value\", color=\"red\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" + }, + "kernelspec": { + "display_name": "Python 3.8.0 32-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pints/__init__.py b/pints/__init__.py index df559710be..a337d3313e 100644 --- a/pints/__init__.py +++ b/pints/__init__.py @@ -242,6 +242,15 @@ def version(formatted=False): # from ._sample_initial_points import sample_initial_points +# +# ABC +# + +from ._abc import ABCSampler +from ._abc import ABCController +from ._abc._abc_rejection import RejectionABC + + # # Transformations # diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py index 6a21c7b633..a86f500fdd 100644 --- a/pints/_abc/__init__.py +++ b/pints/_abc/__init__.py @@ -1,46 +1,151 @@ +# +# Sub-module containing ABC inference routines +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import pints +import numpy as np +import pints class ABCSampler(pints.Loggable, pints.TunableMethod): """ - Bla bla bla + Abstract base class for ABC methods. + All ABC samplers implement the :class:`pints.Loggable` and + :class:`pints.TunableMethod` interfaces. """ def name(self): """ - Something Something + Returns this method's full name. """ raise NotImplementedError def ask(self): """ - Something Something + Returns a parameter vector sampled from the LogPrior. """ raise NotImplementedError def tell(self, x): """ - Something Something + Performs an iteration of the ABC algorithm, using the + parameters specified by ask. + Returns the accepted parameter values, or ``None`` to indicate + that no parameters were accepted (tell allows for multiple evaluations + per iteration). """ raise NotImplementedError -# First do the interface i guess + class ABCController(object): """ - Explanations + Samples from a :class:`pints.LogPrior`. + + Properties related to the number of iterations, parallelisation, + threshold, and number of parameters to sample can be set directly on the + ``ABCController`` object, e.g.:: + + abc.set_max_iterations(1000) + + Finally, to run an ABC routine, call:: + + posterior_estimate = abc.run() + + Constructor arguments: + ``error_measure`` + An error measure to evaluate on a problem, given a forward model, + simulated and observed data, and times + + ``log_prior`` + A :class:`LogPrior` function from which parameter values are sampled + + ``method`` + The class of :class:`ABCSampler` to use. If no method is specified, + :class:`RejectionABC` is used. """ + def __init__(self, error_measure, log_prior, method=None): + + # Store function + if not isinstance(log_prior, pints.LogPrior): + raise ValueError('Given function must extend pints.LogPrior.') + self._log_prior = log_prior + + # Check error_measure + # if not isinstance(error_measure, pints.ErrorMeasure): + # raise ValueError('Given error_measure must extend + # pints.ErrorMeasure') + self._error_measure = error_measure + + # Check if number of parameters from prior matches that of error + # measure + if self._log_prior.n_parameters() != \ + self._error_measure.n_parameters(): + raise ValueError('Number of parameters in prior must match number ' + 'of parameters in model.') + + # Get number of parameters + self._n_parameters = self._log_prior.n_parameters() + + # Set rejection ABC as default method + if method is None: + method = pints.RejectionABC + else: + try: + ok = issubclass(method, ABCSampler) + except TypeError: # Not a class + ok = False + if not ok: + raise ValueError('Given method must extend ABCSampler.') + + # Initialisation + self._parallel = False + self._n_workers = 1 + self._max_iterations = 10000 + self._nr_samples = 500 + self._sampler = method(log_prior) + self._log_to_screen = True + self._log_filename = None + self._log_csv = False + self.set_log_interval() + self._acceptance_rate = 0 + def set_log_interval(self, iters=20, warm_up=3): + """ + Changes the frequency with which messages are logged. + + Arguments: + + ``interval`` + A log message will be shown every ``iters`` iterations. + ``warm_up`` + A log message will be shown every iteration, for the first + ``warm_up`` iterations. + """ iters = int(iters) if iters < 1: - raise ValueError("Interval must be greater than 0") + raise ValueError("Interval must be greater than 0.") warm_up = max(0, int(warm_up)) self._message_interval = iters self._message_warm_up = warm_up def set_log_to_file(self, filename=None, csv=False): + """ + Enables progress logging to file when a filename is passed in, disables + it if ``filename`` is ``False`` or ``None``. + + The argument ``csv`` can be set to ``True`` to write the file in comma + separated value (CSV) format. By default, the file contents will be + similar to the output on screen. + """ if filename: self._log_filename = str(filename) self._log_csv = True if csv else False @@ -49,37 +154,188 @@ def set_log_to_file(self, filename=None, csv=False): self._log_csv = False def set_log_to_screen(self, enabled): + """ + Enables or disables progress logging to screen. + """ self._log_to_screen = True if enabled else False def max_iterations(self): + """ + Returns the maximum iterations if this stopping criterion is set, or + ``None`` if it is not. See :meth:`set_max_iterations()`. + """ return self._max_iterations - def n_target(self): - return self._n_target + def nr_samples(self): + """ + Returns the target number of samples to obtain in the estimated + posterior. + """ + return self._nr_samples def parallel(self): + """ + Returns the number of parallel worker processes this routine will be + run on, or ``False`` if parallelisation is disabled. + """ return self._n_workers if self._parallel else False def run(self): - print("main logic here") - + """ + Runs the ABC sampler. + """ + if self._max_iterations is None: + raise ValueError("At least one stopping criterion must be set.") + + has_stopping_criterion = self._max_iterations + + # Iteration and evaluation counting + iteration = 0 + evaluations = 0 + accepted_count = 0 + + # Choose method to evaluate + f = self._error_measure + + # Create evaluator + if self._parallel: + n_workers = self._n_workers + evaluator = pints.ParallelEvaluator(f, n_workers=n_workers) + else: + evaluator = pints.SequentialEvaluator(f) + + # Set up progress reporting + next_message = 0 + + # Start logging + logging = self._log_to_screen or self._log_filename + if logging: + if self._log_to_screen: + print('Using ' + str(self._sampler.name())) + if self._parallel: + print('Running in parallel with ' + str(n_workers) + + ' worker processess.') + else: + print('Running in sequential mode.') + + # Set up logger + logger = pints.Logger() + if not self._log_to_screen: + logger.set_stream(None) + if self._log_filename: + logger.set_filename(self._log_filename, csv=self._log_csv) + + # Add fields to log + max_iter_guess = max(self._max_iterations or 0, 10000) + max_eval_guess = max_iter_guess + logger.add_counter('Iter.', max_value=max_iter_guess) + logger.add_counter('Eval.', max_value=max_eval_guess) + logger.add_float('Acceptance rate') + self._sampler._log_init(logger) + logger.add_time('Time m:s') + + # Start sampling + timer = pints.Timer() + running = True + + samples = [] + # Sample until we find an acceptable sample + while running: + accepted_vals = None + while accepted_vals is None: + # Get points from prior + xs = self._sampler.ask(self._n_workers) + + # Simulate and get error + fxs = evaluator.evaluate(xs) + evaluations += self._n_workers + + # Tell sampler errors and get list of acceptable parameters + accepted_vals = self._sampler.tell(fxs) + + accepted_count += len(accepted_vals) + for val in accepted_vals: + samples.append(val) + + iteration += 1 + + # Log progress + if logging and iteration >= next_message: + # Log state + logger.log(iteration, evaluations, ( + accepted_count / evaluations)) + self._sampler._log_write(logger) + logger.log(timer.time()) + + # Choose next logging point + if iteration < self._message_warm_up: + next_message = iteration + 1 + else: + next_message = self._message_interval * ( + 1 + iteration // self._message_interval) + + if iteration >= self._max_iterations: + running = False + halt_message = ('Halting: Maximum number of iterations (' + + str(iteration) + ') reached.') + elif accepted_count >= self._nr_samples: + running = False + halt_message = ('Halting: target number of samples (' + + str(accepted_count) + ') reached.') + + # Log final state and show halt message + if logging: + logger.log(iteration, evaluations) + self._sampler._log_write(logger) + logger.log(timer.time()) + if self._log_to_screen: + print(halt_message) + samples = np.array(samples) + return samples + def log_filename(self): + """ + Returns log filename. + """ return self._log_filename def sampler(self): + """ + Returns the underlying sampler object. + """ return self._sampler def set_max_iterations(self, iterations=10000): + """ + Adds a stopping criterion, allowing the routine to halt after the + given number of `iterations`. + + This criterion is enabled by default. To disable it, use + `set_max_iterations(None)`. + """ if iterations is None: iterations = int(iterations) if iterations < 0: raise ValueError('Maximum number of iterations cannot be negative.') self._max_iterations = iterations - def set_nr_samples(self, n_samples=500): - self._n_samples = n_samples + def set_nr_samples(self, nr_samples=500): + """ + Sets a target number of samples + """ + self._nr_samples = nr_samples def set_parallel(self, parallel=False): + """ + Enables/disables parallel evaluation. + + If ``parallel=True``, the method will run using a number of worker + processes equal to the detected cpu core count. The number of workers + can be set explicitly by setting ``parallel`` to an integer greater + than 0. + Parallelisation can be disabled by setting ``parallel`` to ``0`` or + ``False``. + """ if parallel is True: self._n_workers = int(parallel) self._parallel = True @@ -87,6 +343,6 @@ def set_parallel(self, parallel=False): elif parallel >= 1: self._parallel = True self._n_workers = int(parallel) - else + else: self._parallel = False self._n_workers = 1 diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py new file mode 100644 index 0000000000..b3676ee1fd --- /dev/null +++ b/pints/_abc/_abc_rejection.py @@ -0,0 +1,82 @@ +# +# ABC Rejection method +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +from __future__ import absolute_import, division +from __future__ import print_function, unicode_literals +import pints +import numpy as np + + +class RejectionABC(pints.ABCSampler): + """ + Implements the rejection ABC algorithm as described in [1]. + Here is a high-level description of the algorithm: + theta* ~ p(theta), i.e. sample parameters from prior distribution + x ~ p(x|theta*), i.e. sample data from sampling distribution + if s(x) < threshold: + theta* added to list of samples + References + ---------- + .. [1] "Approximate Bayesian Computation (ABC) in practice". Katalin + Csillery, Michael G.B.Blum, Oscar E. Gaggiotti, Olivier Francois + (2010) Trends in Ecology & Evolution + https://doi.org/10.1016/j.tree.2010.04.001 + """ + def __init__(self, log_prior): + + self._log_prior = log_prior + self._threshold = 1 + self._xs = None + self._ready_for_tell = False + + def name(self): + """ See :meth:`pints.ABCSampler.name()`. """ + return 'Rejection ABC' + + def ask(self, n_samples): + """ See :meth:`ABCSampler.ask()`. """ + if self._ready_for_tell: + raise RuntimeError('Ask called before tell.') + self._xs = self._log_prior.sample(n_samples) + + self._ready_for_tell = True + return self._xs + + def tell(self, fx): + """ See :meth:`ABCSampler.tell()`. """ + if not self._ready_for_tell: + raise RuntimeError('Tell called before ask.') + self._ready_for_tell = False + if isinstance(fx, list): + accepted = [a < self._threshold for a in fx] + if np.sum(accepted) == 0: + return None + else: + return [self._xs[c].tolist() for c, x in + enumerate(accepted) if x] + else: + if fx < self._threshold: + return self._xs + else: + return None + + def threshold(self): + """ + Returns threshold error distance that determines if a sample is + accepted (is error < threshold). + """ + return self._threshold + + def set_threshold(self, threshold): + """ + Sets threshold error distance that determines if a sample is accepted + (if error < threshold). + """ + x = float(threshold) + if x <= 0: + raise ValueError('Threshold must be positive.') + self._threshold = threshold \ No newline at end of file From 8b38479cbe1f0b677ac7657e6f47114018e4e49c Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 01:06:30 +0000 Subject: [PATCH 03/41] Fixes + unit tests --- True | 4 + pints/_abc/__init__.py | 5 +- pints/tests/test_abc_controller.py | 199 +++++++++++++++++++++++++++++ pints/tests/test_abc_rejection.py | 97 ++++++++++++++ 4 files changed, 303 insertions(+), 2 deletions(-) create mode 100644 True create mode 100644 pints/tests/test_abc_controller.py create mode 100644 pints/tests/test_abc_rejection.py diff --git a/True b/True new file mode 100644 index 0000000000..d35611b277 --- /dev/null +++ b/True @@ -0,0 +1,4 @@ +Iter. Eval. Acceptance rate Time m:s +1 113 0.00884955752 0:00.0 +2 591 0.00338409475 0:00.1 +3 692 0.00433526012 0:00.2 diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py index a86f500fdd..9344c6a344 100644 --- a/pints/_abc/__init__.py +++ b/pints/_abc/__init__.py @@ -128,6 +128,7 @@ def set_log_interval(self, iters=20, warm_up=3): ``warm_up`` A log message will be shown every iteration, for the first ``warm_up`` iterations. + """ iters = int(iters) if iters < 1: @@ -313,7 +314,7 @@ def set_max_iterations(self, iterations=10000): This criterion is enabled by default. To disable it, use `set_max_iterations(None)`. """ - if iterations is None: + if iterations is not None: iterations = int(iterations) if iterations < 0: raise ValueError('Maximum number of iterations cannot be negative.') @@ -337,7 +338,7 @@ def set_parallel(self, parallel=False): ``False``. """ if parallel is True: - self._n_workers = int(parallel) + self._n_workers = pints.ParallelEvaluator.cpu_count() self._parallel = True elif parallel >= 1: diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py new file mode 100644 index 0000000000..1ae04ef0b1 --- /dev/null +++ b/pints/tests/test_abc_controller.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +# +# Tests the ABC Controller. +# +# 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 pints +import pints.toy +import unittest +import numpy as np +from shared import StreamCapture + +# Consistent unit testing in Python 2 and 3 +try: + unittest.TestCase.assertRaisesRegex +except AttributeError: + unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp + + +debug = False + + +class TestABCController(unittest.TestCase): + """ + Tests the ABCController class. + """ + + @classmethod + def setUpClass(cls): + """ Prepare problem for tests. """ + + # Create toy model + cls.model = pints.toy.StochasticDegradationModel() + cls.real_parameters = [0.1] + cls.times = np.linspace(0, 10, 10) + cls.values = cls.model.simulate(cls.real_parameters, cls.times) + + # Create an object (problem) with links to the model and time series + cls.problem = pints.SingleOutputProblem( + cls.model, cls.times, cls.values) + + # Create a uniform prior over both the parameters + cls.log_prior = pints.UniformLogPrior( + [0.0], + [0.3] + ) + + # Set error measure + cls.error_measure = pints.RootMeanSquaredError(cls.problem) + + def test_nparameters_error(self): + """ Test that error is thrown when parameters from log prior and error + measure do not match""" + log_prior = pints.UniformLogPrior( + [0.0, 0, 0], + [0.2, 100, 1]) + + self.assertRaises(ValueError, pints.ABCController, self.error_measure, + log_prior) + + def test_stopping(self): + """ Test different stopping criteria. """ + + abc = pints.ABCController(self.error_measure, self.log_prior) + + # Test setting max iterations + maxi = abc.max_iterations() + 2 + self.assertNotEqual(maxi, abc.max_iterations()) + abc.set_max_iterations(maxi) + self.assertEqual(maxi, abc.max_iterations()) + self.assertRaisesRegex( + ValueError, 'Maximum number of iterations cannot be negative.', abc.set_max_iterations, -1) + + # # Test without stopping criteria + abc.set_max_iterations(None) + self.assertIsNone(abc.max_iterations()) + self.assertRaisesRegex( + ValueError, 'At least one stopping criterion must be set.', abc.run) + + def test_parallel(self): + """ Test running ABC with parallisation. """ + + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + + # Test with auto-detected number of worker processes + self.assertFalse(abc.parallel()) + abc.set_parallel(True) + self.assertTrue(abc.parallel()) + self.assertEqual(abc.parallel(), pints.ParallelEvaluator.cpu_count()) + + # Test with fixed number of worker processes + abc.set_parallel(2) + self.assertEqual(abc.parallel(), 2) + + # def test_logging(self): + # # tests logging to screen + # # No output + # with StreamCapture() as capture: + # abc = pints.ABCController( + # self.error_measure, self.log_prior, method=pints.RejectionABC) + # abc.set_max_iterations(10) + # abc.set_log_to_screen(False) + # abc.set_log_to_file(False) + # abc.run() + # self.assertEqual(capture.text(), '') + + # # With output to screen + # np.random.seed(1) + # with StreamCapture() as capture: + # pints.ABCController( + # self.error_measure, self.log_prior, method=pints.RejectionABC) + # abc.set_max_iterations(10) + # abc.set_log_to_screen(True) + # abc.set_log_to_file(False) + # abc.run() + # lines = capture.text().splitlines() + # self.assertTrue(len(lines) > 0) + + # # With output to screen + # np.random.seed(1) + # with StreamCapture() as capture: + # pints.ABCController( + # self.error_measure, self.log_prior, method=pints.RejectionABC) + # abc.set_max_iterations(10) + # abc.set_log_to_screen(False) + # abc.set_log_to_file(True) + # abc.run() + # lines = capture.text().splitlines() + # self.assertTrue(len(lines) == 0) + + # # Invalid log interval + # self.assertRaises(ValueError, abc.set_log_interval, 0) + + # abc = pints.ABCController( + # self.error_measure, self.log_prior, method=pints.RejectionABC) + # abc.set_log_to_file("temp_file") + # self.assertEqual(abc.log_filename(), "temp_file") + + # # tests logging to screen with parallel + # with StreamCapture() as capture: + # abc = pints.ABCController( + # self.error_measure, self.log_prior, method=pints.RejectionABC) + # abc.set_parallel(2) + # abc.set_max_iterations(10) + # abc.set_log_to_screen(False) + # abc.set_log_to_file(False) + # abc.run() + # self.assertEqual(capture.text(), '') + + def test_controller_extra(self): + # tests various controller aspects + self.assertRaises(ValueError, pints.ABCController, self.error_measure, + self.error_measure) + # self.assertRaisesRegex( + # ValueError, 'Given method must extend pints.ABCSampler', + # pints.ABCController, self.error_measure, + # self.log_prior, pints.MCMCSampler) + self.assertRaises(ValueError, pints.ABCController, self.error_measure, + pints.MCMCSampler) + self.assertRaises(ValueError, pints.ABCController, self.error_measure, + self.log_prior, 0.0) + + # test setters + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_nr_samples(230) + self.assertEqual(abc.nr_samples(), 230) + + sampler = abc.sampler() + pt = sampler.ask(1) + self.assertEqual(len(pt), 1) + + abc.set_parallel(False) + self.assertEqual(abc.parallel(), 0) + + with StreamCapture() as capture: + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_parallel(4) + abc.sampler().set_threshold(100) + abc.set_nr_samples(1) + abc.run() + lines = capture.text().splitlines() + self.assertTrue(len(lines) > 0) + self.assertTrue(True) + + +if __name__ == '__main__': + print('Add -v for more debug output') + import sys + if '-v' in sys.argv: + debug = True + unittest.main() \ No newline at end of file diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py new file mode 100644 index 0000000000..61db7ba470 --- /dev/null +++ b/pints/tests/test_abc_rejection.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python +# +# Tests the basic methods of the adaptive covariance MCMC routine. +# +# 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. +# +import pints +import pints.toy as toy +import unittest +import numpy as np + +# Consistent unit testing in Python 2 and 3 +try: + unittest.TestCase.assertRaisesRegex +except AttributeError: + unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp + + +class TestRejectionABC(unittest.TestCase): + """ + Tests the basic methods of the ABC Rejection routine. + """ +# Set up toy model, parameter values, problem, error measure + @classmethod + def setUpClass(cls): + """ Set up problem for tests. """ + + # Create toy model + cls.model = toy.StochasticDegradationModel() + cls.real_parameters = [0.1] + cls.times = np.linspace(0, 10, 10) + cls.values = cls.model.simulate(cls.real_parameters, cls.times) + + # Create an object (problem) with links to the model and time series + cls.problem = pints.SingleOutputProblem( + cls.model, cls.times, cls.values) + + # Create a uniform prior over both the parameters + cls.log_prior = pints.UniformLogPrior( + [0.0], + [0.3] + ) + + # Set error measure + cls.error_measure = pints.RootMeanSquaredError(cls.problem) + + def test_method(self): + + # Create abc rejection scheme + abc = pints.RejectionABC(self.log_prior) + + # Configure + n_draws = 1 + niter = 20 + + # Perform short run using ask and tell framework + samples = [] + while len(samples) < niter: + x = abc.ask(n_draws)[0] + fx = self.error_measure(x) + sample = abc.tell(fx) + while sample is None: + x = abc.ask(n_draws)[0] + fx = self.error_measure(x) + sample = abc.tell(fx) + samples.append(sample) + + samples = np.array(samples) + self.assertEqual(samples.shape[0], niter) + + def test_errors(self): + # test errors in abc rejection + abc = pints.RejectionABC(self.log_prior) + abc.ask(1) + # test two asks raises error + self.assertRaises(RuntimeError, abc.ask, 1) + + # test tell with large value + self.assertEqual(None, abc.tell(100)) + # test error raised if tell called before ask + self.assertRaises(RuntimeError, abc.tell, 2.5) + + def test_setters_and_getters(self): + # test setting and getting + abc = pints.RejectionABC(self.log_prior) + self.assertEqual('Rejection ABC', abc.name()) + self.assertEqual(abc.threshold(), 1) + abc.set_threshold(2) + self.assertEqual(abc.threshold(), 2) + self.assertRaises(ValueError, abc.set_threshold, -3) + + +if __name__ == '__main__': + unittest.main() \ No newline at end of file From ff6bcca05386366a501dd8b7a6ee47367c77d33c Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 01:29:48 +0000 Subject: [PATCH 04/41] fixed tests + flake8 --- True | 6 +- pints/_abc/__init__.py | 30 +++---- pints/_abc/_abc_rejection.py | 2 +- pints/tests/test_abc_controller.py | 126 +++++++++++++++-------------- pints/tests/test_abc_rejection.py | 2 +- 5 files changed, 83 insertions(+), 83 deletions(-) diff --git a/True b/True index d35611b277..2819384cf5 100644 --- a/True +++ b/True @@ -1,4 +1,4 @@ Iter. Eval. Acceptance rate Time m:s -1 113 0.00884955752 0:00.0 -2 591 0.00338409475 0:00.1 -3 692 0.00433526012 0:00.2 +1 173 0.00578034682 0:00.0 +2 465 0.00430107527 0:00.1 +3 493 0.0060851927 0:00.1 diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py index 9344c6a344..a62b725e46 100644 --- a/pints/_abc/__init__.py +++ b/pints/_abc/__init__.py @@ -10,7 +10,6 @@ import pints import numpy as np -import pints class ABCSampler(pints.Loggable, pints.TunableMethod): """ @@ -42,26 +41,25 @@ def tell(self, x): raise NotImplementedError - class ABCController(object): """ Samples from a :class:`pints.LogPrior`. - + Properties related to the number of iterations, parallelisation, threshold, and number of parameters to sample can be set directly on the ``ABCController`` object, e.g.:: - + abc.set_max_iterations(1000) - + Finally, to run an ABC routine, call:: - + posterior_estimate = abc.run() - + Constructor arguments: ``error_measure`` An error measure to evaluate on a problem, given a forward model, simulated and observed data, and times - + ``log_prior`` A :class:`LogPrior` function from which parameter values are sampled @@ -116,13 +114,12 @@ def __init__(self, error_measure, log_prior, method=None): self.set_log_interval() self._acceptance_rate = 0 - def set_log_interval(self, iters=20, warm_up=3): """ Changes the frequency with which messages are logged. Arguments: - + ``interval`` A log message will be shown every ``iters`` iterations. ``warm_up`` @@ -188,8 +185,6 @@ def run(self): if self._max_iterations is None: raise ValueError("At least one stopping criterion must be set.") - has_stopping_criterion = self._max_iterations - # Iteration and evaluation counting iteration = 0 evaluations = 0 @@ -257,10 +252,10 @@ def run(self): accepted_count += len(accepted_vals) for val in accepted_vals: samples.append(val) - + iteration += 1 - - # Log progress + + # Log progress if logging and iteration >= next_message: # Log state logger.log(iteration, evaluations, ( @@ -274,7 +269,7 @@ def run(self): else: next_message = self._message_interval * ( 1 + iteration // self._message_interval) - + if iteration >= self._max_iterations: running = False halt_message = ('Halting: Maximum number of iterations (' @@ -317,7 +312,8 @@ def set_max_iterations(self, iterations=10000): if iterations is not None: iterations = int(iterations) if iterations < 0: - raise ValueError('Maximum number of iterations cannot be negative.') + raise ValueError( + 'Maximum number of iterations cannot be negative.') self._max_iterations = iterations def set_nr_samples(self, nr_samples=500): diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index b3676ee1fd..04bb6a7a41 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -79,4 +79,4 @@ def set_threshold(self, threshold): x = float(threshold) if x <= 0: raise ValueError('Threshold must be positive.') - self._threshold = threshold \ No newline at end of file + self._threshold = threshold diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index 1ae04ef0b1..7a49d8486d 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -74,13 +74,17 @@ def test_stopping(self): abc.set_max_iterations(maxi) self.assertEqual(maxi, abc.max_iterations()) self.assertRaisesRegex( - ValueError, 'Maximum number of iterations cannot be negative.', abc.set_max_iterations, -1) + ValueError, + 'Maximum number of iterations cannot be negative.', + abc.set_max_iterations, -1) # # Test without stopping criteria abc.set_max_iterations(None) self.assertIsNone(abc.max_iterations()) self.assertRaisesRegex( - ValueError, 'At least one stopping criterion must be set.', abc.run) + ValueError, + 'At least one stopping criterion must be set.', + abc.run) def test_parallel(self): """ Test running ABC with parallisation. """ @@ -98,69 +102,69 @@ def test_parallel(self): abc.set_parallel(2) self.assertEqual(abc.parallel(), 2) - # def test_logging(self): - # # tests logging to screen - # # No output - # with StreamCapture() as capture: - # abc = pints.ABCController( - # self.error_measure, self.log_prior, method=pints.RejectionABC) - # abc.set_max_iterations(10) - # abc.set_log_to_screen(False) - # abc.set_log_to_file(False) - # abc.run() - # self.assertEqual(capture.text(), '') - - # # With output to screen - # np.random.seed(1) - # with StreamCapture() as capture: - # pints.ABCController( - # self.error_measure, self.log_prior, method=pints.RejectionABC) - # abc.set_max_iterations(10) - # abc.set_log_to_screen(True) - # abc.set_log_to_file(False) - # abc.run() - # lines = capture.text().splitlines() - # self.assertTrue(len(lines) > 0) - - # # With output to screen - # np.random.seed(1) - # with StreamCapture() as capture: - # pints.ABCController( - # self.error_measure, self.log_prior, method=pints.RejectionABC) - # abc.set_max_iterations(10) - # abc.set_log_to_screen(False) - # abc.set_log_to_file(True) - # abc.run() - # lines = capture.text().splitlines() - # self.assertTrue(len(lines) == 0) - - # # Invalid log interval - # self.assertRaises(ValueError, abc.set_log_interval, 0) - - # abc = pints.ABCController( - # self.error_measure, self.log_prior, method=pints.RejectionABC) - # abc.set_log_to_file("temp_file") - # self.assertEqual(abc.log_filename(), "temp_file") - - # # tests logging to screen with parallel - # with StreamCapture() as capture: - # abc = pints.ABCController( - # self.error_measure, self.log_prior, method=pints.RejectionABC) - # abc.set_parallel(2) - # abc.set_max_iterations(10) - # abc.set_log_to_screen(False) - # abc.set_log_to_file(False) - # abc.run() - # self.assertEqual(capture.text(), '') + def test_logging(self): + # tests logging to screen + # No output + with StreamCapture() as capture: + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_max_iterations(10) + abc.set_log_to_screen(False) + abc.set_log_to_file(False) + abc.run() + self.assertEqual(capture.text(), '') + + # With output to screen + np.random.seed(1) + with StreamCapture() as capture: + pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_max_iterations(10) + abc.set_log_to_screen(True) + abc.set_log_to_file(False) + abc.run() + lines = capture.text().splitlines() + self.assertTrue(len(lines) > 0) + + # With output to screen + np.random.seed(1) + with StreamCapture() as capture: + pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_max_iterations(10) + abc.set_log_to_screen(False) + abc.set_log_to_file(True) + abc.run() + lines = capture.text().splitlines() + self.assertTrue(len(lines) == 0) + + # Invalid log interval + self.assertRaises(ValueError, abc.set_log_interval, 0) + + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_log_to_file("temp_file") + self.assertEqual(abc.log_filename(), "temp_file") + + # tests logging to screen with parallel + with StreamCapture() as capture: + abc = pints.ABCController( + self.error_measure, self.log_prior, method=pints.RejectionABC) + abc.set_parallel(2) + abc.set_max_iterations(10) + abc.set_log_to_screen(False) + abc.set_log_to_file(False) + abc.run() + self.assertEqual(capture.text(), '') def test_controller_extra(self): # tests various controller aspects self.assertRaises(ValueError, pints.ABCController, self.error_measure, self.error_measure) - # self.assertRaisesRegex( - # ValueError, 'Given method must extend pints.ABCSampler', - # pints.ABCController, self.error_measure, - # self.log_prior, pints.MCMCSampler) + self.assertRaisesRegex( + ValueError, 'Given method must extend ABCSampler.', + pints.ABCController, self.error_measure, + self.log_prior, pints.MCMCSampler) self.assertRaises(ValueError, pints.ABCController, self.error_measure, pints.MCMCSampler) self.assertRaises(ValueError, pints.ABCController, self.error_measure, @@ -196,4 +200,4 @@ def test_controller_extra(self): import sys if '-v' in sys.argv: debug = True - unittest.main() \ No newline at end of file + unittest.main() diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py index 61db7ba470..4882310eb6 100644 --- a/pints/tests/test_abc_rejection.py +++ b/pints/tests/test_abc_rejection.py @@ -94,4 +94,4 @@ def test_setters_and_getters(self): if __name__ == '__main__': - unittest.main() \ No newline at end of file + unittest.main() From c5a8eaf53f06fb828969862deab824f543371439 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 02:24:44 +0000 Subject: [PATCH 05/41] Added copyright disclaimer --- True | 4 ---- docs/source/abc_samplers/base_classes.rst | 2 -- pints/tests/test_abc_controller.py | 7 +++---- pints/tests/test_abc_rejection.py | 7 +++---- 4 files changed, 6 insertions(+), 14 deletions(-) delete mode 100644 True diff --git a/True b/True deleted file mode 100644 index 2819384cf5..0000000000 --- a/True +++ /dev/null @@ -1,4 +0,0 @@ -Iter. Eval. Acceptance rate Time m:s -1 173 0.00578034682 0:00.0 -2 465 0.00430107527 0:00.1 -3 493 0.0060851927 0:00.1 diff --git a/docs/source/abc_samplers/base_classes.rst b/docs/source/abc_samplers/base_classes.rst index 58473c7658..e70b022bb8 100644 --- a/docs/source/abc_samplers/base_classes.rst +++ b/docs/source/abc_samplers/base_classes.rst @@ -4,7 +4,5 @@ ABC sampler base class .. currentmodule:: pints - .. autoclass:: ABCSampler - .. autoclass:: ABCController \ No newline at end of file diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index 7a49d8486d..538e328a0b 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -2,10 +2,9 @@ # # Tests the ABC Controller. # -# 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. +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. # from __future__ import absolute_import, division from __future__ import print_function, unicode_literals diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py index 4882310eb6..ef76e1fc6e 100644 --- a/pints/tests/test_abc_rejection.py +++ b/pints/tests/test_abc_rejection.py @@ -2,10 +2,9 @@ # # Tests the basic methods of the adaptive covariance MCMC routine. # -# 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. +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. # import pints import pints.toy as toy From a040e402673a513316f9e6112e11c22c694c7ae8 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 13:05:03 +0000 Subject: [PATCH 06/41] fix docs warnings --- pints/_abc/_abc_rejection.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index 04bb6a7a41..50c1bb1390 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -14,17 +14,22 @@ class RejectionABC(pints.ABCSampler): """ Implements the rejection ABC algorithm as described in [1]. + Here is a high-level description of the algorithm: + theta* ~ p(theta), i.e. sample parameters from prior distribution x ~ p(x|theta*), i.e. sample data from sampling distribution if s(x) < threshold: theta* added to list of samples + + References ---------- .. [1] "Approximate Bayesian Computation (ABC) in practice". Katalin Csillery, Michael G.B.Blum, Oscar E. Gaggiotti, Olivier Francois (2010) Trends in Ecology & Evolution https://doi.org/10.1016/j.tree.2010.04.001 + """ def __init__(self, log_prior): From 5079d72de13bbdfe7060d1e4257aa84536217242 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 13:09:22 +0000 Subject: [PATCH 07/41] fix2 for docs --- pints/_abc/_abc_rejection.py | 1 - 1 file changed, 1 deletion(-) diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index 50c1bb1390..94cfbae822 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -22,7 +22,6 @@ class RejectionABC(pints.ABCSampler): if s(x) < threshold: theta* added to list of samples - References ---------- .. [1] "Approximate Bayesian Computation (ABC) in practice". Katalin From 2f24b95fee96dc1a455e60503017c6cc19a70835 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 8 Nov 2021 13:17:19 +0000 Subject: [PATCH 08/41] final fix for docs --- pints/_abc/_abc_rejection.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index 94cfbae822..d6adce8036 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -19,8 +19,7 @@ class RejectionABC(pints.ABCSampler): theta* ~ p(theta), i.e. sample parameters from prior distribution x ~ p(x|theta*), i.e. sample data from sampling distribution - if s(x) < threshold: - theta* added to list of samples + if s(x) < threshold, theta* added to list of samples References ---------- From 77d371c98bd956cb556bfbf4b81e8b18690ddf25 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 18 Nov 2021 18:14:41 +0000 Subject: [PATCH 09/41] addressed comments --- pints/_abc/__init__.py | 85 ++++++++++++++++++------------ pints/_abc/_abc_rejection.py | 44 ++++++++-------- pints/tests/test_abc_controller.py | 15 ------ pints/tests/test_abc_rejection.py | 15 ++---- 4 files changed, 76 insertions(+), 83 deletions(-) diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py index a62b725e46..d6ea829541 100644 --- a/pints/_abc/__init__.py +++ b/pints/_abc/__init__.py @@ -5,8 +5,6 @@ # released under the BSD 3-clause license. See accompanying LICENSE.md for # copyright notice and full license details. # -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals import pints import numpy as np @@ -34,9 +32,8 @@ def tell(self, x): """ Performs an iteration of the ABC algorithm, using the parameters specified by ask. - Returns the accepted parameter values, or ``None`` to indicate - that no parameters were accepted (tell allows for multiple evaluations - per iteration). + Expects to receive x as a sequence of leangth at least 1. + Returns the accepted parameter values. """ raise NotImplementedError @@ -47,25 +44,26 @@ class ABCController(object): Properties related to the number of iterations, parallelisation, threshold, and number of parameters to sample can be set directly on the - ``ABCController`` object, e.g.:: + ``ABCController`` object. Afterwards the ABC routine can be run. + + Parameters + ---------- + error_measure + An error measure to evaluate on a problem, given a forward model, + simulated and observed data, and times + log_prior + A :class:`LogPrior` function from which parameter values are sampled + method + The class of :class:`ABCSampler` to use. If no method is specified, + :class:`RejectionABC` is used. + + Example + ------- + :: abc.set_max_iterations(1000) - - Finally, to run an ABC routine, call:: - posterior_estimate = abc.run() - Constructor arguments: - ``error_measure`` - An error measure to evaluate on a problem, given a forward model, - simulated and observed data, and times - - ``log_prior`` - A :class:`LogPrior` function from which parameter values are sampled - - ``method`` - The class of :class:`ABCSampler` to use. If no method is specified, - :class:`RejectionABC` is used. """ def __init__(self, error_measure, log_prior, method=None): @@ -76,9 +74,9 @@ def __init__(self, error_measure, log_prior, method=None): self._log_prior = log_prior # Check error_measure - # if not isinstance(error_measure, pints.ErrorMeasure): - # raise ValueError('Given error_measure must extend - # pints.ErrorMeasure') + if not isinstance(error_measure, pints.ErrorMeasure): + raise ValueError('Given error_measure must extend ' + 'pints.ErrorMeasure') self._error_measure = error_measure # Check if number of parameters from prior matches that of error @@ -86,7 +84,7 @@ def __init__(self, error_measure, log_prior, method=None): if self._log_prior.n_parameters() != \ self._error_measure.n_parameters(): raise ValueError('Number of parameters in prior must match number ' - 'of parameters in model.') + 'of parameters in error measure.') # Get number of parameters self._n_parameters = self._log_prior.n_parameters() @@ -103,29 +101,38 @@ def __init__(self, error_measure, log_prior, method=None): raise ValueError('Given method must extend ABCSampler.') # Initialisation + + # Parallelisation self._parallel = False self._n_workers = 1 + + # Maximum number of iterations as a stopping criterion self._max_iterations = 10000 + + # Maximum number of target samples to obtain + # in the estimated posterior self._nr_samples = 500 + + # The sampler object uses the prior distribution self._sampler = method(log_prior) + + # Logging self._log_to_screen = True self._log_filename = None self._log_csv = False self.set_log_interval() - self._acceptance_rate = 0 def set_log_interval(self, iters=20, warm_up=3): """ Changes the frequency with which messages are logged. - Arguments: - - ``interval`` + Parameters + ---------- + iters A log message will be shown every ``iters`` iterations. - ``warm_up`` + warm_up A log message will be shown every iteration, for the first ``warm_up`` iterations. - """ iters = int(iters) if iters < 1: @@ -234,13 +241,22 @@ def run(self): timer = pints.Timer() running = True + # Specifying the number of samples we want to get + # from the prior at once. It depends on whether we + # are using parallelisation and how many workers + # are being used. + if self._parallel: + n_requested_samples = 1 + else: + n_requested_samples = self._n_workers + samples = [] # Sample until we find an acceptable sample while running: accepted_vals = None while accepted_vals is None: # Get points from prior - xs = self._sampler.ask(self._n_workers) + xs = self._sampler.ask(n_requested_samples) # Simulate and get error fxs = evaluator.evaluate(xs) @@ -291,7 +307,8 @@ def run(self): def log_filename(self): """ - Returns log filename. + Returns the file name in which all the logs related to the + ABC routine will be stored. """ return self._log_filename @@ -304,10 +321,10 @@ def sampler(self): def set_max_iterations(self, iterations=10000): """ Adds a stopping criterion, allowing the routine to halt after the - given number of `iterations`. + given number of ``iterations``. This criterion is enabled by default. To disable it, use - `set_max_iterations(None)`. + ``set_max_iterations(None)``. """ if iterations is not None: iterations = int(iterations) diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index d6adce8036..92794ab442 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -5,26 +5,33 @@ # released under the BSD 3-clause license. See accompanying LICENSE.md for # copyright notice and full license details. # -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals import pints -import numpy as np class RejectionABC(pints.ABCSampler): - """ + r""" Implements the rejection ABC algorithm as described in [1]. Here is a high-level description of the algorithm: - theta* ~ p(theta), i.e. sample parameters from prior distribution - x ~ p(x|theta*), i.e. sample data from sampling distribution - if s(x) < threshold, theta* added to list of samples + .. math:: + \begin{align} + \theta^* &\sim p(\theta) \\ + x &\sim p(x|\theta^*) \\ + \textrm{if } s(x) < \textrm{threshold}, \textrm{then} \\ + \theta^* \textrm{ is added to list of samples} \\ + \end{align} + + In other words, the first two steps sample parameters + from the prior distribution and then sample data from the + sampling distribution (assuming the sampled parameters). + In the end, if the summary statistics are within the threshold, + we add the sampled parameters to the list of samples. References ---------- .. [1] "Approximate Bayesian Computation (ABC) in practice". Katalin - Csillery, Michael G.B.Blum, Oscar E. Gaggiotti, Olivier Francois + Csillery, Michael G.B. Blum, Oscar E. Gaggiotti, Olivier Francois (2010) Trends in Ecology & Evolution https://doi.org/10.1016/j.tree.2010.04.001 @@ -54,32 +61,23 @@ def tell(self, fx): if not self._ready_for_tell: raise RuntimeError('Tell called before ask.') self._ready_for_tell = False - if isinstance(fx, list): - accepted = [a < self._threshold for a in fx] - if np.sum(accepted) == 0: - return None - else: - return [self._xs[c].tolist() for c, x in - enumerate(accepted) if x] - else: - if fx < self._threshold: - return self._xs - else: - return None + + fx = pints.vector(fx) + return self._xs[fx < self._threshold] def threshold(self): """ Returns threshold error distance that determines if a sample is - accepted (is error < threshold). + accepted (is ``error < threshold``). """ return self._threshold def set_threshold(self, threshold): """ Sets threshold error distance that determines if a sample is accepted - (if error < threshold). + (if ``error < threshold``). """ x = float(threshold) if x <= 0: - raise ValueError('Threshold must be positive.') + raise ValueError('Threshold must be greater than zero.') self._threshold = threshold diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index 538e328a0b..90d0ebe8b3 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -6,23 +6,12 @@ # released under the BSD 3-clause license. See accompanying LICENSE.md for # copyright notice and full license details. # -from __future__ import absolute_import, division -from __future__ import print_function, unicode_literals import pints import pints.toy import unittest import numpy as np from shared import StreamCapture -# Consistent unit testing in Python 2 and 3 -try: - unittest.TestCase.assertRaisesRegex -except AttributeError: - unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp - - -debug = False - class TestABCController(unittest.TestCase): """ @@ -195,8 +184,4 @@ def test_controller_extra(self): if __name__ == '__main__': - print('Add -v for more debug output') - import sys - if '-v' in sys.argv: - debug = True unittest.main() diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py index ef76e1fc6e..94fd51bc00 100644 --- a/pints/tests/test_abc_rejection.py +++ b/pints/tests/test_abc_rejection.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Tests the basic methods of the adaptive covariance MCMC routine. +# Tests the basic methods of the ABC Rejection routine. # # This file is part of PINTS (https://github.com/pints-team/pints/) which is # released under the BSD 3-clause license. See accompanying LICENSE.md for @@ -11,18 +11,12 @@ import unittest import numpy as np -# Consistent unit testing in Python 2 and 3 -try: - unittest.TestCase.assertRaisesRegex -except AttributeError: - unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp - class TestRejectionABC(unittest.TestCase): """ Tests the basic methods of the ABC Rejection routine. """ -# Set up toy model, parameter values, problem, error measure + # Set up toy model, parameter values, problem, error measure @classmethod def setUpClass(cls): """ Set up problem for tests. """ @@ -76,9 +70,8 @@ def test_errors(self): abc.ask(1) # test two asks raises error self.assertRaises(RuntimeError, abc.ask, 1) - - # test tell with large value - self.assertEqual(None, abc.tell(100)) + # test tell with large values returns empty arrays + self.assertTrue(abc.tell(np.array([100])).size == 0) # test error raised if tell called before ask self.assertRaises(RuntimeError, abc.tell, 2.5) From b2b420cb9afd6b650e7a7529b590cf04cc36f5ec Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 18 Nov 2021 21:37:00 +0000 Subject: [PATCH 10/41] fix for test coverage --- pints/tests/test_abc_controller.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index 90d0ebe8b3..cf8a84cc13 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -51,6 +51,20 @@ def test_nparameters_error(self): self.assertRaises(ValueError, pints.ABCController, self.error_measure, log_prior) + def test_error_measure_instance(self): + """ Test that error is thrown when we use an error measure which is not + an instance of ``pints.ErrorMeasure``""" + # Set a log prior as the error measure to trigger the warning + wrong_error_measure = pints.UniformLogPrior( + [0.0, 0, 0], + [0.2, 100, 1]) + + self.assertRaises( + ValueError, + pints.ABCController, + wrong_error_measure, + self.log_prior) + def test_stopping(self): """ Test different stopping criteria. """ From 4cd015dd284a084af96a696276fb67e43f58d805 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Wed, 1 Dec 2021 15:08:38 +0000 Subject: [PATCH 11/41] added to changelog. updated ipynb. fixed sampling bug --- CHANGELOG.md | 1 + docs/source/abc_samplers/index.rst | 8 +++ examples/sampling/rejection-abc.ipynb | 92 ++++++++++++++++++++------- pints/_abc/__init__.py | 24 +++---- pints/_abc/_abc_rejection.py | 20 ++++-- 5 files changed, 105 insertions(+), 40 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index db8dc7a675..5babe52493 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file. ## [Unreleased] ### Added +- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for the Approximate Bayesian Inference sampling algorithms. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. - [#1383](https://github.com/pints-team/pints/pull/1383) Added a method `toy.TwistedGaussianDistribution.untwist` that turns samples from this distribution into samples from a multivariate Gaussian. - [#1322](https://github.com/pints-team/pints/pull/1322) Added a method `sample_initial_points` that allows users to generate random points with finite metrics (either log-probabilities or error measures) to use as starting points for sampling or optimisation. - [#1243](https://github.com/pints-team/pints/pull/1243) Added testing for Python 3.9. diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst index 7d6a74487c..848b4e3c96 100644 --- a/docs/source/abc_samplers/index.rst +++ b/docs/source/abc_samplers/index.rst @@ -2,6 +2,14 @@ ABC samplers ************ +.. currentmodule:: pints + +Pints provides a number of samplers for Approximate Bayesian +Computation, all implementing the :class:`ABCSampler` +interface, that can be used to sample from a stochastic model +given a :class:`LogPrior` and a :class:`ErrorMeasure`. + + .. toctree:: base_classes diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb index 7fa0a61aa5..2f87eb5aae 100644 --- a/examples/sampling/rejection-abc.ipynb +++ b/examples/sampling/rejection-abc.ipynb @@ -5,7 +5,14 @@ "metadata": {}, "source": [ "# Rejection ABC\n", - "This example shows you how to perform rejection ABC on a time series from the stochastic degradation model.\n" + "This example shows you how to perform Rejection ABC on a time series from the stochastic degradation model.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, the stochastic degradation model needs to be loaded." ] }, { @@ -18,7 +25,29 @@ "import pints.toy as toy\n", "import pints.plot\n", "import numpy as np\n", - "import matplotlib.pyplot as plt\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(3)\n", "\n", "# Load a forward model\n", "model = toy.StochasticDegradationModel()\n", @@ -34,21 +63,27 @@ "# Create a uniform prior parameter\n", "log_prior = pints.UniformLogPrior([0.0], [0.3])\n", "\n", - "\n", "# Set the error measure to be used to compare simulated to observed data\n", - "error_measure = pints.RootMeanSquaredError(problem)" + "error_measure = pints.RootMeanSquaredError(problem)\n", + "\n", + "plt.step(times, values)\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Fit using Rejection ABC" + "## Fit using Rejection ABC\n", + "\n", + "Now the Rejection ABC algorithm can be applied to sample parameter values." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -59,19 +94,19 @@ "Using Rejection ABC\n", "Running in sequential mode.\n", "Iter. Eval. Acceptance rate Time m:s\n", - "1 40 0.025 0:00.0\n", - "2 56 0.0357142857 0:00.0\n", - "3 84 0.0357142857 0:00.0\n", - "20 879 0.0227531286 0:00.3\n", - "40 1864 0.0214592275 0:00.6\n", - "60 2591 0.0231570822 0:00.8\n", - "80 3392 0.0235849057 0:01.0\n", - "100 4361 0.0229305205 0:01.3\n", - "120 5177 0.0231794476 0:01.5\n", - "140 6446 0.0217188954 0:01.8\n", - "160 7379 0.0216831549 0:02.0\n", - "180 8424 0.0213675214 0:02.3\n", - "200 9347 0.0213972398 0:02.6\n", + "1 91 0.010989011 0:00.1\n", + "2 317 0.00630914826 0:00.2\n", + "3 1023 0.00293255132 0:00.4\n", + "20 3841 0.00520697735 0:01.3\n", + "40 6299 0.00635021432 0:01.9\n", + "60 8010 0.0074906367 0:02.4\n", + "80 10140 0.00788954635 0:02.9\n", + "100 12195 0.008200082 0:03.6\n", + "120 15140 0.00792602378 0:04.4\n", + "140 17443 0.00802614229 0:05.0\n", + "160 20806 0.0076900894 0:05.9\n", + "180 22634 0.00795263762 0:06.3\n", + "200 25295 0.00790670093 0:07.1\n", "Halting: target number of samples (200) reached.\n", "Done\n" ] @@ -84,7 +119,7 @@ "abc.sampler().set_threshold(1)\n", "\n", "# set target number of samples\n", - "abc.set_nr_samples(200)\n", + "abc.set_n_samples(200)\n", "\n", "# log to screen\n", "abc.set_log_to_screen(True)\n", @@ -98,17 +133,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Plot approximate posterior vs actual parameter value" + "Plotting the approximate posterior compared to the actual parameter value." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -125,6 +160,17 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Note on Rejection ABC\n", + "\n", + "The Rejection ABC algorithm is a highly simplistic method for Bayesian inference. As a consequence, it is inefficient when used with high variance priors.\n", + "\n", + "Please make sure that you are monitoring the acceptance rate to see if this algorithm is working for your problem." + ] } ], "metadata": { diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py index d6ea829541..6e2b74419c 100644 --- a/pints/_abc/__init__.py +++ b/pints/_abc/__init__.py @@ -32,7 +32,7 @@ def tell(self, x): """ Performs an iteration of the ABC algorithm, using the parameters specified by ask. - Expects to receive x as a sequence of leangth at least 1. + Expects to receive x as a sequence of length at least 1. Returns the accepted parameter values. """ raise NotImplementedError @@ -60,7 +60,7 @@ class ABCController(object): Example ------- :: - + abc = pints.ABCController(error_measure, log_prior) abc.set_max_iterations(1000) posterior_estimate = abc.run() @@ -111,7 +111,7 @@ def __init__(self, error_measure, log_prior, method=None): # Maximum number of target samples to obtain # in the estimated posterior - self._nr_samples = 500 + self._n_samples = 500 # The sampler object uses the prior distribution self._sampler = method(log_prior) @@ -171,12 +171,12 @@ def max_iterations(self): """ return self._max_iterations - def nr_samples(self): + def n_samples(self): """ Returns the target number of samples to obtain in the estimated posterior. """ - return self._nr_samples + return self._n_samples def parallel(self): """ @@ -246,9 +246,9 @@ def run(self): # are using parallelisation and how many workers # are being used. if self._parallel: - n_requested_samples = 1 - else: n_requested_samples = self._n_workers + else: + n_requested_samples = 1 samples = [] # Sample until we find an acceptable sample @@ -289,8 +289,10 @@ def run(self): if iteration >= self._max_iterations: running = False halt_message = ('Halting: Maximum number of iterations (' - + str(iteration) + ') reached.') - elif accepted_count >= self._nr_samples: + + str(iteration) + ') reached. Only (' + + str(accepted_count) + ') sample were ' + + 'obtained') + elif accepted_count >= self._n_samples: running = False halt_message = ('Halting: target number of samples (' + str(accepted_count) + ') reached.') @@ -333,11 +335,11 @@ def set_max_iterations(self, iterations=10000): 'Maximum number of iterations cannot be negative.') self._max_iterations = iterations - def set_nr_samples(self, nr_samples=500): + def set_n_samples(self, n_samples=500): """ Sets a target number of samples """ - self._nr_samples = nr_samples + self._n_samples = n_samples def set_parallel(self, parallel=False): """ diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py index 92794ab442..48060887fa 100644 --- a/pints/_abc/_abc_rejection.py +++ b/pints/_abc/_abc_rejection.py @@ -6,6 +6,7 @@ # copyright notice and full license details. # import pints +import numpy as np class RejectionABC(pints.ABCSampler): @@ -23,10 +24,12 @@ class RejectionABC(pints.ABCSampler): \end{align} In other words, the first two steps sample parameters - from the prior distribution and then sample data from the - sampling distribution (assuming the sampled parameters). - In the end, if the summary statistics are within the threshold, - we add the sampled parameters to the list of samples. + from the prior distribution :math:`p(\theta)` and then sample + simulated data from the sampling distribution (conditional on + the sampled parameter values), :math:`p(x|\theta^*)`. + In the end, if the error measure between our simulated data and + the original data is within the threshold, we add the sampled + parameters to the list of samples. References ---------- @@ -63,12 +66,17 @@ def tell(self, fx): self._ready_for_tell = False fx = pints.vector(fx) - return self._xs[fx < self._threshold] + accepted = self._xs[fx < self._threshold] + if np.sum(accepted) == 0: + return None + else: + return [self._xs.tolist() for c, x in + enumerate(accepted) if x] def threshold(self): """ Returns threshold error distance that determines if a sample is - accepted (is ``error < threshold``). + accepted (if ``error < threshold``). """ return self._threshold From c087f3ff6dffef026f8b4b7c4af19313078a61da Mon Sep 17 00:00:00 2001 From: phumtutum Date: Wed, 1 Dec 2021 15:24:51 +0000 Subject: [PATCH 12/41] fixed tests --- pints/tests/test_abc_controller.py | 6 +++--- pints/tests/test_abc_rejection.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index cf8a84cc13..80e8b1824f 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -175,8 +175,8 @@ def test_controller_extra(self): # test setters abc = pints.ABCController( self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_nr_samples(230) - self.assertEqual(abc.nr_samples(), 230) + abc.set_n_samples(230) + self.assertEqual(abc.n_samples(), 230) sampler = abc.sampler() pt = sampler.ask(1) @@ -190,7 +190,7 @@ def test_controller_extra(self): self.error_measure, self.log_prior, method=pints.RejectionABC) abc.set_parallel(4) abc.sampler().set_threshold(100) - abc.set_nr_samples(1) + abc.set_n_samples(1) abc.run() lines = capture.text().splitlines() self.assertTrue(len(lines) > 0) diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py index 94fd51bc00..dc18247dd4 100644 --- a/pints/tests/test_abc_rejection.py +++ b/pints/tests/test_abc_rejection.py @@ -71,7 +71,7 @@ def test_errors(self): # test two asks raises error self.assertRaises(RuntimeError, abc.ask, 1) # test tell with large values returns empty arrays - self.assertTrue(abc.tell(np.array([100])).size == 0) + self.assertTrue(abc.tell(np.array([100])) is None) # test error raised if tell called before ask self.assertRaises(RuntimeError, abc.tell, 2.5) From ca07da494e4f9fe07b3f753b505d5c74a8dacad8 Mon Sep 17 00:00:00 2001 From: Michael Clerx Date: Thu, 2 Dec 2021 16:14:45 +0000 Subject: [PATCH 13/41] Update CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1561e8d345..122b59208d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file. ## [Unreleased] ### Added -- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for the Approximate Bayesian Inference sampling algorithms. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. +- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for Approximate Bayesian computation (ABC) samplers. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. - [#1409](https://github.com/pints-team/pints/pull/1409) The `OptimisationController` now accepts a callback function that will be called at every iteration; this can be used for easier customisation or visualisation of the optimiser trajectory. - [#1383](https://github.com/pints-team/pints/pull/1383) Added a method `toy.TwistedGaussianDistribution.untwist` that turns samples from this distribution into samples from a multivariate Gaussian. - [#1322](https://github.com/pints-team/pints/pull/1322) Added a method `sample_initial_points` that allows users to generate random points with finite metrics (either log-probabilities or error measures) to use as starting points for sampling or optimisation. From be8e30b25cc6554b40120e988ea2adeea1f6fa07 Mon Sep 17 00:00:00 2001 From: Michael Clerx Date: Thu, 2 Dec 2021 16:15:22 +0000 Subject: [PATCH 14/41] Update docs/source/abc_samplers/index.rst --- docs/source/abc_samplers/index.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst index 848b4e3c96..96b4e9fc9d 100644 --- a/docs/source/abc_samplers/index.rst +++ b/docs/source/abc_samplers/index.rst @@ -5,7 +5,7 @@ ABC samplers .. currentmodule:: pints Pints provides a number of samplers for Approximate Bayesian -Computation, all implementing the :class:`ABCSampler` +Computation (ABC), all implementing the :class:`ABCSampler` interface, that can be used to sample from a stochastic model given a :class:`LogPrior` and a :class:`ErrorMeasure`. From 412175dfbd40362540111843f8c88aab6d2819cb Mon Sep 17 00:00:00 2001 From: phumtutum Date: Sun, 12 Dec 2021 21:23:44 +0000 Subject: [PATCH 15/41] extended jupyter notebook for rej abc --- examples/sampling/rejection-abc.ipynb | 74 +++++++++++++++------------ 1 file changed, 42 insertions(+), 32 deletions(-) diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb index 2f87eb5aae..73be5bca71 100644 --- a/examples/sampling/rejection-abc.ipynb +++ b/examples/sampling/rejection-abc.ipynb @@ -4,20 +4,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Rejection ABC\n", - "This example shows you how to perform Rejection ABC on a time series from the stochastic degradation model.\n" + "# Rejection ABC\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "First, the stochastic degradation model needs to be loaded." + "This example shows you how to perform Rejection ABC on a time series from the [stochastic degradation model](../toy/model-stochastic-degradation.ipynb). This model describes the describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react. It differs from most other models in PINTS through the fact that a likelihood ( $D | \\theta$ ) cannot be derived and we are only able to produce stochastic simulations using Gillespie's algorithm. ABC samplers are the solution to such a problem since they do not evaluate the likelihood to sample from the posterior distribution ( $\\theta | D$ )." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we will load the stochastic degradation model. In order to emphasise the variety provided by the stochastic simulations we will plot multiple runs of the model with the same parameters." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -30,12 +36,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -55,18 +61,22 @@ "# Create some toy data\n", "real_parameters = model.suggested_parameters()\n", "times = np.linspace(0, 10, 100)\n", - "values = model.simulate(real_parameters, times)\n", "\n", - "# Create an object with links to the model and time series\n", - "problem = pints.SingleOutputProblem(model, times, values)\n", + "for i in range(10):\n", + " values = model.simulate(real_parameters, times)\n", + "\n", + " # Create an object with links to the model and time series\n", + " problem = pints.SingleOutputProblem(model, times, values)\n", + "\n", + " # Create a uniform prior parameter\n", + " log_prior = pints.UniformLogPrior([0.0], [0.3])\n", + "\n", + " # Set the error measure to be used to compare simulated to observed data\n", + " error_measure = pints.RootMeanSquaredError(problem)\n", "\n", - "# Create a uniform prior parameter\n", - "log_prior = pints.UniformLogPrior([0.0], [0.3])\n", + " plt.step(times, values)\n", "\n", - "# Set the error measure to be used to compare simulated to observed data\n", - "error_measure = pints.RootMeanSquaredError(problem)\n", "\n", - "plt.step(times, values)\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", "plt.show()" @@ -78,12 +88,12 @@ "source": [ "## Fit using Rejection ABC\n", "\n", - "Now the Rejection ABC algorithm can be applied to sample parameter values." + "The Rejection ABC algorithm can be applied to sample parameter values. An error measure will be used to compare the difference between the stochastic simulation obtained with the true set of parameters and the stochastic simulation obtained with a candidate value. Our error measure of choice is the root mean squared error. Root mean squared error has been chosen in order to amplify smaller differences between two stochastic simulations in order to increase the quality of our samples." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -94,19 +104,19 @@ "Using Rejection ABC\n", "Running in sequential mode.\n", "Iter. Eval. Acceptance rate Time m:s\n", - "1 91 0.010989011 0:00.1\n", - "2 317 0.00630914826 0:00.2\n", - "3 1023 0.00293255132 0:00.4\n", - "20 3841 0.00520697735 0:01.3\n", - "40 6299 0.00635021432 0:01.9\n", - "60 8010 0.0074906367 0:02.4\n", - "80 10140 0.00788954635 0:02.9\n", - "100 12195 0.008200082 0:03.6\n", - "120 15140 0.00792602378 0:04.4\n", - "140 17443 0.00802614229 0:05.0\n", - "160 20806 0.0076900894 0:05.9\n", - "180 22634 0.00795263762 0:06.3\n", - "200 25295 0.00790670093 0:07.1\n", + "1 73 0.0136986301 0:00.0\n", + "2 298 0.0067114094 0:00.1\n", + "3 1214 0.00247116969 0:00.4\n", + "20 8713 0.00229542064 0:02.5\n", + "40 16802 0.00238066897 0:04.9\n", + "60 24257 0.0024735128 0:06.9\n", + "80 31257 0.00255942669 0:08.8\n", + "100 38391 0.00260477716 0:10.7\n", + "120 44873 0.00267421389 0:12.6\n", + "140 49498 0.00282839711 0:13.9\n", + "160 56999 0.00280706679 0:15.9\n", + "180 62154 0.00289603244 0:17.3\n", + "200 68341 0.00292650093 0:19.0\n", "Halting: target number of samples (200) reached.\n", "Done\n" ] @@ -133,17 +143,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Plotting the approximate posterior compared to the actual parameter value." + "In order to find the efficiency of the rejection ABC, we plot the approximate posterior compared to the actual parameter value. In the graph, we can see that there is a high concentration of samples around the value with which the data was generated. This suggests that the rejection ABC algorithm performs well and that the root mean squared error was a good choice as an error measure, since high quality samples were produced." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From 0295abd7253d6d13f6665ca09a1e8414e6ebb9c8 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 14:10:06 +0000 Subject: [PATCH 16/41] merged with new stochastic pr --- examples/sampling/rejection-abc.ipynb | 41 +++++++++------------------ 1 file changed, 14 insertions(+), 27 deletions(-) diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb index 73be5bca71..a7a7ea39ce 100644 --- a/examples/sampling/rejection-abc.ipynb +++ b/examples/sampling/rejection-abc.ipynb @@ -23,12 +23,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "import pints\n", "import pints.toy as toy\n", + "import pints.toy.stochastic\n", "import pints.plot\n", "import numpy as np\n", "import matplotlib.pyplot as plt" @@ -36,12 +37,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -56,7 +57,7 @@ "np.random.seed(3)\n", "\n", "# Load a forward model\n", - "model = toy.StochasticDegradationModel()\n", + "model = toy.stochastic.DegradationModel()\n", "\n", "# Create some toy data\n", "real_parameters = model.suggested_parameters()\n", @@ -93,32 +94,18 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running...\n", - "Using Rejection ABC\n", - "Running in sequential mode.\n", - "Iter. Eval. Acceptance rate Time m:s\n", - "1 73 0.0136986301 0:00.0\n", - "2 298 0.0067114094 0:00.1\n", - "3 1214 0.00247116969 0:00.4\n", - "20 8713 0.00229542064 0:02.5\n", - "40 16802 0.00238066897 0:04.9\n", - "60 24257 0.0024735128 0:06.9\n", - "80 31257 0.00255942669 0:08.8\n", - "100 38391 0.00260477716 0:10.7\n", - "120 44873 0.00267421389 0:12.6\n", - "140 49498 0.00282839711 0:13.9\n", - "160 56999 0.00280706679 0:15.9\n", - "180 62154 0.00289603244 0:17.3\n", - "200 68341 0.00292650093 0:19.0\n", - "Halting: target number of samples (200) reached.\n", - "Done\n" + "ename": "AttributeError", + "evalue": "module 'pints' has no attribute 'ABCController'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mabc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpints\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mABCController\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merror_measure\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlog_prior\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# set threshold\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mabc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msampler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_threshold\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mAttributeError\u001b[0m: module 'pints' has no attribute 'ABCController'" ] } ], From 3f91fb589cd594125ba90b800ee6ebd351ea6c2f Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 14:34:33 +0000 Subject: [PATCH 17/41] ipynb and tests now use new stochastic models --- examples/sampling/rejection-abc.ipynb | 42 ++++++++++++++++++--------- pints/tests/test_abc_controller.py | 3 +- pints/tests/test_abc_rejection.py | 3 +- 3 files changed, 32 insertions(+), 16 deletions(-) diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb index a7a7ea39ce..9be5af1c3f 100644 --- a/examples/sampling/rejection-abc.ipynb +++ b/examples/sampling/rejection-abc.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -37,12 +37,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -94,18 +94,32 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 3, "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "module 'pints' has no attribute 'ABCController'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mabc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpints\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mABCController\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0merror_measure\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlog_prior\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;31m# set threshold\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mabc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msampler\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_threshold\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mAttributeError\u001b[0m: module 'pints' has no attribute 'ABCController'" + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "Using Rejection ABC\n", + "Running in sequential mode.\n", + "Iter. Eval. Acceptance rate Time m:s\n", + "1 14 0.0714285714 0:00.0\n", + "2 24 0.0833333333 0:00.0\n", + "3 41 0.0731707317 0:00.0\n", + "20 521 0.0383877159 0:00.2\n", + "40 1418 0.0282087447 0:00.5\n", + "60 2418 0.0248138958 0:00.8\n", + "80 3185 0.0251177394 0:01.0\n", + "100 4057 0.0246487552 0:01.3\n", + "120 4979 0.0241012251 0:01.6\n", + "140 5725 0.0244541485 0:01.8\n", + "160 6767 0.0236441555 0:02.1\n", + "180 7834 0.0229767679 0:02.4\n", + "200 8539 0.0234219464 0:02.6\n", + "Halting: target number of samples (200) reached.\n", + "Done\n" ] } ], @@ -135,12 +149,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZVklEQVR4nO3dfXRV9b3n8fcXQfABiyRcSg0YHAFBHktQEW5XKGopQ0FrJFplwNJGYXTZomuqLXeV8WLHW6/obastWdUbqkOQyRVBxk6RJ1t7ASUUEaQ86EAJpSChOKaIinznj7OTewiBnJCTvbM3n9daZ52zH8/n7Oz1ze/8zn4wd0dEROKnTdQBRETkzKiAi4jElAq4iEhMqYCLiMSUCriISEy1DfPNcnNzPT8/P8y3FBGJvcrKyoPu3qX++FALeH5+PuvXrw/zLUVEYs/Mdjc0Xl0oIiIxpQIuIhJTKuAiIjEVah+4iLRen376KVVVVRw9ejTqKGetDh06kJeXR7t27TKaXwVcRACoqqqiY8eO5OfnY2ZRxznruDvV1dVUVVXRs2fPjJZRF4qIAHD06FFycnJUvCNiZuTk5DTpG5AKuIjUUfGOVlO3vwq4iEhMqYCLSIPMsvvIxCOPPMKVV17JwIEDGTx4MOvWrWuxz1dYWBj7Ewv1I6acJMpv0bq/yNlrzZo1LF26lA0bNtC+fXsOHjzIJ598EnWsVk0tcBFpFfbt20dubi7t27cHIDc3ly984Qs8/PDDDBs2jP79+1NSUkLtXcQKCwv57ne/S0FBAX379uXNN9/k61//Or169WLmzJkA7Nq1iyuuuILbb7+dvn37UlRUxJEjR05672XLljF8+HC++MUvcsstt1BTUwPAgw8+SL9+/Rg4cCAPPPBASFsicyrgItIq3HDDDezZs4fevXszffp0XnvtNQDuuece3nzzTTZv3sxHH33E0qVL65Y599xzWb9+PXfffTcTJkzgqaeeYvPmzZSVlVFdXQ3Atm3bmD59Olu3buWiiy7i6aefPuF9Dx48yOzZs1m+fDkbNmygoKCAOXPmUF1dzaJFi9iyZQubNm2q+6fQmqiAi0ircOGFF1JZWUlpaSldunShuLiYsrIyVq1axdVXX82AAQNYuXIlW7ZsqVtm/PjxAAwYMIArr7ySbt260b59ey677DL27NkDQPfu3RkxYgQAd9xxB6+//voJ77t27VreeecdRowYweDBg5k3bx67d+/mc5/7HB06dGDq1Km8+OKLnH/++SFticypD1xEWo1zzjmHwsJCCgsLGTBgAHPnzmXTpk2sX7+e7t27M2vWrBOOk67tbmnTpk3d69rhY8eOAScfmld/2N25/vrrKS8vPynPG2+8wYoVK6ioqOBnP/sZK1euzNpnzYaMWuBmtsvM3jazjWa2PhjX2cxeNbMdwfPFLRtVRJJs27Zt7Nixo25448aN9OnTB0j1h9fU1FBRUdHk9f7pT39izZo1AMyfP5+RI0eeMP2aa67h97//PTt37gTgb3/7G9u3b6empoYPPviAsWPH8sQTT/DWW2+d6UdrMU1pgY9y94Npww8CK9z9UTN7MBj+XlbTiUhkwj4iqKamhnvvvZfDhw/Ttm1bLr/8ckpLS+nUqRP9+/fn85//PMOGDWvyevv06cNTTz3FN7/5Tfr168e0adNOmN6lSxfKysq47bbb+PjjjwGYPXs2HTt2ZMKECRw9ehR3Z86cOVn5nNlknsFfycx2AQXpBdzMtgGF7r7PzLoBq929z+nWU1BQ4HE/7vJsoMMIz05bt26lb9++UcfIql27djFu3Dg2b94cdZSMNfR3MLNKdy+oP2+mP2I6sMzMKs2sJBjX1d33Ba//AnRtaEEzKzGz9Wa2/v3338/w7SSpBrGRQWyMOoZIImTahTLS3fea2d8Br5rZH9MnurubWYNtJ3cvBUoh1QJvVlqJvbcYHHUEOYvk5+fHqvXdVBm1wN19b/B8AFgEXAXsD7pOCJ4PtFRISY7RLGc0y6OOIZIIjRZwM7vAzDrWvgZuADYDS4DJwWyTgcUtFVKSYyazmcnsqGOIJEImXShdgUXBsZNtgfnu/n/M7E1goZlNBXYDE1supoiI1NdoAXf394BBDYyvBka3RCgREWmcTqUXkVblpZdewsz44x//2Oi8Tz75ZIMXp8pUWVkZ99xzzxkvn+31NJUKuIi0KuXl5YwcObLBU9vra24BjzsVcAnVXczlLuZGHUNaqZqaGl5//XWeeeYZFixYUDf+s88+44EHHqB///4MHDiQn/70p/zkJz/hz3/+M6NGjWLUqFFA6oJYtSoqKpgyZQoAL7/8MldffTVDhgzhuuuuY//+/afMcPz4cfLz8zl8+HDduF69erF///6M1jNlypQTTvlPz/TYY48xbNgwBg4cyA9/+MMmb5/6dDErCdV2TnuyrrQmhYUnj5s4EaZPhyNHYOzYk6dPmZJ6HDwIRUUnTlu9utG3XLx4MWPGjKF3797k5ORQWVnJ0KFDKS0tZdeuXWzcuJG2bdty6NAhOnfuzJw5c1i1ahW5ubmnXe/IkSNZu3YtZsYvf/lLfvzjH/P44483OG+bNm2YMGECixYt4s4772TdunVceumldO3atUnrqW/ZsmXs2LGDN954A3dn/Pjx/Pa3v+VLX/pSRss3RAVcQjWOlwFYytciTiKtUXl5Offddx8At956K+Xl5QwdOpTly5dz991307ZtqmR17ty5SeutqqqiuLiYffv28cknn9CzZ8/Tzl9cXMzDDz/MnXfeyYIFCyguLj6j9aRbtmwZy5YtY8iQIUDq28aOHTtUwCU+7ifVWlEBj4HTtZjPP//003NzM2pxpzt06BArV67k7bffxsz47LPPMDMee+yxjNeRfqnY9MvO3nvvvcyYMYPx48ezevVqZs2addr1DB8+nJ07d/L+++/z0ksv1d3MIZP1tG3bluPHjwOp7pja28K5Ow899BB33XVXxp+nMeoDl1Yl2zfSzeYNd6VlVVRUMGnSJHbv3s2uXbvYs2cPPXv25He/+x3XX389c+fOrbvG96FDhwDo2LEjH374Yd06unbtytatWzl+/DiLFi2qG//BBx9wySWXADBv3rxGs5gZN910EzNmzKBv377k5ORkvJ78/HwqKysBWLJkCZ9++ikAX/nKV3j22Wfrbte2d+9eDhxo3gnsKuAi0iqUl5dz0003nTDu5ptvpry8nG9961v06NGDgQMHMmjQIObPnw9ASUkJY8aMqfsR89FHH2XcuHFce+21dOvWrW49s2bN4pZbbmHo0KGN9pfXKi4u5vnnn6/rPsl0Pd/+9rd57bXXGDRoEGvWrOGCCy4AUreM+8Y3vsHw4cMZMGAARUVFJ/zzORMZXU42W3Q52XhoyRbpKgoBGMXqlnuTM6DL2CbzcrJx1BKXkxURkVZGP2JKqCbxXNQRRBJDBVxCVUX3qCPIabj7STf9lfA0tUtbXSgSqom8wEReiDqGNKBDhw5UV1c3uYhIdrg71dXVdOjQIeNl1AKXUE3j5wAspLiROSVseXl5VFVVoVsfRqdDhw7k5eVlPL8KuIgA0K5duyadWSjRUxeKiEhMqYCLiMSUCriISEypD1xCVURF4zOJSEZUwCVU1WR2HQoRaZy6UCRUkyljMmVRxxBJBLXAJVRTguI9jymR5hBJArXARURiSgVcRCSmVMBFRGJKBVxEJKb0I6aEaiyvRB1BJDFUwCVUH3F+1BFEEkNdKBKqaTzNNJ6OOoZIIqiAS6gmspCJLIw6hkgiZFzAzewcM/uDmS0Nhnua2Toz22lmL5jZuS0XU0RE6mtKC/w+YGva8D8BT7j75cBfganZDCYiIqeXUQE3szzgPwO/DIYN+DLUXVpuHnBjC+QTEZFTyLQF/iTw34DjwXAOcNjdjwXDVcAl2Y0mIiKn0+hhhGY2Djjg7pVmVtjUNzCzEqAEoEePHk1dXBJmFKujjiCSGJm0wEcA481sF7CAVNfJvwCdzKz2H0AesLehhd291N0L3L2gS5cuWYgsIiKQQQF394fcPc/d84FbgZXufjuwCigKZpsMLG6xlJIY9/PP3M8/Rx1DJBGacxz494AZZraTVJ/4M9mJJEk2jqWMY2nUMUQSoUmn0rv7akh1Yrr7e8BV2Y8kIiKZ0JmYIiIxpQIuIhJTuhqhhOojzos6gkhiqIBLqMby66gjiCSGulBERGJKBVxCNZN/ZCb/GHUMkURQAZdQjWYFo1kRdQyRRFABFxGJKRVwEZGYUgEXEYkpHUYooaomJ+oIIomhAi6hKuLfoo4gkhjqQhERiSkVcAnVj3iIH/FQ1DFEEkFdKBKq4ayJOoJIYqgFLiISUyrgIiIxpQIuIhJT6gOXUFWRF3UEkcRQAZdQTeL5qCOIJIa6UEREYkoFXEL1BN/hCb4TdQyRRFAXioRqMBujjiCSGGqBi4jElAq4iEhMqYCLiMSU+sAlVNvpHXUEkcRQAZdQ3UVp1BFEEkNdKCIiMaUCLqGaSwlzKYk6hkgiqAtFQtWb7VFHEEmMRlvgZtbBzN4ws7fMbIuZ/fdgfE8zW2dmO83sBTM7t+XjiohIrUy6UD4Gvuzug4DBwBgzuwb4J+AJd78c+CswtcVSiojISRot4J5SEwy2Cx4OfBmoCMbPA25siYAiItKwjPrAzewcoBK4HHgKeBc47O7HglmqgEtOsWwJpH616tGjR3PznlXMok6QfRsZHHUEkcTIqIC7+2fAYDPrBCwCrsj0Ddy9FFIH/xYUFPgZZJQE+S5PRh1BJDGadBihux8GVgHDgU5mVvsPIA/Ym91oIiJyOpkchdIlaHljZucB1wNbSRXyomC2ycDiFsooCfIcd/Acd0QdQyQRMulC6QbMC/rB2wAL3X2pmb0DLDCz2cAfgGdaMKckRB5VUUcQSYxGC7i7bwKGNDD+PeCqlgglIiKN06n0IiIxpQIuIhJTuhaKhGoNw6OOIJIYKuASqu/zP6KOIJIY6kIREYkpFXAJVQU3U8HNUccQSQR1oUiocqiOOoJIYqgFLiISUyrgIiIxpQIuIhJT6gOXUK1gdNQRRBJDBVxCNZt/iDqCSGKoC0VEJKZUwCVUr/BVXuGrUccQSQR1oUiozuOjqCM0KMr7j7puNChnSC1wEZGYUgEXEYkpFXARkZhSH7iEainjoo4gkhgq4BKqx3kg6ggiiaEuFBGRmFIBl1CtopBVFEYdQyQRVMBFRGJKBVxEJKZUwEVEYkoFXEQkpnQYoYRqIROjjiCSGCrgEqqfMz3qCCKJoS4UCdV5HOE8jkQdQyQR1AKXUL3CWABGsTraICIJoBa4iEhMNVrAzay7ma0ys3fMbIuZ3ReM72xmr5rZjuD54paPKyIitTJpgR8D7nf3fsA1wH81s37Ag8AKd+8FrAiGRUQkJI0WcHff5+4bgtcfAluBS4AJwLxgtnnAjS2UUUREGtCkHzHNLB8YAqwDurr7vmDSX4Cup1imBCgB6NGjxxkHlWQoY0rUEUQSwzzDO6qa2YXAa8Aj7v6imR12905p0//q7qftBy8oKPD169c3J+9ZJcob7Up4dFNjaYyZVbp7Qf3xGR2FYmbtgH8D/qe7vxiM3m9m3YLp3YAD2QoryZXDQXI4GHUMkUTI5CgUA54Btrr7nLRJS4DJwevJwOLsx5OkqaCICoqijiGSCJn0gY8AJgFvm9nGYNz3gUeBhWY2FdgNusiFiEiYGi3g7v46cKre2NHZjSMiIpnSmZgiIjGlAi4iElO6mJWE6udMizqCSGKogEuoFlIcdQSRxFAXioQqjz3ksSfqGCKJoBa4hOo5JgG6HrhINqgFLiISUyrgIiIxpQIuIhJTKuAiIjGlHzElVI9zf9QRRBJDBVxCtZSvRR1BJDHUhSKh6s02erMt6hgiiaAWuIRqLncBOg5cJBtUwBuh25pJS4tqH9Ot3OJPXSgiIjGlAi4iElMq4CIiMaU+cAnVbGZGHUEkMVTAJVQruC7qCCKJoS4UCdUgNjKIjVHHEEkEtcAlVE/yHUDHgYtkg1rgIiIxpQIuIhJTKuAiIjGlAi4iElP6EVNC9X1+FHUEkcRQAZdQreHaqCOIJIa6UCRUw/l3hvPvUccQSQS1wCVUP+L7gI4DF8kGtcBFRGKq0QJuZs+a2QEz25w2rrOZvWpmO4Lni1s2poiI1JdJC7wMGFNv3IPACnfvBawIhkVEJESNFnB3/y1wqN7oCcC84PU84MbsxhIRkcac6Y+YXd19X/D6L0DXU81oZiVACUCPHj3O8O0kKb7Dk1FHEEmMZh+F4u5uZqe8Paq7lwKlAAUFBbqN6lnuLQZHHUEkMc70KJT9ZtYNIHg+kL1IkmSjWc5olkcdQyQRzrSALwEmB68nA4uzE0eSbiazmcnsqGOIJEImhxGWA2uAPmZWZWZTgUeB681sB3BdMCwiIiFqtA/c3W87xaTRWc4iIiJNoDMxRURiSgVcRCSmdDErCdVdzI06gkhiqIBLqLbTJ+oIIomhLhQJ1TheZhwvRx1DJBHUApdQ3c/jACzlaxEnEYk/FXCRs5RZdO/tuqhGVqgLRUQkplTARURiSgVcRCSm1AcuoZrEc1FHEEkMFXAJVRXdo44gkhjqQpFQTeQFJvJC1DFEEkEtcAnVNH4OwEKKI04iEn9qgYuIxJQKuIhITKmAi4jElAq4iEhM6UdMCVURFVFHkFYgquuwJO0aLCrgEqpqcqOOIJIY6kKRUE2mjMmURR1DJBHUApdQTQmK9zymRJpDJAliU8CjvHaxiEhrpC4UEZGYUgEXEYkpFXARkZiKTR+4JMNYXok6gpzFknb8uQq4hOojzo86gkhiqAtFQjWNp5nG01HHEEkEFXAJ1UQWMpGFUccQSQQVcBGRmGpWATezMWa2zcx2mtmD2QolIiKNO+MCbmbnAE8BXwX6AbeZWb9sBRMRkdNrTgv8KmCnu7/n7p8AC4AJ2YklIiKNac5hhJcAe9KGq4Cr689kZiVASTBYY2bbmvGeYcgFDkYdoolik3lU6ikXLBZ508RmGweUt+VlnDkLx59f2tDIFj8O3N1LgdKWfp9sMbP17l4QdY6miFvmuOWF+GVW3pbXGjI3pwtlL9A9bTgvGCciIiFoTgF/E+hlZj3N7FzgVmBJdmKJiEhjzrgLxd2Pmdk9wG+Ac4Bn3X1L1pJFJzbdPWniljlueSF+mZW35UWe2Txpd/kUETlL6ExMEZGYUgEXEYmpxBfwxk73N7P2ZvZCMH2dmeUH4/PN7CMz2xg8fpG2zFAzeztY5idm2bvKcDPy3p6WdaOZHTezwcG01cE6a6f9XbbyZpj5S2a2wcyOmVlRvWmTzWxH8JicNj7KbdxgXjMbbGZrzGyLmW0ys+K0aWVm9n/TtvHgqPMG0z5Ly7QkbXzPYP/ZGexP52Yrb3Mym9moevvxUTO7MZgW5TaeYWbvBH/3FWZ2adq00PfhOu6e2AepH1ffBS4DzgXeAvrVm2c68Ivg9a3AC8HrfGDzKdb7BnANYMCvga9GnbfePAOAd9OGVwMFEW7jfGAg8CugKG18Z+C94Pni4PXFrWAbnypvb6BX8PoLwD6gUzBclj5va9i+wbSaU6x3IXBr8PoXwLTWkrne/nEIOL8VbONRaTmm8R91IvR9OP2R9BZ4Jqf7TwDmBa8rgNGn+09pZt2Ai9x9raf+Sr8CbmxleW8Llg1Do5ndfZe7bwKO11v2K8Cr7n7I3f8KvAqMiXobnyqvu2939x3B6z8DB4AuWcqV9bynEuwvXya1/0Bqf7oxa4mzl7kI+LW7H8litoZkkndVWo61pM57gWj24TpJL+ANne5/yanmcfdjwAdATjCtp5n9wcxeM7O/T5u/qpF1RpW3VjFQXm/cvwZfO/8hy1/lMsnc1GWj3saNMrOrSLXW3k0b/UjwFfsJM2vfvJh1mpu3g5mtN7O1tV0RpPaXw8H+cybrbExWtjGpb5j19+PWsI2nkmpRn27ZltyH6yS9gDfHPqCHuw8BZgDzzeyiiDM1ysyuBo64++a00be7+wDg74PHpEjCJUTQunoOuNPda1uQDwFXAMNIfZ3+XkTx6rvUU6d7fwN40sz+U9SBMhFs4wGkzjOpFfk2NrM7gALgsbDfuyFJL+CZnO5fN4+ZtQU+B1S7+8fuXg3g7pWkWlq9g/nz0pbP5iUEzjhv2vSTWi3uvjd4/hCYT+orY7Y055IKp1o26m18SsE/8f8N/MDd19aOd/d9nvIx8K9kbxs3K2/a3/49Ur+FDCG1v3QK9p8mrzMD2bjMxkRgkbt/Wjsi6m1sZtcBPwDGBxlOt2xL7sN1kl7AMzndfwlQ+8txEbDS3d3MuljqmueY2WVAL+A9d98H/D8zuyboivgvwOKo8wY525Da8ev6v82srZnlBq/bAeOAzWRPcy6p8BvgBjO72MwuBm4AftMKtnGDgvkXAb9y94p607oFz0aqrzNb27g5eS+u7WYI9oERwDvB/rKK1P4Dqf0pW9u3WZnT3Ea9hkiU29jMhgBzSRXvA2mTotiH/0O2fxVtbQ9gLLCdVAv6B8G4h4M/BEAH4H8BO0n9anxZMP5mYAuwEdgAfC1tnQWkdp53gZ8RnNEaZd5gWiGwtt76LgAqgU3B5/kX4JyQt/EwUn2AfyPV+tuStuw3g8+yk1SXRGvYxg3mBe4APg32idrH4GDaSuDtIPPzwIWtIO+1Qaa3guepaeu8LNh/dgb7U/tWtE/kk2qttqm3zii38XJgf9rffUmU+3DtQ6fSi4jEVNK7UEREEksFXEQkplTARURiSgVcRCSmVMBFRGJKBVxEJKZUwEVEYur/A57fXlBJ8TTVAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py index 80e8b1824f..f3def023d9 100644 --- a/pints/tests/test_abc_controller.py +++ b/pints/tests/test_abc_controller.py @@ -8,6 +8,7 @@ # import pints import pints.toy +import pints.toy.stochastic import unittest import numpy as np from shared import StreamCapture @@ -23,7 +24,7 @@ def setUpClass(cls): """ Prepare problem for tests. """ # Create toy model - cls.model = pints.toy.StochasticDegradationModel() + cls.model = pints.toy.stochastic.DegradationModel() cls.real_parameters = [0.1] cls.times = np.linspace(0, 10, 10) cls.values = cls.model.simulate(cls.real_parameters, cls.times) diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py index dc18247dd4..eab78786f8 100644 --- a/pints/tests/test_abc_rejection.py +++ b/pints/tests/test_abc_rejection.py @@ -8,6 +8,7 @@ # import pints import pints.toy as toy +import pints.toy.stochastic import unittest import numpy as np @@ -22,7 +23,7 @@ def setUpClass(cls): """ Set up problem for tests. """ # Create toy model - cls.model = toy.StochasticDegradationModel() + cls.model = toy.stochastic.DegradationModel() cls.real_parameters = [0.1] cls.times = np.linspace(0, 10, 10) cls.values = cls.model.simulate(cls.real_parameters, cls.times) From 3b46e62a505849a5ef9c86949e222bbb16c0366a Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 16:29:52 +0000 Subject: [PATCH 18/41] added unit tests for the stochastic logistic model --- .../test_toy_stochastic_logistic_model.py | 37 +++---- pints/toy/stochastic/__init__.py | 1 + pints/toy/stochastic/_logistic_model.py | 99 +++++++++++++++++++ 3 files changed, 115 insertions(+), 22 deletions(-) create mode 100644 pints/toy/stochastic/_logistic_model.py diff --git a/pints/tests/test_toy_stochastic_logistic_model.py b/pints/tests/test_toy_stochastic_logistic_model.py index 67fc040257..0eb1314d3d 100755 --- a/pints/tests/test_toy_stochastic_logistic_model.py +++ b/pints/tests/test_toy_stochastic_logistic_model.py @@ -10,6 +10,7 @@ import numpy as np import pints import pints.toy +import pints.toy.stochastic class TestStochasticLogisticModel(unittest.TestCase): @@ -22,7 +23,7 @@ def test_start_with_zero(self): # Set seed for random generator np.random.seed(1) - model = pints.toy.StochasticLogisticModel(0) + model = pints.toy.stochastic.LogisticModel(0) times = [0, 1, 2, 100, 1000] parameters = [0.1, 50] values = model.simulate(parameters, times) @@ -35,7 +36,7 @@ def test_start_with_one(self): # Set seed for random generator np.random.seed(1) - model = pints.toy.StochasticLogisticModel(1) + model = pints.toy.stochastic.LogisticModel(1) times = [0, 1, 2, 100, 1000] parameters = [0.1, 50] values = model.simulate(parameters, times) @@ -46,7 +47,7 @@ def test_start_with_one(self): def test_suggested(self): # Check suggested values - model = pints.toy.StochasticLogisticModel(1) + model = pints.toy.stochastic.LogisticModel(1) times = model.suggested_times() parameters = model.suggested_parameters() self.assertTrue(len(times) == 101) @@ -55,14 +56,14 @@ def test_suggested(self): def test_simulate(self): # Check each step in the simulation process np.random.seed(1) - model = pints.toy.StochasticLogisticModel(1) + model = pints.toy.stochastic.LogisticModel(1) times = np.linspace(0, 100, 101) - params = [0.1, 50] - time, raw_values = model._simulate_raw([0.1, 50]) - values = model._interpolate_values(time, raw_values, times, params) + time, raw_values = model.simulate_raw([0.1, 50], 100) + values = model.interpolate_mol_counts(time, raw_values, times) self.assertTrue(len(time), len(raw_values)) # Test output of Gillespie algorithm + raw_values = np.concatenate(raw_values) self.assertTrue(np.all(raw_values == np.array(range(1, 51)))) # Check simulate function returns expected values @@ -70,19 +71,17 @@ def test_simulate(self): # Check interpolation function works as expected temp_time = np.array([np.random.uniform(time[0], time[1])]) - self.assertTrue(model._interpolate_values(time, raw_values, temp_time, - params)[0] == 1) + self.assertTrue(model.interpolate_mol_counts(time, raw_values, + temp_time)[0] == 1) temp_time = np.array([np.random.uniform(time[1], time[2])]) - self.assertTrue(model._interpolate_values(time, raw_values, temp_time, - params)[0] == 2) + self.assertTrue(model.interpolate_mol_counts(time, raw_values, + temp_time)[0] == 2) # Check parameters, times cannot be negative parameters_0 = [-0.1, 50] - self.assertRaises(ValueError, model.simulate, parameters_0, times) self.assertRaises(ValueError, model.mean, parameters_0, times) parameters_1 = [0.1, -50] - self.assertRaises(ValueError, model.simulate, parameters_1, times) self.assertRaises(ValueError, model.mean, parameters_1, times) times_2 = np.linspace(-10, 10, 21) @@ -96,21 +95,15 @@ def test_simulate(self): self.assertRaises(ValueError, model.mean, parameters_3, times) # Check initial value cannot be negative - self.assertRaises(ValueError, pints.toy.StochasticLogisticModel, -1) + self.assertRaises(ValueError, pints.toy.stochastic.LogisticModel, -1) - def test_mean_variance(self): + def test_mean(self): # Check the mean is what we expected - model = pints.toy.StochasticLogisticModel(1) + model = pints.toy.stochastic.LogisticModel(1) v_mean = model.mean([1, 10], [5, 10]) self.assertEqual(v_mean[0], 10 / (1 + 9 * np.exp(-5))) self.assertEqual(v_mean[1], 10 / (1 + 9 * np.exp(-10))) - # Check model variance is not implemented - times = np.linspace(0, 100, 101) - parameters = [0.1, 50] - self.assertRaises(NotImplementedError, model.variance, - parameters, times) - if __name__ == '__main__': unittest.main() diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py index a429108900..7d5c081297 100644 --- a/pints/toy/stochastic/__init__.py +++ b/pints/toy/stochastic/__init__.py @@ -9,3 +9,4 @@ from ._markov_jump_model import MarkovJumpModel # noqa from ._michaelis_menten_model import MichaelisMentenModel # noqa from ._degradation_model import DegradationModel # noqa +from ._logistic_model import LogisticModel # noqa diff --git a/pints/toy/stochastic/_logistic_model.py b/pints/toy/stochastic/_logistic_model.py new file mode 100644 index 0000000000..e8a8a08d5c --- /dev/null +++ b/pints/toy/stochastic/_logistic_model.py @@ -0,0 +1,99 @@ +# +# Stochastic logistic toy model. +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +from . import MarkovJumpModel + +import numpy as np + + +class LogisticModel(MarkovJumpModel): + r""" + This model describes the growth of a population of individuals, where the + birth rate per capita, initially :math:`b_0`, decreases to :math:`0` as the + population size, :math:`\mathcal{C}(t)`, starting from an initial + population size, :math:`n_0`, approaches a carrying capacity, :math:`k`. + This process follows a rate according to [1]_ + + .. math:: + A \xrightarrow{b_0(1-\frac{\mathcal{C}(t)}{k})} 2A. + + The model is simulated using the Gillespie stochastic simulation algorithm + [2]_, [3]_. + + *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + + Parameters + ---------- + initial_molecule_count : float + Sets the initial population size :math:`n_0`. + + References + ---------- + .. [1] Simpson, M. et al. 2019. Process noise distinguishes between + indistinguishable population dynamics. bioRxiv. + https://doi.org/10.1101/533182 + .. [2] Gillespie, D. 1976. A General Method for Numerically Simulating the + Stochastic Time Evolution of Coupled Chemical Reactions. + Journal of Computational Physics. 22 (4): 403-434. + https://doi.org/10.1016/0021-9991(76)90041-3 + .. [3] Erban R. et al. 2007. A practical guide to stochastic simulations + of reaction-diffusion processes. arXiv. + https://arxiv.org/abs/0704.1908v2 + """ + def __init__(self, initial_molecule_count=50): + V = [[1]] + init_list = [initial_molecule_count] + super(LogisticModel, self).__init__(init_list, + V, self._propensities) + + def n_parameters(self): + """ + Default value must be overwritten because the number of parameters + does not correspond with the number of equations. + """ + return 2 + + @staticmethod + def _propensities(xs, ks): + return [ + ks[0] * (1 - xs[0] / ks[1]) * xs[0], + ] + + def mean(self, parameters, times): + r""" + Computes the deterministic mean of infinitely many stochastic + simulations with times :math:`t` and parameters (:math:`b`, :math:`k`), + which follows: + :math:`\frac{kC(0)}{C(0) + (k - C(0)) \exp(-bt)}`. + + Returns an array with the same length as `times`. + """ + parameters = np.asarray(parameters) + if len(parameters) != self.n_parameters(): + raise ValueError('This model should have only 2 parameters.') + + b = parameters[0] + if b <= 0: + raise ValueError('Rate constant must be positive.') + + k = parameters[1] + if k <= 0: + raise ValueError("Carrying capacity must be positive") + + times = np.asarray(times) + if np.any(times < 0): + raise ValueError('Negative times are not allowed.') + c0 = self._V[0][0] + return (c0 * k) / (c0 + np.exp(-b * times) * (k - c0)) + + def suggested_parameters(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + return np.array([0.1, 500]) + + def suggested_times(self): + """ See :meth:`pints.toy.ToyModel.suggested_times()`.""" + return np.linspace(0, 100, 101) From a8d1f4efc38f61294d71f1f8f42ee8304123f25a Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 17:00:31 +0000 Subject: [PATCH 19/41] finished ipynb for logistic model --- examples/toy/model-stochastic-logistic-growth.ipynb | 13 +++++++------ pints/toy/stochastic/_logistic_model.py | 2 +- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/examples/toy/model-stochastic-logistic-growth.ipynb b/examples/toy/model-stochastic-logistic-growth.ipynb index 1ccd30e0e5..4efb82e988 100644 --- a/examples/toy/model-stochastic-logistic-growth.ipynb +++ b/examples/toy/model-stochastic-logistic-growth.ipynb @@ -29,6 +29,7 @@ "source": [ "import pints\n", "import pints.toy\n", + "import pints.toy.stochastic\n", "import matplotlib.pyplot as plt\n", "import numpy as np" ] @@ -47,7 +48,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAX1UlEQVR4nO3de9RddX3n8fdHELRojECkkZAJrSw7EStqFKx0FoLOAKJxHAreWmSwzJpaxZnOVO2sNVJrV2Xa8V4ZUlFDvSBLRZh6mbIw3ipkTASlgq6mSiCZQFAuIiqKfuePvR84xhNyTp5zP+/XWs96zv6dfZ7zPWvD+eb7++7926kqJEna1UPGHYAkaTKZICRJXZkgJEldmSAkSV2ZICRJXe077gAG5eCDD65Vq1aNOwxJmiqbN2/+blUt6/bczCSIVatWsWnTpnGHIUlTJcnW3T3nFJMkqSsThCSpKxOEJKkrE4QkqSsThCSpq5EliCQ3JrkuybVJNrVjBya5Isk/tb8f3Y4nyTuSbEny9SRPGVWckqTGqCuIZ1XVUVW1pt1+HXBlVR0BXNluA5wEHNH+nA2cP+I4JWnujfs6iLXAce3j9cDngNe24xdVsxb51UmWJlleVTvGEqUkLdKHNt7EZdduH8rfXv3YJbzheU8Y+N8dZYIo4O+TFHBBVa0DDun40r8FOKR9fChwc8drt7Vjv5AgkpxNU2GwcuXKIYYuaVYM84v6wWz8zu0AHH34gSN/7701ygRxbFVtT/IY4Iok3+x8sqqqTR49a5PMOoA1a9Z45yOpT+P6shyncX1RH334gaw96lBecvT0/GN2ZAmiqra3v3cmuRR4OnDrwtRRkuXAznb37cBhHS9f0Y5JehD9fuFP479qF2sav6jHZSQJIskBwEOq6u728b8G3ghcDpwBvLn9fVn7ksuBP0xyMXA0cJf9B6m7zqTQ7xe+X5Z6MKOqIA4BLk2y8J4fqqrPJPkKcEmSs4CtwGnt/p8CTga2AD8EzhxRnNJU2F1S8AtfgzSSBFFV3wae1GX8e8AJXcYLeOUIQpOm0mXXbuf6Hd9n9fIlJgUNzbhPc5XUo86qYSE5fOQ/PGPMUWmWmSCkCba7qaTVy5ew9qhDxxma5oAJQppgTiVpnEwQ0oRzKknjYoKQJky3XoM0DiYIaQLYa9AkMkFIY+K1DJp0JghphEwKmiYmCGmEPCtJ08QEIQ3RrovneYGbpon3pJaGaKFiWGDTWdPECkIaMisGTSsThDRgXsegWeEUkzRgndNKTilpmllBSAPgSquaRSYIaS959bNmnQlC2kte06BZZ4KQ+uBUkuaJTWqpDzagNU+sIKQ+WTVoXpggpD3wugbNKxOE1IVnKEkmCKkrz1CSTBDSbtlr0LwzQUgtew3SL/I0V6nlKazSL7KC0Fzzwjdp96wgNNesGqTds4LQ3LNqkLqzgpAkdWUFobnj2UpSb6wgNHfsO0i9sYLQXLLvIO2ZCUJzwWklqX9OMWkuOK0k9W+kFUSSfYBNwPaqOiXJ4cDFwEHAZuB3q+onSfYHLgKeCnwPOL2qbhxlrJo9TitJ/Rl1BXEOcEPH9nnAW6vqccAdwFnt+FnAHe34W9v9pL58aONNnH7BVZx+wVX3Vw+SejeyBJFkBfBc4D3tdoDjgY+2u6wHXtA+Xttu0z5/Qru/1DOnlaTFGeUU09uAPwYe2W4fBNxZVfe129uAhf+DDwVuBqiq+5Lc1e7/3c4/mORs4GyAlStdq1+/zGklae+NpIJIcgqws6o2D/LvVtW6qlpTVWuWLVs2yD8tSXNvVBXEM4HnJzkZeBiwBHg7sDTJvm0VsQLY3u6/HTgM2JZkX+BRNM1q6UF5Oqs0OCOpIKrq9VW1oqpWAS8CPltVLwU2AKe2u50BXNY+vrzdpn3+s1VVo4hV082+gzQ4475Q7rXAxUneBFwDXNiOXwj8bZItwO00SUXqyns6SMMx8gRRVZ8DPtc+/jbw9C77/Bj4nZEGpqm1UDWsXr7EqkEaoHFXENJAWDVIg9d3DyLJAe0V0ZKkGbbHCiLJQ2h6AC8FngbcC+yf5LvAJ4ELqmrLUKOUduHZStLw9VJBbAB+HXg98KtVdVhVPQY4FrgaOC/Jy4YYo/RLPFtJGr5eehDPrqqf7jpYVbcDHwM+luShA49M2gP7DtJw7bGC2DU5dOtBdEsgkqTptscEkeQhSV6S5JNJdgLfBHYkuT7JXyZ53PDDlCSNmj0ISVJXPfcgkqyqqp8vDNqDkKTZtscE0dFf+DjwlM7nkhxTVVfbg9AoeGqrNFq99CBOS/Jm4JFJ/mV7XcSCdcMLTfpFntoqjVYvU0z/QLNE9yuAtwCPT3In8P+AHw0xNumXeGqrNDq9TDFtBy5K8s9V9Q8ASQ4CVtGc0SQNjdNK0vj0MsUUgIXk0D7+XlVtrqp7OveRBs1pJWl8epli2pDkY8BlVXXTwmCS/WhOdT2D5lTY9w8lQs09p5Wk8eglQZwI/Hvgw0kOB+6k6UnsA/w98LaqumZ4IWreOK0kTYZeehA/Bt4NvLu93uFg4EdVdeewg9N88gZA0mTo64ZB7fUOOxa2kyw1UWgYnFaSxq+nBJHkAOAJwJEdv48EDgCWDi06SdLY9HLDoBuBhwLX05zWegPwYuCoqto51OgkSWPTSwXxv4HjgL+pqksAkvxXk4MGyca0NHl6uR/Eq4BTgJOTfCXJSUANPTLNFa93kCZPTz2IqtoKvDzJE4A/A341ybOqasNQo9NcsTEtTZZe7gdxv6r6RlW9EHgW8N+SfH44YUmSxq2XJnWq6hemlKpqI/DsJCfsbh9pT+w7SJOtpzvKJXlVkpWdg+1SGyRZT7PchtQX+w7SZHOpDY2VfQdpcrnUhiSpq0UttSH1y76DND36OotJWiz7DtL06KuCkAbBvoM0HXpOEEn2B/4dza1G739dVb1x8GFJksatnwriMuAuYDNw73DCkSRNin4SxIqqOnFokUiSJko/TeovJ3ni0CKRJE2UfhLEscDmJN9K8vUk1yX5ei8vTPKwJP83ydeSfCPJn7bjhyfZmGRLko90XJ29f7u9pX1+Vb8fTJK0OP1MMZ20iPe5Fzi+qn7QXmz3pSSfBv4z8NaqujjJ/wLOAs5vf99RVY9L8iLgPOD0Rby/JKlPPSeIqtqa5EnAb7dDX6yqr/X42gJ+0G4+tP0p4HjgJe34euBcmgSxtn0M8FHgXS4IOL28OE6aTj1PMSU5B/gg8Jj25wNJXtXH6/dJci2wE7gC+Gfgzqq6r91lG7Bw1dShwM0A7fN3AQd1+ZtnJ9mUZNNtt93WaygaMS+Ok6ZTP1NMZwFHV9U9AEnOA64C3tnLi6vqZ8BRSZYClwK/0Wes3f7mOmAdwJo1a6wuJpgXx0nTp58mdYCfdWz/rB3rS7vI3wbgGcDSJAtJagWwvX28HTgMoH3+UcD3+n0vSdLe6ydBvA/YmOTcJOcCVwMX9vLCJMvayoEkDweeA9xAkyhObXc7g+ZiPIDLeeAeE6cCn7X/IEmj1U+T+i3tLUaf2Q6d2cd9IJYD65PsQ5OULqmqv0tyPXBxkjcB1/BAwrkQ+NskW4DbgRf1GqckaTD6Xe57M81SG32pqq8DT+4y/m3g6V3Gfwz8Tr/vI0kanF7uSf2lqjo2yd00p6be/xTNGayesyhJM6iXO8od2/5+5PDDkSRNin6W+z6vql67pzEJvDhOmgX9nMX0nC5ji1l+QzPMi+Ok6ddLD+I/An8A/Noui/M9EvjysALT9PPiOGm69TLF9CHg08BfAK/rGL+7qm4fSlSSpLHrpUl9F81aSC9O8mjgCOBhAEmoqi8MN0RJ0jj006R+BXAOzZIY1wLH0KzFdPxwQtM06WxKg41paRb006Q+B3gasLWqnkVz4dudQ4lKU6ezKQ02pqVZ0M+V1D+uqh8nIcn+VfXNJI8fWmSaOjalpdnST4LY1i649wngiiR3AFuHE5Ykadx6ShBJAry6Xar73CQbaJbg/swwg5MkjU9PCaKqKsmngCe2258falSSpLHrp0n91SRPG1okkqSJ0k8P4mjgpUm2AvfwwGquvzmUyCRJY9VPgvg3Q4tCU8kF+aTZ1s8U0x9U1dbOH5o1mjSnXJBPmm39VBDPAXZd2vukLmOaI177IM2uvV3NNcAjcDXXueO0kjQ/XM1VfVmYVlq9fInTStKM63k11yRnAi8EVi28rl3N9Y1DjVATx2klaT7004P4BM2y35uBe4cTjiRpUvSTIFZU1YlDi0QTy76DNJ/6Oc31y0meOLRINLE8nVWaT/1UEMcCL0/yHZopJq+kniP2HaT500+COGloUUiSJk7PCaK9clpzwr6DpJ57EGm8LMl/b7dXJnn68ELTONl3kNTPFNO7gZ8DxwNvBO4GPkZzn2rNIPsO0nzra7nvqnpKkmsAquqOJPsNKS5J0pj1kyB+mmQfoACSLKOpKDQj7DtI6tTPdRDvAC4FHpPkz4Ev0azPpBlh30FSp37OYvpgks3ACTTXQLygqm4YWmQaC/sOkhb0cxbTeuCWqvrrqnoXcEuS9w4vNEnSOPUzxfSbVXXnwkZV3QE8efAhSZImQT9N6ockeXSbGEhyYK+vT3IYcBFwCE2Te11Vvb39Gx+hWUL8RuC09uyoAG8HTgZ+CLy8qr7aR6zqkY1pSbvTTwXxP4Grk/xZkjfR3E3uL3t87X3AH1XVauAY4JVJVtPcgOjKqjoCuJIHbkh0EnBE+3M2cH4fcaoPNqYl7U4/TeqLkmyiuVCugBdW1fU9vnYHsKN9fHeSG4BDgbXAce1u64HP0dzjei1wUVUVTVJammR5+3c0YDamJXXTT5N6f+AoYAlwEHDqwrIb/UiyiqZ3sRE4pONL/xaaKShoksfNHS/b1o7t+rfOTrIpyabbbrut31AkSQ+inymmy2j+ZX8fcE/HT8+SPIJmeY7XVNX3O59rq4Xq5+9V1bqqWlNVa5YtW9bPSyVJezCyO8oleShNcvhgVX28Hb51YeooyXJgZzu+HTis873bMQ2AjWlJvRjJHeXas5IuBG6oqrd0PHU5cEb7+AyaKmVh/PfaFWSPAe6y/zA4NqYl9WJUd5R7JvC7wHVJrm3H/gR4M3BJkrOArcBp7XOfojnFdQvNaa5n9hGnemBjWtKejOSOclX1JZqE0s0JXfYv4JV7+36SpMXzjnJzwr6DpH71U0GQ5EnAb7ebX6yqrw0+JA3DQt9h9fIl9h0k9aTnBJHkHOD3gYUzkD6QZF1VvXMokWng7DtI6kc/FcRZNHeVuwcgyXnAVYAJQpJmUD+nuQb4Wcf2z9h941mSNOX6qSDeB2xMcmm7/QKaaxs0oWxMS1qMPSaIJI+jWTPpLUk+R3M9BMCr8ermiWZjWtJi9FJBvA14PUB7T4avArRXVb8NeN7QotOi2ZiWtLd66UEcUlXX7TrYjq0aeESSpInQS4JY+iDPPXxQgUiSJksvU0ybkvx+Vf1N52CSVwCbhxOW9paNaUmD0kuCeA1waZKX8kBCWAPsB/zbYQWmvWNjWtKg7DFBVNWtwG8leRZwZDv8yar67FAj016zMS1pEPpZrG8DsGGIsWgvOa0kaRj6uZJaE8obAEkahr5Wc9Xk6FY1OK0kaZCsIKaUVYOkYbOCmGJWDZKGyQpCktSVFcQU8WwlSaNkBTFF7DtIGiUriClj30HSqFhBSJK6MkFIkrpyimnC2ZiWNC5WEBPOxrSkcbGCmAI2piWNgwliAjmtJGkSOMU0gZxWkjQJrCAmlNNKksbNBDEhnFaSNGmcYpoQTitJmjRWEBPEaSVJk8QEMUZOK0maZE4xjZHTSpIm2UgqiCTvBU4BdlbVke3YgcBHgFXAjcBpVXVHkgBvB04Gfgi8vKq+Ooo4x8FpJUmTalQVxPuBE3cZex1wZVUdAVzZbgOcBBzR/pwNnD+iGEfiQxtv4vQLruL0C666v3qQpEk0kgRRVV8Abt9leC2wvn28HnhBx/hF1bgaWJpk+SjiHAWnlSRNi3E2qQ+pqh3t41uAQ9rHhwI3d+y3rR3bwS6SnE1TZbBy5crhRTpgTitJmgYTcRZTVVWS2ovXrQPWAaxZs6bv14+KZytJmkbjPIvp1oWpo/b3znZ8O3BYx34r2rGp5bSSpGk0zgricuAM4M3t78s6xv8wycXA0cBdHVNRU8tpJUnTZlSnuX4YOA44OMk24A00ieGSJGcBW4HT2t0/RXOK6xaa01zPHEWMg+a0kqRpN5IEUVUv3s1TJ3TZt4BXDjei4VuYVlq9fInTSpKm0kQ0qWeV00qSpplLbUiSurKCGCD7DpJmiRXEAHk6q6RZYgWxSN2qBvsOkmaBFcQiWTVImlVWEH3qrBjAqkHS7LKC6FNnxQBWDZJmlxXEXrBikDQPTBA98PRVSfPIKaYe2IiWNI+sIDrs2oBeYCNa0jyyguiwawN6gVWDpHlkBbELKwVJasx9grABLUndzf0U02XXbmfjd24HnEqSpE5zX0GsfuwSVj92CW943hPGHYokTZS5TxAmBknqbu6nmCRJ3ZkgJEldmSAkSV2ZICRJXZkgJEldmSAkSV2ZICRJXZkgJEldparGHcNAJLkN2LqXLz8Y+O4Aw5kGfub54GeeD4v5zP+iqpZ1e2JmEsRiJNlUVWvGHcco+Znng595PgzrMzvFJEnqygQhSerKBNFYN+4AxsDPPB/8zPNhKJ/ZHoQkqSsrCElSVyYISVJXc58gkpyY5FtJtiR53bjjGYYkhyXZkOT6JN9Ick47fmCSK5L8U/v70eOOdZCS7JPkmiR/124fnmRje6w/kmS/ccc4SEmWJvlokm8muSHJM+bgGP+n9r/pf0zy4SQPm7XjnOS9SXYm+ceOsa7HNY13tJ/960mespj3nusEkWQf4K+Bk4DVwIuTrB5vVENxH/BHVbUaOAZ4Zfs5XwdcWVVHAFe227PkHOCGju3zgLdW1eOAO4CzxhLV8Lwd+ExV/QbwJJrPPrPHOMmhwKuBNVV1JLAP8CJm7zi/Hzhxl7HdHdeTgCPan7OB8xfzxnOdIICnA1uq6ttV9RPgYmDtmGMauKraUVVfbR/fTfPFcSjNZ13f7rYeeMF4Ihy8JCuA5wLvabcDHA98tN1l1j7vo4B/BVwIUFU/qao7meFj3NoXeHiSfYFfAXYwY8e5qr4A3L7L8O6O61rgompcDSxNsnxv33veE8ShwM0d29vasZmVZBXwZGAjcEhV7WifugU4ZExhDcPbgD8Gft5uHwTcWVX3tduzdqwPB24D3tdOq70nyQHM8DGuqu3AXwE30SSGu4DNzPZxXrC74zrQ77R5TxBzJckjgI8Br6mq73c+V835zjNxznOSU4CdVbV53LGM0L7AU4Dzq+rJwD3sMp00S8cYoJ13X0uTHB8LHMAvT8XMvGEe13lPENuBwzq2V7RjMyfJQ2mSwwer6uPt8K0L5Wf7e+e44huwZwLPT3IjzbTh8TTz80vbqQiYvWO9DdhWVRvb7Y/SJIxZPcYAzwa+U1W3VdVPgY/THPtZPs4LdndcB/qdNu8J4ivAEe1ZD/vRNLguH3NMA9fOv18I3FBVb+l46nLgjPbxGcBlo45tGKrq9VW1oqpW0RzTz1bVS4ENwKntbjPzeQGq6hbg5iSPb4dOAK5nRo9x6ybgmCS/0v43vvCZZ/Y4d9jdcb0c+L32bKZjgLs6pqL6NvdXUic5mWa+eh/gvVX152MOaeCSHAt8EbiOB+bk/4SmD3EJsJJmqfTTqmrXZthUS3Ic8F+q6pQkv0ZTURwIXAO8rKruHWd8g5TkKJqm/H7At4Ezaf4ROLPHOMmfAqfTnKl3DfAKmjn3mTnOST4MHEezpPetwBuAT9DluLaJ8l00U20/BM6sqk17/d7zniAkSd3N+xSTJGk3TBCSpK5MEJKkrkwQkqSuTBCSpK5MEFKfkhyU5Nr255Yk29vHP0jy7nHHJw2Kp7lKi5DkXOAHVfVX445FGjQrCGlAkhzXce+Jc5OsT/LFJFuTvDDJ/0hyXZLPtEufkOSpST6fZHOS/7OYlTelQTNBSMPz6zTrQD0f+ACwoaqeCPwIeG6bJN4JnFpVTwXeC8zclfyaXvvueRdJe+nTVfXTJNfRLOXymXb8OmAV8HjgSOCKZoUE9qFZtlqaCCYIaXjuBaiqnyf5aT3Q8Ps5zf97Ab5RVc8YV4DSg3GKSRqfbwHLkjwDmiXZkzxhzDFJ9zNBSGPS3ub2VOC8JF8DrgV+a7xRSQ/wNFdJUldWEJKkrkwQkqSuTBCSpK5MEJKkrkwQkqSuTBCSpK5MEJKkrv4/rlfX08Vi+jgAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYT0lEQVR4nO3de/TcdX3n8edLELRYDAGkMZBNWjl24w0xGqjsHgRtwVtYl4q3Sllc9rSu4m67VbvnrK61Z2XbVapVChU11AuyKMJ627IY75BjIhQU7DGCQNJAohjEC6jw3j++3x+M6fySmWRuv5nn45w5M9/PzPzmPecL88778/58v99UFZIk7exh4w5AkjSZTBCSpK5MEJKkrkwQkqSuTBCSpK72HXcAg3LIIYfU8uXLxx2GJC0oGzdu/F5VHdrtualJEMuXL2fDhg3jDkOSFpQkt873nFNMkqSuTBCSpK5MEJKkrkwQkqSuTBCSpK5GliCSfDfJDUmuS7KhHVuc5Mok327vD2rHk+SdSTYluT7J0aOKU5LUGHUF8ayqOqqqVrXbbwCuqqojgavabYCTgSPb21nAeSOOU5Jm3riPg1gDHN8+Xgt8Hnh9O35RNecivybJoiRLqmrrWKKUpD3w4fW3cfl1W4b+OSsfeyBvesETBv53R5kgCvj7JAWcX1UXAId1/OjfARzWPl4K3N7x3s3t2C8liCRn0VQYLFu2bIihS1poRvXjvCvrb7kLgNUrFo81jj01ygRxXFVtSfIY4Mok3+p8sqqqTR49a5PMBQCrVq3yykfSBJiEH2aYjB/n1SsWs+aopbxs9cL8B+zIEkRVbWnvtyW5DHgGcOfc1FGSJcC29uVbgCM63n54OyZpQsyXCCbhh3nu8xfyj/MkGEmCSHIA8LCquqd9/NvAW4ArgNOBt7X3l7dvuQL4j0kuBlYDd9t/kAZvb/61P18i8Id5eoyqgjgMuCzJ3Gd+uKo+m+RrwCVJzgRuBV7cvv7TwHOBTcBPgDNGFKe0IAxqGmdv/rVvIph+I0kQVXUz8JQu498HTuwyXsCrRxCatGB0JoVBTeP4I69dGfcyV0m7MF9S8Iddo2CCkCaMSUGTwgQhDdGe9ApMCpoUJghpiC6/bgs3bv0hK5cc2PN7TAqaFCYIachWLjmQj/6HY8cdhtQ3E4Q0APNNJfVbPUiTxOtBSAMwN5W0s5VLDmTNUUvHEJG096wgpD3UWTXMVQpOJWmaWEFIe6izarBS0DSygpB2Y3f9BasGTSsrCGk37C9oVllBSD2wUtAsMkFIXXRrQEuzxikmqQsb0JIVhDQvp5U060wQUstpJemXOcUktZxWkn6ZFYRmmkdDS/OzgtBMs2qQ5mcFoZln1SB1Z4LQzLEZLfXGKSbNHKeVpN5YQWgmOa0k7Z4VhCSpKysIzQT7DlL/rCA0E+w7SP2zgtDMsO8g9ccEoanltJK0d0wQmiqdSWH9LXcBsHrFYqeVpD1ggtBUmes1rFxyIKtXLGbNUUt52epl4w5LWpBMEJo69hqkwXAVkySpKysILXg2o6XhsILQgucxDtJwWEFoQfJCP9LwjbSCSLJPkmuTfLLdXpFkfZJNST6aZL92fP92e1P7/PJRxqnJZ9UgDd+oK4izgZuAuUnic4B3VNXFSf4GOBM4r73/QVU9LslL2tedNuJYNeGsGqThGlkFkeRw4HnAe9vtACcAl7YvWQuc0j5e027TPn9i+3pJ0oiMcorpXOBPgAfa7YOBHVX1i3Z7MzA3T7AUuB2gff7u9vW/JMlZSTYk2bB9+/Yhhi5Js2ckU0xJng9sq6qNSY4f1N+tqguACwBWrVpVg/q7mkwuZ5VGa1QVxDOBFyb5LnAxzdTSXwGLkswlqcOBLe3jLcARAO3zjwa+P6JYNaFsTEujNZIKoqreCLwRoK0g/riqXp7kfwOn0iSN04HL27dc0W5f3T7/uaqyQpCNaWmExn0cxOuBi5O8FbgWuLAdvxD4uySbgLuAl4wpPo2Z00rS+Iw8QVTV54HPt49vBp7R5TX3Ar870sA0kTrPzuq0kjRa464gpN1yWkkaj74TRJIDgHur6v4hxCM5rSRNiN2uYkrysCQvS/KpJNuAbwFbk9yY5C+SPG74YWqWuFpJmgy9VBDrgP9HswrpG1X1AECSxcCzgHOSXFZVHxxemJo1TitJ49dLgnh2Vf1858Gqugv4GPCxJA8feGSSpLHa7RTTzskhyQFJ9tnVayRJC99uK4gkD6M5DuHlwNOB+4D9k3wP+BRwflVtGmqUmno2pqXJ08upNtYBv0HTg/i1qjqiqh4DHAdcQ9ODeMUQY9QMsDEtTZ6eexBJls81qMEehAbPxrQ0WXabIDr6Cx8Hju58LskxVXWNPQjtCaeVpMnWy3EQL07yNuBXk/zLticx54LhhaZp57SSNNl6mWL6CvAI4FXA24HHJ9kB/BPw0+GFplngtJI0uXqZYtoCXJTkO1X1FYAkBwPLaY6qliRNoV6WuaYaX5kbq6rv03EBn7nXDClGSdIY9LTMNclrkizrHEyyX5ITkqylubiPJGmK9NKDOAn4d8BHkqwAdtD0JPYB/h44t6quHVqEkqSx6KUHcS/wHuA97fEOhwA/raodQ45NkjRGfV0Poj3eYevcdpJFJgr1w2MfpIWjpwTRXiToCcATO+6fCBwALBpWcJoOnUlh/S13AbB6xWKPfZAmXC+rmL4LPBy4kWZZ603AS4GjqmrbUKPTVOi8rvTqFYtZc9RSXrZ62e7fKGmseqkg/g9wPPC3VXUJQJL/YnLQrnSbSvKAOGlh6eV6EK8Bng88N8nXkpwMeMyDdsnTaEgLX089iKq6Ffj9JE8A/gz4tSTPqqp1Q41OC5pVg7Sw9XKg3IOq6ptV9SKaa1H/1yRfGE5YkqRx6/lUG51jVbUeeHaSE+d7jSRpYetlimldko8Bl1fVbXODSfZr79fSXHXuA0OJUAtCZ1MaPMZBmga9TDGdBNxPc6qNf0pyY5KbgW/TXKv63Kr6wBBj1ALQ2ZQGG9PSNPBUGxoYm9LSdNmrU21IkqZXXwlC6uR5laTp1tcyV6mTB8NJ063nCiLJ/sC/pbnU6IPvq6q3DD4sLRT2HaTp1c8U0+XA3cBG4L7hhCNJmhT9JIjDq+qkoUWiBcG+gzQ7+ulBfDXJk4YWiRYE+w7S7OingjiO5oR9t9BMMQWoqnry7t6Y5BHAF4H928+8tKre1F7j+mLgYJqpq9+rqp+1/Y6LgKcB3wdOq6rv9hGrhsi+gzQb+kkQJ+/F59wHnFBVP2oPtvtyks8A/xl4R1VdnORvgDOB89r7H1TV45K8BDgHOG0vPl+S1Keep5jaU34vAl7Q3ha1Y728t6rqR+3mw9tbAScAl7bja4FT2sdr2m3a509Mkl5jlSTtvZ4TRJKzgQ8Bj2lvH0zymj7ev0+S64BtwJXAd4AdVfWL9iWbgbkJ7aXA7QDt83fTTEPt/DfPSrIhyYbt27f3GookqQf9TDGdCayuqh8DJDkHuBp4Vy9vrqr7gaOSLAIuA36zv1C7/s0LgAsAVq1a5enGJWmA+kkQoTmr65z727G+VNWOJOuAY4FFSfZtq4TDgbnzRW8BjgA2J9kXeDRNs1pj4NJWaTb1s8z1/cD6JG9O8mbgGuDCXt6Y5NC2ciDJI4HnADfRXEfi1PZlp9McjAdwRbtN+/znvCDR+Li0VZpNPVcQVfX29hKjz2yHzqiqa3t8+xJgbZJ9aJLSJVX1ySQ3AhcneStwLQ8lnAuBv0uyCbiL5roTGiOXtkqzp9/TfW+kOV6hL1V1PfDULuM3A8/oMn4v8Lv9fo4kaXB6uSb1l6vquCT30CxNffApmhWsTkhL0hTq5Ypyx7X3vzr8cCRJk6Kf4yDO6WVMkjQd+ulBPAd4/U5jJ3cZ0xRwaauk3VYQSf4gyQ3A45Nc33G7Bbhh+CFqHFzaKqmXCuLDwGeA/wG8oWP8nqq6ayhRaSK4tFWabb00qe+mORfSS5McBBwJPAIgCVX1xeGGKEkah36uSf0q4GyaU2JcBxxDcy6mE4YSmUbOvoOkTv2cauNs4OnArVX1LJoD33YMIyiNh30HSZ36WcV0b1Xdm4Qk+1fVt5I8fmiRaSzsO0ia00+C2NyecO8TwJVJfgD0dMEgSdLC01OCaK/m9tqq2gG8uT1d96OBzw4xNknSGPWUIKqqknwaeFK7/YWhRiVJGrt+ppi+nuTpVfW1oUWjkXPlkqT59LOKaTVwdZLvtEdS35Dk+mEFptFw5ZKk+fRTQfzO0KLQWLlySVI3/VQQf1hVt3begD8cVmCSpPHqJ0E8p8vYyYMKRJI0WXq5otwf0FQKv97RcwjwKOCrQ4xNkjRGns11BrlySVIvej6ba5IzgBcBy+fe157N9S1DjVADN7dyaeWSA125JGle/axi+gTNab83AvcNJRqNjCuXJO1OPwni8Ko6aWiRaKicVpLUr35WMX01yZOGFomGygPiJPWrnwriOOD322tR30ezkqmq6slDiUwD57SSpH70kyA85kGSZkjPCaI9clqSNCN67kGk8Yok/63dXpbkGcMLTZI0Tv00qd8DHAu8tN2+B3j3wCOSJE2EfnoQq6vq6CTXAlTVD5LsN6S4JElj1k8F8fMk+wAFkORQ4IGhRCVJGrt+EsQ7gcuAxyT5c+DLNOdnkiRNoX5WMX0oyUbgRJpjIE6pqpuGFpn2mkdPS9ob/axiWgvcUVXvrqq/Bu5I8r7hhaa95dHTkvZGP03qJ1fVjrmNtkn91MGHpEHy6GlJe6qfHsTDkhw0t5FkMT0mmCRHJFmX5MYk30xy9tzfSHJlkm+39we140nyziSbklyf5Oh+vpQkae/1kyD+F3BNkj9L8laaq8n9RY/v/QXwR1W1EjgGeHWSlTQXILqqqo4EruKhCxKdDBzZ3s4CzusjTknSAPTTpL4oyQbgBJqlri+qqht7fO9WYGv7+J4kNwFLgTXA8e3L1gKfB17fjl9UVUWTlBYlWdL+He2CjWlJg9JPk3p/4CjgQOBg4NS50270I8ly4KnAeuCwjh/9O4DD2sdLgds73ra5Hdv5b52VZEOSDdu3b+83lKlkY1rSoPTTpL6cvbyiXJJHAR8DXldVP0zy4HNVVUmqn79XVRcAFwCsWrWqr/dOMxvTkgZhZFeUS/JwmuTwoar6eDt859zUUZIlwLZ2fAtwROdnt2OSpBEZyRXl0pQKFwI3VdXbO566Aji9fXw6TZUyN/7KdjXTMcDd9h/m9+H1t3Ha+Vdz2vlXPzi9JEl7a1RXlHsm8HvADUmua8f+FHgbcEmSM4FbgRe3z30aeC6wCfgJcEYfcc6cub7DyiUH2neQNDAjuaJcVX2ZJqF0c2KX1xfw6j39vFlk30HSoHlFOUlSV/1UECR5CvCv2s0vVdU/DD4k9cLjHSQNWz/HQZwNfAh4THv7YJLXDCsw7ZrHO0gatn4qiDNprir3Y4Ak5wBXA+8aRmDaPfsOkoapn2WuAe7v2L6f+RvPkqQFrp8K4v3A+iSXtdun0BzboBGx7yBplHabIJI8juacSW9P8nma4yEAXotHN4+UxztIGqVeKohzgTcCVNXXga8DtEdVnwu8YEixqQv7DpJGpZcexGFVdcPOg+3Y8oFHJEmaCL0kiEW7eO6RA4pDkjRhepli2pDk31fV33YOJnkVzam/NUQ2piWNSy8J4nXAZUlezkMJYRWwH/BvhhSXWjamJY3LbhNEVd0J/FaSZwFPbIc/VVWfG2pkepCNaUnj0M/J+tYB64YYiyRpgvRzJLUkaYaYICRJXfV1um+NhiuXJE0CK4gJ5Km8JU0CK4gJ5colSeNmBSFJ6soKYkLYd5A0aawgJoR9B0mTxgpigth3kDRJrCAkSV1ZQYyRfQdJk8wKYozsO0iaZFYQY2bfQdKkMkGMmNNKkhYKp5hGzGklSQuFFcQYOK0kaSGwgpAkdWUFMQL2HSQtRFYQI2DfQdJCZAUxIvYdJC00VhCSpK5GkiCSvC/JtiTf6BhbnOTKJN9u7w9qx5PknUk2Jbk+ydGjiFGS9MtGVUF8ADhpp7E3AFdV1ZHAVe02wMnAke3tLOC8EcU4UB9efxunnX81p51/9YP9B0laSEaSIKrqi8BdOw2vAda2j9cCp3SMX1SNa4BFSZaMIs5BsjEtaaEbZ5P6sKra2j6+AzisfbwUuL3jdZvbsa3sJMlZNFUGy5YtG16ke8jGtKSFbCKa1FVVQO3B+y6oqlVVterQQw8dQmSSNLvGWUHcmWRJVW1tp5C2teNbgCM6Xnd4OzbxPCBO0jQZZwVxBXB6+/h04PKO8Ve2q5mOAe7umIqaaPYdJE2TkVQQST4CHA8ckmQz8CbgbcAlSc4EbgVe3L7808BzgU3AT4AzRhHjnupWNdh3kDQNRpIgquql8zx1YpfXFvDq4Ua05zoTAsD6W5rFWatXLLZqkDRVPNVGn+amkeb6C6tXLGbNUUt52erJW0UlSXvDBLEHnEaSNAsmYpmrJGnyWEH0wOWrkmaRFUQPXL4qaRZZQfTIvoOkWWOCmIfTSpJmnVNM83BaSdKss4LYBaeVJM0yKwhJUlcmCElSV04xdbAxLUkPsYLoYGNakh5iBbETG9OS1Jj5BOG0kiR1N/NTTJdft+XBazo4rSRJD5n5CmLlYw9k5WMP5E0veMK4Q5GkiTLzCcLEIEndzfwUkySpOxOEJKkrE4QkqSsThCSpKxOEJKkrE4QkqSsThCSpKxOEJKmrVNW4YxiIJNuBW/fw7YcA3xtgOAuB33k2+J1nw958539RVYd2e2JqEsTeSLKhqlaNO45R8jvPBr/zbBjWd3aKSZLUlQlCktSVCaJxwbgDGAO/82zwO8+GoXxnexCSpK6sICRJXZkgJEldzXyCSHJSkn9MsinJG8YdzzAkOSLJuiQ3JvlmkrPb8cVJrkzy7fb+oHHHOkhJ9klybZJPttsrkqxv9/VHk+w37hgHKcmiJJcm+VaSm5IcOwP7+D+1/01/I8lHkjxi2vZzkvcl2ZbkGx1jXfdrGu9sv/v1SY7em8+e6QSRZB/g3cDJwErgpUlWjjeqofgF8EdVtRI4Bnh1+z3fAFxVVUcCV7Xb0+Rs4KaO7XOAd1TV44AfAGeOJarh+Svgs1X1m8BTaL771O7jJEuB1wKrquqJwD7AS5i+/fwB4KSdxubbrycDR7a3s4Dz9uaDZzpBAM8ANlXVzVX1M+BiYM2YYxq4qtpaVV9vH99D88OxlOa7rm1fthY4ZSwBDkGSw4HnAe9ttwOcAFzavmTavu+jgX8NXAhQVT+rqh1M8T5u7Qs8Msm+wK8AW5my/VxVXwTu2ml4vv26BrioGtcAi5Is2dPPnvUEsRS4vWN7czs2tZIsB54KrAcOq6qt7VN3AIeNK64hOBf4E+CBdvtgYEdV/aLdnrZ9vQLYDry/nVZ7b5IDmOJ9XFVbgL8EbqNJDHcDG5nu/Txnvv060N+0WU8QMyXJo4CPAa+rqh92PlfNeuepWPOc5PnAtqraOO5YRmhf4GjgvKp6KvBjdppOmqZ9DNDOu6+hSY6PBQ7gn0/FTL1h7tdZTxBbgCM6tg9vx6ZOkofTJIcPVdXH2+E758rP9n7buOIbsGcCL0zyXZppwxNo5ucXtVMRMH37ejOwuarWt9uX0iSMad3HAM8Gbqmq7VX1c+DjNPt+mvfznPn260B/02Y9QXwNOLJd9bAfTYPrijHHNHDt/PuFwE1V9faOp64ATm8fnw5cPurYhqGq3lhVh1fVcpp9+rmqejmwDji1fdnUfF+AqroDuD3J49uhE4EbmdJ93LoNOCbJr7T/jc9956ndzx3m269XAK9sVzMdA9zdMRXVt5k/kjrJc2nmq/cB3ldVfz7eiAYvyXHAl4AbeGhO/k9p+hCXAMtoTpX+4qrauRm2oCU5Hvjjqnp+kl+nqSgWA9cCr6iq+8YY3kAlOYqmKb8fcDNwBs0/Aqd2Hyf578BpNCv1rgVeRTPnPjX7OclHgONpTul9J/Am4BN02a9tovxrmqm2nwBnVNWGPf7sWU8QkqTuZn2KSZI0DxOEJKkrE4QkqSsThCSpKxOEJKkrE4TUpyQHJ7muvd2RZEv7+EdJ3jPu+KRBcZmrtBeSvBn4UVX95bhjkQbNCkIakCTHd1x74s1J1ib5UpJbk7woyf9MckOSz7anPiHJ05J8IcnGJP93b868KQ2aCUIant+gOQ/UC4EPAuuq6knAT4HntUniXcCpVfU04H3A1B3Jr4Vr392/RNIe+kxV/TzJDTSncvlsO34DsBx4PPBE4MrmDAnsQ3PaamkimCCk4bkPoKoeSPLzeqjh9wDN/3sBvllVx44rQGlXnGKSxucfgUOTHAvNKdmTPGHMMUkPMkFIY9Je5vZU4Jwk/wBcB/zWWIOSOrjMVZLUlRWEJKkrE4QkqSsThCSpKxOEJKkrE4QkqSsThCSpKxOEJKmr/w+hdX3m9YJx8AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -60,7 +61,7 @@ ], "source": [ "n_0 = 50\n", - "model = pints.toy.StochasticLogisticModel(n_0)\n", + "model = pints.toy.stochastic.LogisticModel(n_0)\n", "\n", "times = np.linspace(0, 100, 101)\n", "\n", @@ -89,7 +90,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -104,7 +105,7 @@ "def simulate_n(n):\n", " values = np.zeros(len(times))\n", " for i in range(n):\n", - " values += model.simulate(params,times) / n\n", + " values += model.simulate(params,times).reshape(-1) / n\n", " plt.plot(times, values, label=r'$n=%s$' % n)\n", " \n", "for i in range(5):\n", @@ -132,7 +133,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -169,7 +170,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/pints/toy/stochastic/_logistic_model.py b/pints/toy/stochastic/_logistic_model.py index e8a8a08d5c..10df3eda81 100644 --- a/pints/toy/stochastic/_logistic_model.py +++ b/pints/toy/stochastic/_logistic_model.py @@ -87,7 +87,7 @@ def mean(self, parameters, times): times = np.asarray(times) if np.any(times < 0): raise ValueError('Negative times are not allowed.') - c0 = self._V[0][0] + c0 = self._x0 return (c0 * k) / (c0 + np.exp(-b * times) * (k - c0)) def suggested_parameters(self): From bd08bf9bb1a0c7a19d5343583fbe5021a8fc4295 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 17:07:21 +0000 Subject: [PATCH 20/41] added docs + removed old version --- .../stochastic_logistic_model.rst | 2 +- pints/toy/__init__.py | 1 - pints/toy/_stochastic_logistic_model.py | 161 ------------------ 3 files changed, 1 insertion(+), 163 deletions(-) rename docs/source/toy/{ => stochastic}/stochastic_logistic_model.rst (74%) delete mode 100644 pints/toy/_stochastic_logistic_model.py diff --git a/docs/source/toy/stochastic_logistic_model.rst b/docs/source/toy/stochastic/stochastic_logistic_model.rst similarity index 74% rename from docs/source/toy/stochastic_logistic_model.rst rename to docs/source/toy/stochastic/stochastic_logistic_model.rst index a5fb8eec2a..cbd5f40403 100644 --- a/docs/source/toy/stochastic_logistic_model.rst +++ b/docs/source/toy/stochastic/stochastic_logistic_model.rst @@ -2,6 +2,6 @@ Stochastic Logistic Model ************************* -.. currentmodule:: pints.toy +.. currentmodule:: pints.toy.stochastic .. autoclass:: StochasticLogisticModel diff --git a/pints/toy/__init__.py b/pints/toy/__init__.py index 7fc8b1d376..b8aee2d88c 100644 --- a/pints/toy/__init__.py +++ b/pints/toy/__init__.py @@ -32,4 +32,3 @@ from ._simple_egg_box import SimpleEggBoxLogPDF from ._sir_model import SIRModel from ._twisted_gaussian_banana import TwistedGaussianLogPDF -from ._stochastic_logistic_model import StochasticLogisticModel diff --git a/pints/toy/_stochastic_logistic_model.py b/pints/toy/_stochastic_logistic_model.py deleted file mode 100644 index 89734d917a..0000000000 --- a/pints/toy/_stochastic_logistic_model.py +++ /dev/null @@ -1,161 +0,0 @@ -# -# Stochastic logistic model. -# -# This file is part of PINTS (https://github.com/pints-team/pints/) which is -# released under the BSD 3-clause license. See accompanying LICENSE.md for -# copyright notice and full license details. -# -import numpy as np -from scipy.interpolate import interp1d -import pints - -from . import ToyModel - - -class StochasticLogisticModel(pints.ForwardModel, ToyModel): - r""" - This model describes the growth of a population of individuals, where the - birth rate per capita, initially :math:`b_0`, decreases to :math:`0` as the - population size, :math:`\mathcal{C}(t)`, starting from an initial - population size, :math:`n_0`, approaches a carrying capacity, :math:`k`. - This process follows a rate according to [1]_ - - .. math:: - A \xrightarrow{b_0(1-\frac{\mathcal{C}(t)}{k})} 2A. - - The model is simulated using the Gillespie stochastic simulation algorithm - [2]_, [3]_. - - *Extends:* :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. - - Parameters - ---------- - initial_molecule_count : float - Sets the initial population size :math:`n_0`. - - References - ---------- - .. [1] Simpson, M. et al. 2019. Process noise distinguishes between - indistinguishable population dynamics. bioRxiv. - https://doi.org/10.1101/533182 - .. [2] Gillespie, D. 1976. A General Method for Numerically Simulating the - Stochastic Time Evolution of Coupled Chemical Reactions. - Journal of Computational Physics. 22 (4): 403-434. - https://doi.org/10.1016/0021-9991(76)90041-3 - .. [3] Erban R. et al. 2007. A practical guide to stochastic simulations - of reaction-diffusion processes. arXiv. - https://arxiv.org/abs/0704.1908v2 - """ - - def __init__(self, initial_molecule_count=50): - super(StochasticLogisticModel, self).__init__() - self._n0 = float(initial_molecule_count) - if self._n0 < 0: - raise ValueError('Initial molecule count cannot be negative.') - - def n_parameters(self): - """ See :meth:`pints.ForwardModel.n_parameters()`. """ - return 2 - - def _simulate_raw(self, parameters): - """ - Returns tuple (raw times, population sizes) when reactions occur. - """ - parameters = np.asarray(parameters) - if len(parameters) != self.n_parameters(): - raise ValueError('This model should have only 2 parameters.') - b = parameters[0] - k = parameters[1] - if b <= 0: - raise ValueError('Rate constant must be positive.') - - # Initial time and count - t = 0 - a = self._n0 - - # Run stochastic logistic birth-only algorithm, calculating time until - # next reaction and increasing population count by 1 at that time - mol_count = [a] - time = [t] - while a < k: - r = np.random.uniform(0, 1) - t += np.log(1 / r) / (a * b * (1 - a / k)) - a = a + 1 - time.append(t) - mol_count.append(a) - return time, mol_count - - def _interpolate_values(self, time, pop_size, output_times, parameters): - """ - Takes raw times and population size values as inputs and outputs - interpolated values at output_times. - """ - # Interpolate as step function, increasing pop_size by 1 at each - # event time point - interp_func = interp1d(time, pop_size, kind='previous') - - # Compute population size values at given time points using f1 - # at any time beyond the last event, pop_size = k - values = interp_func(output_times[np.where(output_times <= time[-1])]) - zero_vector = np.full( - len(output_times[np.where(output_times > time[-1])]), - parameters[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, pop_size = self._simulate_raw(parameters) - - # interpolate - values = self._interpolate_values(time, pop_size, times, parameters) - return values - - def mean(self, parameters, times): - r""" - Computes the deterministic mean of infinitely many stochastic - simulations with times :math:`t` and parameters (:math:`b`, :math:`k`), - which follows: - :math:`\frac{kC(0)}{C(0) + (k - C(0)) \exp(-bt)}`. - - Returns an array with the same length as `times`. - """ - parameters = np.asarray(parameters) - if len(parameters) != self.n_parameters(): - raise ValueError('This model should have only 2 parameters.') - - b = parameters[0] - if b <= 0: - raise ValueError('Rate constant must be positive.') - - k = parameters[1] - if k <= 0: - raise ValueError("Carrying capacity must be positive") - - times = np.asarray(times) - if np.any(times < 0): - raise ValueError('Negative times are not allowed.') - c0 = self._n0 - return (c0 * k) / (c0 + np.exp(-b * times) * (k - c0)) - - def variance(self, parameters, times): - r""" - Returns the deterministic variance of infinitely many stochastic - simulations. - """ - raise NotImplementedError - - def suggested_parameters(self): - """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ - return np.array([0.1, 500]) - - def suggested_times(self): - """ See :meth:`pints.toy.ToyModel.suggested_times()`.""" - return np.linspace(0, 100, 101) From a725f6c6a2151e546c119a2206cee7594ea1d4d4 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 17:13:54 +0000 Subject: [PATCH 21/41] updated docs --- docs/source/toy/stochastic/stochastic_logistic_model.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/toy/stochastic/stochastic_logistic_model.rst b/docs/source/toy/stochastic/stochastic_logistic_model.rst index cbd5f40403..4045e8c1ac 100644 --- a/docs/source/toy/stochastic/stochastic_logistic_model.rst +++ b/docs/source/toy/stochastic/stochastic_logistic_model.rst @@ -4,4 +4,4 @@ Stochastic Logistic Model .. currentmodule:: pints.toy.stochastic -.. autoclass:: StochasticLogisticModel +.. autoclass:: LogisticModel From 5022ad4bb05ce1d534a891d43a474d4bcd34145f Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 17:17:05 +0000 Subject: [PATCH 22/41] updated docs 2 --- docs/source/toy/index.rst | 1 - docs/source/toy/stochastic/index.rst | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/toy/index.rst b/docs/source/toy/index.rst index 36e0e9ca92..ae09649192 100644 --- a/docs/source/toy/index.rst +++ b/docs/source/toy/index.rst @@ -37,5 +37,4 @@ Some toy classes provide extra functionality defined in the simple_egg_box_logpdf simple_harmonic_oscillator_model sir_model - stochastic_logistic_model twisted_gaussian_logpdf diff --git a/docs/source/toy/stochastic/index.rst b/docs/source/toy/stochastic/index.rst index 586945bd24..1f1159f6e4 100644 --- a/docs/source/toy/stochastic/index.rst +++ b/docs/source/toy/stochastic/index.rst @@ -12,4 +12,5 @@ examples. markov_jump_model stochastic_degradation_model + stochastic_logistic_model stochastic_michaelis_menten_model From 09885029c2d1c001805940299be95c019cb2e1a2 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 18:29:45 +0000 Subject: [PATCH 23/41] added tests + the production and degradation model --- ...tochastic_production_degradation_model.rst | 7 + ...el-stochastic-production-degradation.ipynb | 172 ++++++++++++++++++ ...stochastic_production_degradation_model.py | 49 +++++ pints/toy/stochastic/__init__.py | 1 + .../_production_degradation_model.py | 49 +++++ 5 files changed, 278 insertions(+) create mode 100644 docs/source/toy/stochastic/stochastic_production_degradation_model.rst create mode 100644 examples/toy/model-stochastic-production-degradation.ipynb create mode 100644 pints/tests/test_toy_stochastic_production_degradation_model.py create mode 100644 pints/toy/stochastic/_production_degradation_model.py diff --git a/docs/source/toy/stochastic/stochastic_production_degradation_model.rst b/docs/source/toy/stochastic/stochastic_production_degradation_model.rst new file mode 100644 index 0000000000..05925fbd3c --- /dev/null +++ b/docs/source/toy/stochastic/stochastic_production_degradation_model.rst @@ -0,0 +1,7 @@ +******************************************* +Stochastic production and degradation model +******************************************* + +.. currentmodule:: pints.toy.stochastic + +.. autoclass:: ProductionDegradationModel diff --git a/examples/toy/model-stochastic-production-degradation.ipynb b/examples/toy/model-stochastic-production-degradation.ipynb new file mode 100644 index 0000000000..dff1c89e41 --- /dev/null +++ b/examples/toy/model-stochastic-production-degradation.ipynb @@ -0,0 +1,172 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stochastic production and degradation model\n", + "\n", + "This example shows how the stochastic production and degradation model can be used.\n", + "This model describes the stochastic process of two chemical reactions, in which the concentration of the substance increases at one rate and decreases by another.\n", + "Given an initial concentration of the substance, $n_0$, the substance degrades with rate $k_1$ while its concentration also increases at rate $k_2$ following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n", + " $$A \\xrightarrow{k_1} \\emptyset$$\n", + " $$\\emptyset \\xrightarrow{k_2} A$$\n", + "\n", + "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pints\n", + "import pints.toy.stochastic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZ1klEQVR4nO3de7SddX3n8fcHBC94ASRSCMRQRTvRpdGechltB0EpMNhYlwpBFG8T72KXbRfWWVK1dnSs2jqokEIUZwTxhqKCmqGsQSuiAZFLUEEUSYwkXiDxUjXynT/2c3BzeHbOzsnZe5/s836ttdd+nt9z++71wPnmeX63VBWSJE21y6gDkCTNTSYISVIrE4QkqZUJQpLUygQhSWp1n1EHMJv22WefWrx48ajDkKSdxlVXXfXjqlrQtm2sEsTixYtZs2bNqMOQpJ1Gklt7bfMVkySplQlCktTKBCFJamWCkCS1MkFIkloNLEEkOTDJZUnWJrkhyalN+d5JVie5qfneq8fxpzT73JTklEHFKUlqN8gniK3A66pqCXAY8MokS4DTgEur6mDg0mb9HpLsDZwOHAocApzeK5FIkgZjYAmiqjZU1dXN8hbgRmAhsAw4t9ntXOAZLYf/ObC6qn5aVT8DVgPHDCrWN33mBt70mRsGdXpJ2ikNpaNcksXAE4ArgX2rakOz6UfAvi2HLARu61pf15S1nXsFsAJg0aJFM4pv7Q83z+g4SRpnA6+kTvJA4BPAa6vqHn+JqzNb0Q7NWFRVK6tqoqomFixo7S0uSZqBgSaIJLvRSQ4frqpPNsW3J9mv2b4fsLHl0PXAgV3rBzRlkqQhGWQrpgDnADdW1bu6Nl0ETLZKOgX4dMvhXwCOTrJXUzl9dFMmSRqSQT5BPAl4HnBkkmuaz3HA24CnJbkJeGqzTpKJJGcDVNVPgbcAX28+b27KJElDMrBK6qr6MpAem49q2X8N8JKu9VXAqsFEJ0majj2pJUmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWg1swqAkq4DjgY1V9dim7ALg0c0uewJ3VNXSlmO/D2wBfgdsraqJQcUpSWo3sAQBfBA4A/jQZEFVnTC5nOSdwJ3bOP4pVfXjgUUnSdqmQU45enmSxW3bkgR4DnDkoK4vSdoxo6qD+FPg9qq6qcf2Ar6Y5KokK7Z1oiQrkqxJsmbTpk2zHqgkzVejShDLgfO3sf3JVfVE4FjglUn+rNeOVbWyqiaqamLBggWzHackzVtDTxBJ7gM8E7ig1z5Vtb753ghcCBwynOgkSZNG8QTxVOBbVbWubWOSPZI8aHIZOBq4fojxSZIYbDPX84EjgH2SrANOr6pzgBOZ8nopyf7A2VV1HLAvcGGnHpv7AOdV1ecHFeektRs2c8JZV9yrfNnShZx06KJBX16S5pxBtmJa3qP8BS1lPwSOa5ZvAR4/qLjaLFu6sLV87YbNACYISfPSIPtB7DROOnRRaxJoe6KQpPnCoTYkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktTJBSJJamSAkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktRpYgkiyKsnGJNd3lf19kvVJrmk+x/U49pgk305yc5LTBhWjJKm3QT5BfBA4pqX83VW1tPlcPHVjkl2B9wLHAkuA5UmWDDBOSVKLQU45enmSxTM49BDg5mbqUZJ8BFgGrJ3F8PrWPVe181NLmk9GUQfxqiTXNq+g9mrZvhC4rWt9XVPWKsmKJGuSrNm0adOsBrps6UKW7PdgoJMoPn3N+lk9vyTNZcNOEO8HHgEsBTYA79zRE1bVyqqaqKqJBQsW7Ojp7uGkQxdxwUsP54KXHn53opCk+WLaV0xJ7gccD/wpsD/wK+B64HNVdcP2XKyqbu86778Cn23ZbT1wYNf6AU2ZJGmItvkEkeRNwL8DhwNXAmcBHwW2Am9LsjrJ4/q9WJL9ulb/kk6imerrwMFJDkqyO3AicFG/15AkzY7pniC+VlWn99j2riQPA1prbZOcDxwB7JNkHXA6cESSpUAB3wde2uy7P3B2VR1XVVuTvAr4ArArsGp7n1QkSTtumwmiqj43zfaNwMYe25a3FJ/TY98fAsd1rV8M3KsJrCRpePqpgzgAWA48mSl1EMAlVXXXQCOUJI3ENhNEkg/QaWL6WeDtdJ4W7gc8ik4nuDckOa2qLh90oJKk4ZruCeKdVdVWkXw98MmmEtmeY5I0hrbZimkyOSQ5deq2JKdW1W+q6uZBBTfXTPaqPuGsKzjvyh+MOhxJGqh+O8qd0lL2glmMY86zV7Wk+Wa6OojlwEnAQUm6+yI8CPjpIAOba046dNHd4zBNjs0kSeNsujqIr9AZEmMf7jksxhbg2kEFJUkavekSxA+q6lY6PalbJUlV1eyGJUkatenqIC5L8uok92iplGT3JEcmOZf2+glJ0k5uuieIY4AXAecnOQi4A7g/ncTyReCfq+obA41QkjQS0w218R/A+4D3JdmNTl3Er6rqjiHEJkkaob7ng6iq31bVBuC3SU5Oss1xmiRJO7e+EkRT5/CXST5Gp1XTUcCZA41MkjRS0/WDOJrOQH1HA5cBHwL+pKpeOITYJEkjNN0TxOeBPwSeXFUnV9VnAEdvlaR5YLoE8UTgCuD/NrPHvZjOJD7TSrIqycYk13eVvSPJt5Jcm+TCJHv2OPb7Sa5Lck2SNX3+FknSLJpusL5rquq0qnoEnRnhlgK7JbkkyYppzv1BOs1ku60GHltVjwO+A7x+G8c/paqWVtXENNeRJA3A9rRi+kpVvRo4AHg3cNg0+1/OlPGaquqLVbW1Wf1qcy5J0hy0zQSRZPHUsqq6q/lD/6J0zPSP/IuAS3psK+CLSa6a7kklyYoka5Ks2bRp0wxDkSRNNV1P6nck2QX4NHAVsInOjHKPBI4Ankrn1dO67blokjcAW4EP99jlyVW1PsnDgNVJvtVr1rqqWgmsBJiYmHBMKEmaJdP1pH52kiXAc+n8i38/4JfAjcDFwD82va37luQFwPHAUb0G+auq9c33xiQXAocATmsqSUM03RMEVbUWeMNsXCzJMcDfAv+lqn7ZY589gF2qakuzfDTw5tm4viSpf31XUm+vJOfTaSL76CTrmiayZ9CZbGh104T1zGbf/ZNc3By6L/DlJN8EvgZ8rqo+P6g4JUntpn2CmKmqWt5SfE6PfX8IHNcs3wI8flBxSZL6M7AnCEnSzq3vJ4gkC4GHdx/Tq2WRJGnn11eCSPJ24ARgLfC7priwZZEkja1+nyCeATy6qn49wFgkSXNIv3UQtwC7DTIQSdLc0u8TxC+Ba5JcCtz9FFFVrxlIVJKkkes3QVzUfCRJ80RfCaKqzk2yO/CopujbVfXbwYUlSRq1flsxHQGcC3wfCHBgklPmczPXtRs2c8JZVwCwbOlCTjp00YgjkqTZ1e8rpncCR1fVtwGSPAo4H/jjQQU2ly1buvDu5bUbNgOYICSNnX4TxG6TyQGgqr6TZN62ajrp0EV3J4TJpwhJGjf9Jog1Sc4G/k+z/lzAuaIlaYz1myBeDrwSmGzW+iXgfQOJSJI0J/TbiunXwLuajyRpHthmgkjy0ap6TpLr6Iy9dA9V9biBRSZJGqnpniBObb6PH3QgkqS5ZZtjMVXVhmbxFVV1a/cHeMV0J0+yKsnGJNd3le2dZHWSm5rvvXoce0qzz01JTtmeHyVJ2nH9Dtb3tJayY/s47oPAMVPKTgMuraqDgUub9XtIsjdwOnAocAhweq9EIkkajG0miCQvb+ofHp3k2q7P94Brpzt509P6p1OKl9HplU3z/YyWQ/8cWF1VP62qnwGruXeimTMme1WfcNYVnHflD0YdjiTNiunqIM4DLgH+B/f8l/6Wqpr6h79f+3a9uvoRsG/LPguB27rW1zVl95JkBbACYNGi4fdmtle1pHG1zQRRVXcCdwLLAZI8DLgf8MAkD6yqHfrnclVVknu1jtrOc6wEVgJMTEzs0Llmwl7VksZVX3UQSZ6e5Cbge8D/ozNo3yUzvObtSfZrzrsfsLFln/XAgV3rBzRlkqQh6beS+h+Aw4DvVNVBwFHAV2d4zYuAyVZJpwCfbtnnC8DRSfZqKqePbsokSUPSb4L4bVX9BNglyS5VdRkwMd1BSc4HrqBTyb0uyYuBtwFPa55Intqsk2SiGe+Jpn7jLcDXm8+bd6DOQ5I0A/2OxXRHkgcClwMfTrIR+MV0B1XV8h6bjmrZdw3wkq71VcCqPuOTJM2yfp8gltGZl/qvgM8D3wWePqigJEmjN+0TRJJdgc9W1VOAu/h9HwZJ0hib9gmiqn4H3JXkIUOIR5I0R/RbB/Fz4Lokq+mqe6iq1/Q+ZH7qnqu6m/NWS9rZ9JsgPtl8ug29U9pc192rups9rCXtjPpNEHtW1b90FyQ5tdfO81V3r+pu9rCWtDPqtxVT23DbL5jFOCRJc8x0M8otB04CDkpyUdemB3HvUVolSWNkuldMXwE2APsA7+wq30Ifw31LknZe043meitwK3D4cMKRJM0V/Y7m+sxm6s87k2xOsiXJ5kEHJ0kanX5bMf1P4OlVdeMgg5EkzR39tmK63eQgSfNLv08Qa5JcAHwK+PVkYVVN7TynHnr1sAZ7WUuam/pNEA+mM5rr0V1lxb17V6tFrx7WYC9rSXNXXwmiql446EDGWa8e1mAva0lzV7+tmB6V5NIk1zfrj0vy32dywSSPTnJN12dzktdO2eeIpsXU5D5vnMm1JEkz1+8rpn8F/gY4C6Cqrk1yHp25qrdLVX0bWAp3zzWxHriwZdcvVdXx23t+SdLs6LcV0wOq6mtTyrbOwvWPAr7bdMiTJM0h/SaIHyd5BM0Q30meRWcIjh11InB+j22HJ/lmkkuSPKbXCZKsSLImyZpNmzbNQkiSJOj/FdMrgZXAHyVZD3wPOHlHLpxkd+AvgNe3bL4aeHhV/TzJcXSa1x7cdp6qWtnExsTEhHNUSNIs6bcV0y3AU5PsAexSVVtm4drHAldX1e0t19vctXxxkvcl2aeqfjwL15Uk9aHfVkz/mGTPqvpFVW1JsleS7a6gnmI5PV4vJfmDJGmWD2ni/MkOXk+StB36rYM4tqrumFypqp8Bx830os2TyNPo6miX5GVJXtasPgu4Psk3gfcAJ1aVr48kaYj6rYPYNcl9q+rXAEnuD9x3phetql8AD51SdmbX8hnAGTM9vyRpx/WbID4MXJrkA836C4FzBxOSJGku6LeS+u1JrqXTbwHgLVX1hcGFJUkatX6fIKiqS4BLBhiLJGkOcUY5SVIrZ5STJLVyRjlJUitnlJMktXJGOUlSK2eUmwO2NV/1JOetljRs/bZiOiDJhUk2Np9PJDlg0MHNB8uWLmTJfg/e5j5rN2zm09esH1JEktTR7yumDwDnAc9u1k9uyp42iKDmk23NVz3JeasljUK/rZgWVNUHqmpr8/kgsGCAcUmSRqzfBPGTJCcn2bX5nIzDb0vSWOs3QbwIeA7wIzpTjT6LzoB9kqQx1W8rplvpTA8qSZon+m3FdG6SPbvW90qyakcunOT7Sa5Lck2SNS3bk+Q9SW5Ocm2SJ+7I9SRJ26ffVkyPmzqjXJInzML1n7KNeaaPBQ5uPocC72++JUlD0G+C2CXJXs1UoyTZezuOnallwIeaqUa/mmTPJPtV1YYBX3dO6qcz3aDYSU+an/r9I/9O4IokH2vWnw28dQevXcAXkxRwVlWtnLJ9IXBb1/q6puweCSLJCmAFwKJF4/lHbNnShSO79toNnVHdTRDS/NNvJfWHmnqCI5uiZ1bV2h289pOran2ShwGrk3yrqi7f3pM0iWUlwMTERO1gTHNSP53pBsVOetL8tT0zyq0FdjQpdJ9vffO9McmFwCFAd4JYDxzYtX5AUyZJGoJ++0HMqiR7JHnQ5DKdUWKvn7LbRcDzm9ZMhwF3ztf6B0kahUFXNPeyL3BhkskYzquqzyd5GUBVnQlcDBwH3ExnqHE75knSEI0kQVTVLcDjW8rP7Fou4JXDjEuS9HsjecUkSZr7TBCSpFYmCElSq1FVUmsn0qsXtz2spfFmgtA29erFbQ9rafyZILRNvXpx28NaGn/WQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZT8Izdio5sm2B7c0HCYIzcio5sm2B7c0PCYIzcio5sm2B7c0PEOvg0hyYJLLkqxNckOSU1v2OSLJnUmuaT5vHHackjTfjeIJYivwuqq6upmX+qokq6tq7ZT9vlRVx48gPkkSI3iCqKoNVXV1s7wFuBEYzQttSVJPI23mmmQx8ATgypbNhyf5ZpJLkjxmG+dYkWRNkjWbNm0aVKiSNO+MLEEkeSDwCeC1VbV5yuargYdX1eOB/wV8qtd5qmplVU1U1cSCBQsGFq8kzTcjSRBJdqOTHD5cVZ+cur2qNlfVz5vli4Hdkuwz5DAlaV4bRSumAOcAN1bVu3rs8wfNfiQ5hE6cPxlelJKkUbRiehLwPOC6JNc0ZX8HLAKoqjOBZwEvT7IV+BVwYlXVCGLVHDSTHtz2vpa239ATRFV9Gcg0+5wBnDGciLQzmUkPbntfSzNjT2rtVGbSg9ve19LMOJqrJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFb2g9C80E/va3tbS/dkgtDY66f3tb2tpXszQWjs9dP72t7W0r1ZByFJamWCkCS1MkFIklqZICRJrUwQkqRWo5qT+pgk305yc5LTWrbfN8kFzfYrkyweQZiSNK+NYk7qXYH3AscCS4DlSZZM2e3FwM+q6pHAu4G3DzdKSdIo+kEcAtxcVbcAJPkIsAxY27XPMuDvm+WPA2ckifNSa5BmMte1NBcs2f/BnP70x8z6eUeRIBYCt3WtrwMO7bVPVW1NcifwUODHU0+WZAWwAmDRInvBamZmMte1NO52+p7UVbUSWAkwMTHhE4ZmZCZzXUvjbhSV1OuBA7vWD2jKWvdJch/gIcBPhhKdJAkYTYL4OnBwkoOS7A6cCFw0ZZ+LgFOa5WcB/2b9gyQN19BfMTV1Cq8CvgDsCqyqqhuSvBlYU1UXAecA/zvJzcBP6SQRSdIQjaQOoqouBi6eUvbGruX/AJ497LgkSb9nT2pJUisThCSplQlCktTKBCFJapVxaj2aZBNw6wwP34eWntpjzt88/ubb7wV/8/Z6eFUtaNswVgliRyRZU1UTo45jmPzN42++/V7wN88mXzFJklqZICRJrUwQv7dy1AGMgL95/M233wv+5lljHYQkqZVPEJKkViYISVKreZ8gkhyT5NtJbk5y2qjjGYQkBya5LMnaJDckObUp3zvJ6iQ3Nd97jTrW2ZZk1yTfSPLZZv2gJFc29/uCZsj5sZFkzyQfT/KtJDcmOXzc73OSv2r+u74+yflJ7jdu9znJqiQbk1zfVdZ6X9Pxnua3X5vkiTO97rxOEEl2Bd4LHAssAZYnWTLaqAZiK/C6qloCHAa8svmdpwGXVtXBwKXN+rg5Fbixa/3twLur6pHAz4AXjySqwfkX4PNV9UfA4+n89rG9z0kWAq8BJqrqsXSmEDiR8bvPHwSOmVLW674eCxzcfFYA75/pRed1ggAOAW6uqluq6jfAR4BlI45p1lXVhqq6ulneQuePxkI6v/XcZrdzgWeMJMABSXIA8F+Bs5v1AEcCH292GavfnOQhwJ/RmU+FqvpNVd3BmN9nOtMW3L+ZffIBwAbG7D5X1eV05sbp1uu+LgM+VB1fBfZMst9MrjvfE8RC4Lau9XVN2dhKshh4AnAlsG9VbWg2/QjYd1RxDcg/A38L3NWsPxS4o6q2Nuvjdr8PAjYBH2heq52dZA/G+D5X1Xrgn4Af0EkMdwJXMd73eVKv+zprf9fme4KYV5I8EPgE8Nqq2ty9rZnSdWzaPCc5HthYVVeNOpYhug/wROD9VfUE4BdMeZ00hvd5Lzr/Yj4I2B/Yg3u/ihl7g7qv8z1BrAcO7Fo/oCkbO0l2o5McPlxVn2yKb5989Gy+N44qvgF4EvAXSb5P59XhkXTez+/ZvIqA8bvf64B1VXVls/5xOgljnO/zU4HvVdWmqvot8Ek6936c7/OkXvd11v6uzfcE8XXg4KbFw+50KrcuGnFMs655934OcGNVvatr00XAKc3yKcCnhx3boFTV66vqgKpaTOe+/ltVPRe4DHhWs9u4/eYfAbcleXRTdBSwljG+z3ReLR2W5AHNf+eTv3ls73OXXvf1IuD5TWumw4A7u15FbZd535M6yXF03lXvCqyqqreONqLZl+TJwJeA6/j9+/i/o1MP8VFgEZ1h0p9TVVMrwnZ6SY4A/rqqjk/yh3SeKPYGvgGcXFW/HmF4syrJUjqV8rsDtwAvpPMPwbG9z0neBJxAp7XeN4CX0HnnPjb3Ocn5wBF0hvW+HTgd+BQt97VJlGfQedX2S+CFVbVmRted7wlCktRuvr9ikiT1YIKQJLUyQUiSWpkgJEmtTBCSpFYmCGmGmpFTX9Es75/k49MdI+1MbOYqzVAzrtVnm1FEpbFzn+l3kdTD24BHJLkGuAn4T1X12CQvoDOy5h50hlz+Jzod154H/Bo4runQ9Ag6w80voNOh6b9V1beG/SOkXnzFJM3cacB3q2op8DdTtj0WeCbwJ8BbgV82A+hdATy/2Wcl8Oqq+mPgr4H3DSNoqV8+QUiDcVkz98aWJHcCn2nKrwMe14ys+5+Bj3VGRgDgvsMPU+rNBCENRve4P3d1rd9F5/+7XejMWbB0yHFJffMVkzRzW4AHzeTAZj6O7yV5Ntw9j/DjZzM4aUeZIKQZqqqfAP/eTCT/jhmc4rnAi5N8E7iBMZzuVjs3m7lKklr5BCFJamWCkCS1MkFIklqZICRJrUwQkqRWJghJUisThCSp1f8H7mxI0309ZmIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_0 = 20\n", + "model = pints.toy.stochastic.ProductionDegradationModel(n_0)\n", + "\n", + "times = np.linspace(0, 100, 100)\n", + "k = [0.1, 0.1]\n", + "\n", + "values = model.simulate(k, times)\n", + "\n", + "plt.step(times, values)\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\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, has a mean which tends towards the following deterministic function as the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(10):\n", + " values = model.simulate(k, times)\n", + " plt.step(times, values)\n", + " \n", + "plt.title('stochastic degradation across different iterations')\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now plot the analytic mean and standard deviation of this process.\n", + "The deterministic variance of this model is given by: $e^{-2kt}(-1 + e^{kt})n_0$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "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", + "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()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" + }, + "kernelspec": { + "display_name": "Python 3.8.0 32-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pints/tests/test_toy_stochastic_production_degradation_model.py b/pints/tests/test_toy_stochastic_production_degradation_model.py new file mode 100644 index 0000000000..261458dbd8 --- /dev/null +++ b/pints/tests/test_toy_stochastic_production_degradation_model.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +# +# Tests if the degradation (toy) model works. +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +import unittest +import numpy as np +from pints.toy.stochastic import ProductionDegradationModel + + +class TestProductionDegradationModel(unittest.TestCase): + """ + Tests if the degradation (toy) model works. + """ + def test_n_parameters(self): + x_0 = 20 + model = ProductionDegradationModel(x_0) + self.assertEqual(model.n_parameters(), 2) + + def test_simulation_length(self): + x_0 = 20 + model = ProductionDegradationModel(x_0) + times = np.linspace(0, 1, 100) + k = [0.1, 0.2] + values = model.simulate(k, times) + self.assertEqual(len(values), 100) + + def test_propensities(self): + x_0 = 20 + k = [0.1, 0.2] + model = ProductionDegradationModel(x_0) + self.assertTrue( + np.allclose( + model._propensities([x_0], k), + np.array([2.0, 0.2]))) + + def test_suggested(self): + model = ProductionDegradationModel(20) + times = model.suggested_times() + parameters = model.suggested_parameters() + self.assertTrue(len(times) == 101) + self.assertTrue(np.all(parameters > 0)) + + +if __name__ == '__main__': + unittest.main() diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py index 7d5c081297..568bb8a96d 100644 --- a/pints/toy/stochastic/__init__.py +++ b/pints/toy/stochastic/__init__.py @@ -10,3 +10,4 @@ from ._michaelis_menten_model import MichaelisMentenModel # noqa from ._degradation_model import DegradationModel # noqa from ._logistic_model import LogisticModel # noqa +from ._production_degradation_model import ProductionDegradationModel # noqa diff --git a/pints/toy/stochastic/_production_degradation_model.py b/pints/toy/stochastic/_production_degradation_model.py new file mode 100644 index 0000000000..3d4a066ede --- /dev/null +++ b/pints/toy/stochastic/_production_degradation_model.py @@ -0,0 +1,49 @@ +# +# Stochastic production and degradation toy model. +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +from . import MarkovJumpModel + +import numpy as np + + +class ProductionDegradationModel(MarkovJumpModel): + r""" + Stochastic production and degradation model of two separate chemical + reactions reaction starting from an initial molecule count :math:`A(0)` + and degrading to 0 with a fixed rate. + :math:`k`: + + .. math:: + A \xrightarrow{k1} 0, 0 \xrightarrow{k2} A + + Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + + Parameters + ---------- + initial_molecule_count + The initial molecule count :math:`A(0)`. + """ + def __init__(self, initial_molecule_count=20): + V = [[-1], [1]] + init_list = [initial_molecule_count] + super(ProductionDegradationModel, self).__init__(init_list, + V, self._propensities) + + @staticmethod + def _propensities(xs, ks): + return [ + xs[0] * ks[0], + ks[1] + ] + + def suggested_parameters(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + return np.array([0.1, 0.2]) + + def suggested_times(self): + """ See "meth:`pints.toy.ToyModel.suggested_times()`.""" + return np.linspace(0, 100, 101) From 9163a0563e5ee163a104f1fed246542b292b2ab8 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 19:20:39 +0000 Subject: [PATCH 24/41] added ipynb for production_degradation + added a fix for markov model on zero population values --- ...el-stochastic-production-degradation.ipynb | 70 ++++++------------- pints/toy/stochastic/_markov_jump_model.py | 2 - 2 files changed, 22 insertions(+), 50 deletions(-) diff --git a/examples/toy/model-stochastic-production-degradation.ipynb b/examples/toy/model-stochastic-production-degradation.ipynb index dff1c89e41..9e943232e6 100644 --- a/examples/toy/model-stochastic-production-degradation.ipynb +++ b/examples/toy/model-stochastic-production-degradation.ipynb @@ -24,6 +24,7 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pints\n", + "import pints.toy as toy\n", "import pints.toy.stochastic" ] }, @@ -36,12 +37,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZ1klEQVR4nO3de7SddX3n8fcHBC94ASRSCMRQRTvRpdGechltB0EpMNhYlwpBFG8T72KXbRfWWVK1dnSs2jqokEIUZwTxhqKCmqGsQSuiAZFLUEEUSYwkXiDxUjXynT/2c3BzeHbOzsnZe5/s836ttdd+nt9z++71wPnmeX63VBWSJE21y6gDkCTNTSYISVIrE4QkqZUJQpLUygQhSWp1n1EHMJv22WefWrx48ajDkKSdxlVXXfXjqlrQtm2sEsTixYtZs2bNqMOQpJ1Gklt7bfMVkySplQlCktTKBCFJamWCkCS1MkFIkloNLEEkOTDJZUnWJrkhyalN+d5JVie5qfneq8fxpzT73JTklEHFKUlqN8gniK3A66pqCXAY8MokS4DTgEur6mDg0mb9HpLsDZwOHAocApzeK5FIkgZjYAmiqjZU1dXN8hbgRmAhsAw4t9ntXOAZLYf/ObC6qn5aVT8DVgPHDCrWN33mBt70mRsGdXpJ2ikNpaNcksXAE4ArgX2rakOz6UfAvi2HLARu61pf15S1nXsFsAJg0aJFM4pv7Q83z+g4SRpnA6+kTvJA4BPAa6vqHn+JqzNb0Q7NWFRVK6tqoqomFixo7S0uSZqBgSaIJLvRSQ4frqpPNsW3J9mv2b4fsLHl0PXAgV3rBzRlkqQhGWQrpgDnADdW1bu6Nl0ETLZKOgX4dMvhXwCOTrJXUzl9dFMmSRqSQT5BPAl4HnBkkmuaz3HA24CnJbkJeGqzTpKJJGcDVNVPgbcAX28+b27KJElDMrBK6qr6MpAem49q2X8N8JKu9VXAqsFEJ0majj2pJUmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZYKQJLUyQUiSWg1swqAkq4DjgY1V9dim7ALg0c0uewJ3VNXSlmO/D2wBfgdsraqJQcUpSWo3sAQBfBA4A/jQZEFVnTC5nOSdwJ3bOP4pVfXjgUUnSdqmQU45enmSxW3bkgR4DnDkoK4vSdoxo6qD+FPg9qq6qcf2Ar6Y5KokK7Z1oiQrkqxJsmbTpk2zHqgkzVejShDLgfO3sf3JVfVE4FjglUn+rNeOVbWyqiaqamLBggWzHackzVtDTxBJ7gM8E7ig1z5Vtb753ghcCBwynOgkSZNG8QTxVOBbVbWubWOSPZI8aHIZOBq4fojxSZIYbDPX84EjgH2SrANOr6pzgBOZ8nopyf7A2VV1HLAvcGGnHpv7AOdV1ecHFeektRs2c8JZV9yrfNnShZx06KJBX16S5pxBtmJa3qP8BS1lPwSOa5ZvAR4/qLjaLFu6sLV87YbNACYISfPSIPtB7DROOnRRaxJoe6KQpPnCoTYkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktTJBSJJamSAkSa1MEJKkViYISVIrE4QkqZUJQpLUygQhSWplgpAktRpYgkiyKsnGJNd3lf19kvVJrmk+x/U49pgk305yc5LTBhWjJKm3QT5BfBA4pqX83VW1tPlcPHVjkl2B9wLHAkuA5UmWDDBOSVKLQU45enmSxTM49BDg5mbqUZJ8BFgGrJ3F8PrWPVe181NLmk9GUQfxqiTXNq+g9mrZvhC4rWt9XVPWKsmKJGuSrNm0adOsBrps6UKW7PdgoJMoPn3N+lk9vyTNZcNOEO8HHgEsBTYA79zRE1bVyqqaqKqJBQsW7Ojp7uGkQxdxwUsP54KXHn53opCk+WLaV0xJ7gccD/wpsD/wK+B64HNVdcP2XKyqbu86778Cn23ZbT1wYNf6AU2ZJGmItvkEkeRNwL8DhwNXAmcBHwW2Am9LsjrJ4/q9WJL9ulb/kk6imerrwMFJDkqyO3AicFG/15AkzY7pniC+VlWn99j2riQPA1prbZOcDxwB7JNkHXA6cESSpUAB3wde2uy7P3B2VR1XVVuTvAr4ArArsGp7n1QkSTtumwmiqj43zfaNwMYe25a3FJ/TY98fAsd1rV8M3KsJrCRpePqpgzgAWA48mSl1EMAlVXXXQCOUJI3ENhNEkg/QaWL6WeDtdJ4W7gc8ik4nuDckOa2qLh90oJKk4ZruCeKdVdVWkXw98MmmEtmeY5I0hrbZimkyOSQ5deq2JKdW1W+q6uZBBTfXTPaqPuGsKzjvyh+MOhxJGqh+O8qd0lL2glmMY86zV7Wk+Wa6OojlwEnAQUm6+yI8CPjpIAOba046dNHd4zBNjs0kSeNsujqIr9AZEmMf7jksxhbg2kEFJUkavekSxA+q6lY6PalbJUlV1eyGJUkatenqIC5L8uok92iplGT3JEcmOZf2+glJ0k5uuieIY4AXAecnOQi4A7g/ncTyReCfq+obA41QkjQS0w218R/A+4D3JdmNTl3Er6rqjiHEJkkaob7ng6iq31bVBuC3SU5Oss1xmiRJO7e+EkRT5/CXST5Gp1XTUcCZA41MkjRS0/WDOJrOQH1HA5cBHwL+pKpeOITYJEkjNN0TxOeBPwSeXFUnV9VnAEdvlaR5YLoE8UTgCuD/NrPHvZjOJD7TSrIqycYk13eVvSPJt5Jcm+TCJHv2OPb7Sa5Lck2SNX3+FknSLJpusL5rquq0qnoEnRnhlgK7JbkkyYppzv1BOs1ku60GHltVjwO+A7x+G8c/paqWVtXENNeRJA3A9rRi+kpVvRo4AHg3cNg0+1/OlPGaquqLVbW1Wf1qcy5J0hy0zQSRZPHUsqq6q/lD/6J0zPSP/IuAS3psK+CLSa6a7kklyYoka5Ks2bRp0wxDkSRNNV1P6nck2QX4NHAVsInOjHKPBI4Ankrn1dO67blokjcAW4EP99jlyVW1PsnDgNVJvtVr1rqqWgmsBJiYmHBMKEmaJdP1pH52kiXAc+n8i38/4JfAjcDFwD82va37luQFwPHAUb0G+auq9c33xiQXAocATmsqSUM03RMEVbUWeMNsXCzJMcDfAv+lqn7ZY589gF2qakuzfDTw5tm4viSpf31XUm+vJOfTaSL76CTrmiayZ9CZbGh104T1zGbf/ZNc3By6L/DlJN8EvgZ8rqo+P6g4JUntpn2CmKmqWt5SfE6PfX8IHNcs3wI8flBxSZL6M7AnCEnSzq3vJ4gkC4GHdx/Tq2WRJGnn11eCSPJ24ARgLfC7priwZZEkja1+nyCeATy6qn49wFgkSXNIv3UQtwC7DTIQSdLc0u8TxC+Ba5JcCtz9FFFVrxlIVJKkkes3QVzUfCRJ80RfCaKqzk2yO/CopujbVfXbwYUlSRq1flsxHQGcC3wfCHBgklPmczPXtRs2c8JZVwCwbOlCTjp00YgjkqTZ1e8rpncCR1fVtwGSPAo4H/jjQQU2ly1buvDu5bUbNgOYICSNnX4TxG6TyQGgqr6TZN62ajrp0EV3J4TJpwhJGjf9Jog1Sc4G/k+z/lzAuaIlaYz1myBeDrwSmGzW+iXgfQOJSJI0J/TbiunXwLuajyRpHthmgkjy0ap6TpLr6Iy9dA9V9biBRSZJGqnpniBObb6PH3QgkqS5ZZtjMVXVhmbxFVV1a/cHeMV0J0+yKsnGJNd3le2dZHWSm5rvvXoce0qzz01JTtmeHyVJ2nH9Dtb3tJayY/s47oPAMVPKTgMuraqDgUub9XtIsjdwOnAocAhweq9EIkkajG0miCQvb+ofHp3k2q7P94Brpzt509P6p1OKl9HplU3z/YyWQ/8cWF1VP62qnwGruXeimTMme1WfcNYVnHflD0YdjiTNiunqIM4DLgH+B/f8l/6Wqpr6h79f+3a9uvoRsG/LPguB27rW1zVl95JkBbACYNGi4fdmtle1pHG1zQRRVXcCdwLLAZI8DLgf8MAkD6yqHfrnclVVknu1jtrOc6wEVgJMTEzs0Llmwl7VksZVX3UQSZ6e5Cbge8D/ozNo3yUzvObtSfZrzrsfsLFln/XAgV3rBzRlkqQh6beS+h+Aw4DvVNVBwFHAV2d4zYuAyVZJpwCfbtnnC8DRSfZqKqePbsokSUPSb4L4bVX9BNglyS5VdRkwMd1BSc4HrqBTyb0uyYuBtwFPa55Intqsk2SiGe+Jpn7jLcDXm8+bd6DOQ5I0A/2OxXRHkgcClwMfTrIR+MV0B1XV8h6bjmrZdw3wkq71VcCqPuOTJM2yfp8gltGZl/qvgM8D3wWePqigJEmjN+0TRJJdgc9W1VOAu/h9HwZJ0hib9gmiqn4H3JXkIUOIR5I0R/RbB/Fz4Lokq+mqe6iq1/Q+ZH7qnqu6m/NWS9rZ9JsgPtl8ug29U9pc192rups9rCXtjPpNEHtW1b90FyQ5tdfO81V3r+pu9rCWtDPqtxVT23DbL5jFOCRJc8x0M8otB04CDkpyUdemB3HvUVolSWNkuldMXwE2APsA7+wq30Ifw31LknZe043meitwK3D4cMKRJM0V/Y7m+sxm6s87k2xOsiXJ5kEHJ0kanX5bMf1P4OlVdeMgg5EkzR39tmK63eQgSfNLv08Qa5JcAHwK+PVkYVVN7TynHnr1sAZ7WUuam/pNEA+mM5rr0V1lxb17V6tFrx7WYC9rSXNXXwmiql446EDGWa8e1mAva0lzV7+tmB6V5NIk1zfrj0vy32dywSSPTnJN12dzktdO2eeIpsXU5D5vnMm1JEkz1+8rpn8F/gY4C6Cqrk1yHp25qrdLVX0bWAp3zzWxHriwZdcvVdXx23t+SdLs6LcV0wOq6mtTyrbOwvWPAr7bdMiTJM0h/SaIHyd5BM0Q30meRWcIjh11InB+j22HJ/lmkkuSPKbXCZKsSLImyZpNmzbNQkiSJOj/FdMrgZXAHyVZD3wPOHlHLpxkd+AvgNe3bL4aeHhV/TzJcXSa1x7cdp6qWtnExsTEhHNUSNIs6bcV0y3AU5PsAexSVVtm4drHAldX1e0t19vctXxxkvcl2aeqfjwL15Uk9aHfVkz/mGTPqvpFVW1JsleS7a6gnmI5PV4vJfmDJGmWD2ni/MkOXk+StB36rYM4tqrumFypqp8Bx830os2TyNPo6miX5GVJXtasPgu4Psk3gfcAJ1aVr48kaYj6rYPYNcl9q+rXAEnuD9x3phetql8AD51SdmbX8hnAGTM9vyRpx/WbID4MXJrkA836C4FzBxOSJGku6LeS+u1JrqXTbwHgLVX1hcGFJUkatX6fIKiqS4BLBhiLJGkOcUY5SVIrZ5STJLVyRjlJUitnlJMktXJGOUlSK2eUmwO2NV/1JOetljRs/bZiOiDJhUk2Np9PJDlg0MHNB8uWLmTJfg/e5j5rN2zm09esH1JEktTR7yumDwDnAc9u1k9uyp42iKDmk23NVz3JeasljUK/rZgWVNUHqmpr8/kgsGCAcUmSRqzfBPGTJCcn2bX5nIzDb0vSWOs3QbwIeA7wIzpTjT6LzoB9kqQx1W8rplvpTA8qSZon+m3FdG6SPbvW90qyakcunOT7Sa5Lck2SNS3bk+Q9SW5Ocm2SJ+7I9SRJ26ffVkyPmzqjXJInzML1n7KNeaaPBQ5uPocC72++JUlD0G+C2CXJXs1UoyTZezuOnallwIeaqUa/mmTPJPtV1YYBX3dO6qcz3aDYSU+an/r9I/9O4IokH2vWnw28dQevXcAXkxRwVlWtnLJ9IXBb1/q6puweCSLJCmAFwKJF4/lHbNnShSO79toNnVHdTRDS/NNvJfWHmnqCI5uiZ1bV2h289pOran2ShwGrk3yrqi7f3pM0iWUlwMTERO1gTHNSP53pBsVOetL8tT0zyq0FdjQpdJ9vffO9McmFwCFAd4JYDxzYtX5AUyZJGoJ++0HMqiR7JHnQ5DKdUWKvn7LbRcDzm9ZMhwF3ztf6B0kahUFXNPeyL3BhkskYzquqzyd5GUBVnQlcDBwH3ExnqHE75knSEI0kQVTVLcDjW8rP7Fou4JXDjEuS9HsjecUkSZr7TBCSpFYmCElSq1FVUmsn0qsXtz2spfFmgtA29erFbQ9rafyZILRNvXpx28NaGn/WQUiSWpkgJEmtTBCSpFYmCElSKxOEJKmVCUKS1MoEIUlqZT8Izdio5sm2B7c0HCYIzcio5sm2B7c0PCYIzcio5sm2B7c0PEOvg0hyYJLLkqxNckOSU1v2OSLJnUmuaT5vHHackjTfjeIJYivwuqq6upmX+qokq6tq7ZT9vlRVx48gPkkSI3iCqKoNVXV1s7wFuBEYzQttSVJPI23mmmQx8ATgypbNhyf5ZpJLkjxmG+dYkWRNkjWbNm0aVKiSNO+MLEEkeSDwCeC1VbV5yuargYdX1eOB/wV8qtd5qmplVU1U1cSCBQsGFq8kzTcjSRBJdqOTHD5cVZ+cur2qNlfVz5vli4Hdkuwz5DAlaV4bRSumAOcAN1bVu3rs8wfNfiQ5hE6cPxlelJKkUbRiehLwPOC6JNc0ZX8HLAKoqjOBZwEvT7IV+BVwYlXVCGLVHDSTHtz2vpa239ATRFV9Gcg0+5wBnDGciLQzmUkPbntfSzNjT2rtVGbSg9ve19LMOJqrJKmVCUKS1MoEIUlqZYKQJLUyQUiSWpkgJEmtTBCSpFb2g9C80E/va3tbS/dkgtDY66f3tb2tpXszQWjs9dP72t7W0r1ZByFJamWCkCS1MkFIklqZICRJrUwQkqRWo5qT+pgk305yc5LTWrbfN8kFzfYrkyweQZiSNK+NYk7qXYH3AscCS4DlSZZM2e3FwM+q6pHAu4G3DzdKSdIo+kEcAtxcVbcAJPkIsAxY27XPMuDvm+WPA2ckifNSa5BmMte1NBcs2f/BnP70x8z6eUeRIBYCt3WtrwMO7bVPVW1NcifwUODHU0+WZAWwAmDRInvBamZmMte1NO52+p7UVbUSWAkwMTHhE4ZmZCZzXUvjbhSV1OuBA7vWD2jKWvdJch/gIcBPhhKdJAkYTYL4OnBwkoOS7A6cCFw0ZZ+LgFOa5WcB/2b9gyQN19BfMTV1Cq8CvgDsCqyqqhuSvBlYU1UXAecA/zvJzcBP6SQRSdIQjaQOoqouBi6eUvbGruX/AJ497LgkSb9nT2pJUisThCSplQlCktTKBCFJapVxaj2aZBNw6wwP34eWntpjzt88/ubb7wV/8/Z6eFUtaNswVgliRyRZU1UTo45jmPzN42++/V7wN88mXzFJklqZICRJrUwQv7dy1AGMgL95/M233wv+5lljHYQkqZVPEJKkViYISVKreZ8gkhyT5NtJbk5y2qjjGYQkBya5LMnaJDckObUp3zvJ6iQ3Nd97jTrW2ZZk1yTfSPLZZv2gJFc29/uCZsj5sZFkzyQfT/KtJDcmOXzc73OSv2r+u74+yflJ7jdu9znJqiQbk1zfVdZ6X9Pxnua3X5vkiTO97rxOEEl2Bd4LHAssAZYnWTLaqAZiK/C6qloCHAa8svmdpwGXVtXBwKXN+rg5Fbixa/3twLur6pHAz4AXjySqwfkX4PNV9UfA4+n89rG9z0kWAq8BJqrqsXSmEDiR8bvPHwSOmVLW674eCxzcfFYA75/pRed1ggAOAW6uqluq6jfAR4BlI45p1lXVhqq6ulneQuePxkI6v/XcZrdzgWeMJMABSXIA8F+Bs5v1AEcCH292GavfnOQhwJ/RmU+FqvpNVd3BmN9nOtMW3L+ZffIBwAbG7D5X1eV05sbp1uu+LgM+VB1fBfZMst9MrjvfE8RC4Lau9XVN2dhKshh4AnAlsG9VbWg2/QjYd1RxDcg/A38L3NWsPxS4o6q2Nuvjdr8PAjYBH2heq52dZA/G+D5X1Xrgn4Af0EkMdwJXMd73eVKv+zprf9fme4KYV5I8EPgE8Nqq2ty9rZnSdWzaPCc5HthYVVeNOpYhug/wROD9VfUE4BdMeZ00hvd5Lzr/Yj4I2B/Yg3u/ihl7g7qv8z1BrAcO7Fo/oCkbO0l2o5McPlxVn2yKb5989Gy+N44qvgF4EvAXSb5P59XhkXTez+/ZvIqA8bvf64B1VXVls/5xOgljnO/zU4HvVdWmqvot8Ek6936c7/OkXvd11v6uzfcE8XXg4KbFw+50KrcuGnFMs655934OcGNVvatr00XAKc3yKcCnhx3boFTV66vqgKpaTOe+/ltVPRe4DHhWs9u4/eYfAbcleXRTdBSwljG+z3ReLR2W5AHNf+eTv3ls73OXXvf1IuD5TWumw4A7u15FbZd535M6yXF03lXvCqyqqreONqLZl+TJwJeA6/j9+/i/o1MP8VFgEZ1h0p9TVVMrwnZ6SY4A/rqqjk/yh3SeKPYGvgGcXFW/HmF4syrJUjqV8rsDtwAvpPMPwbG9z0neBJxAp7XeN4CX0HnnPjb3Ocn5wBF0hvW+HTgd+BQt97VJlGfQedX2S+CFVbVmRted7wlCktRuvr9ikiT1YIKQJLUyQUiSWpkgJEmtTBCSpFYmCGmGmpFTX9Es75/k49MdI+1MbOYqzVAzrtVnm1FEpbFzn+l3kdTD24BHJLkGuAn4T1X12CQvoDOy5h50hlz+Jzod154H/Bo4runQ9Ag6w80voNOh6b9V1beG/SOkXnzFJM3cacB3q2op8DdTtj0WeCbwJ8BbgV82A+hdATy/2Wcl8Oqq+mPgr4H3DSNoqV8+QUiDcVkz98aWJHcCn2nKrwMe14ys+5+Bj3VGRgDgvsMPU+rNBCENRve4P3d1rd9F5/+7XejMWbB0yHFJffMVkzRzW4AHzeTAZj6O7yV5Ntw9j/DjZzM4aUeZIKQZqqqfAP/eTCT/jhmc4rnAi5N8E7iBMZzuVjs3m7lKklr5BCFJamWCkCS1MkFIklqZICRJrUwQkqRWJghJUisThCSp1f8H7mxI0309ZmIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -53,11 +54,11 @@ } ], "source": [ - "n_0 = 20\n", - "model = pints.toy.stochastic.ProductionDegradationModel(n_0)\n", + "n_0 = 0\n", + "model = toy.stochastic.ProductionDegradationModel(n_0)\n", "\n", "times = np.linspace(0, 100, 100)\n", - "k = [0.1, 0.1]\n", + "k = [0.1, 1]\n", "\n", "values = model.simulate(k, times)\n", "\n", @@ -71,17 +72,19 @@ "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, has a mean which tends towards the following deterministic function as the number of iterations tends to infinity (Erban et al., 2007): $ n_0e^{-kt} $.\n" + "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute the stochastic mean $M(t)$ which gives the average number of molecules of $A$ at time $t$. This function can be described by the following ODE (Erban et al., 2007): $ \\frac{\\text{d}M}{\\text{d}t} = -k_1 M + k_2 $.\n", + "\n", + "We will plot the ODE solution, and compare it to 10 stochastic simulations to show that the stochastic simulation average to the desired function.\n" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -93,6 +96,16 @@ } ], "source": [ + "def pend(y, t):\n", + " dydt = [-k[0] * y[0] + k[1]]\n", + " return dydt\n", + "\n", + "x_0 = [0]\n", + "times = np.linspace(0, 100, 100)\n", + "\n", + "from scipy.integrate import odeint\n", + "sol = odeint(pend, x_0, times)\n", + "\n", "for i in range(10):\n", " values = model.simulate(k, times)\n", " plt.step(times, values)\n", @@ -100,46 +113,7 @@ "plt.title('stochastic degradation across different iterations')\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now plot the analytic mean and standard deviation of this process.\n", - "The deterministic variance of this model is given by: $e^{-2kt}(-1 + e^{kt})n_0$" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "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", - "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.plot(times, sol,'--', color='black', label='ode solution')\n", "plt.show()" ] } diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py index 4cd8a032b1..16c222dab8 100644 --- a/pints/toy/stochastic/_markov_jump_model.py +++ b/pints/toy/stochastic/_markov_jump_model.py @@ -149,8 +149,6 @@ def simulate(self, parameters, times): times = np.asarray(times) if np.any(times < 0): raise ValueError('Negative times are not allowed.') - if np.all(self._x0 == 0): - return np.zeros(times.shape) # Run Gillespie time, mol_count = self.simulate_raw(parameters, max(times)) # Interpolate From 4715e2e8202fd501ec44fdfbf2952ff41bc14375 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 20:10:13 +0000 Subject: [PATCH 25/41] small fixes + added schlogl's model and tests --- docs/source/toy/stochastic/index.rst | 1 + .../stochastic_schlogl_model copy.rst | 7 + ...el-stochastic-production-degradation.ipynb | 11 +- examples/toy/model-stochastic-schlogl.ipynb | 149 ++++++++++++++++++ ...stochastic_production_degradation_model.py | 2 +- .../test_toy_stochastic_schlogl_model.py | 49 ++++++ pints/toy/stochastic/__init__.py | 1 + pints/toy/stochastic/_schlogl_model.py | 54 +++++++ 8 files changed, 268 insertions(+), 6 deletions(-) create mode 100644 docs/source/toy/stochastic/stochastic_schlogl_model copy.rst create mode 100644 examples/toy/model-stochastic-schlogl.ipynb create mode 100644 pints/tests/test_toy_stochastic_schlogl_model.py create mode 100644 pints/toy/stochastic/_schlogl_model.py diff --git a/docs/source/toy/stochastic/index.rst b/docs/source/toy/stochastic/index.rst index 1f1159f6e4..ec6bc52b3b 100644 --- a/docs/source/toy/stochastic/index.rst +++ b/docs/source/toy/stochastic/index.rst @@ -14,3 +14,4 @@ examples. stochastic_degradation_model stochastic_logistic_model stochastic_michaelis_menten_model + stochastic_schlogl_model diff --git a/docs/source/toy/stochastic/stochastic_schlogl_model copy.rst b/docs/source/toy/stochastic/stochastic_schlogl_model copy.rst new file mode 100644 index 0000000000..dd38193744 --- /dev/null +++ b/docs/source/toy/stochastic/stochastic_schlogl_model copy.rst @@ -0,0 +1,7 @@ +************** +Sclogl's model +************** + +.. currentmodule:: pints.toy.stochastic + +.. autoclass:: SchloglModel diff --git a/examples/toy/model-stochastic-production-degradation.ipynb b/examples/toy/model-stochastic-production-degradation.ipynb index 9e943232e6..ccf527aa10 100644 --- a/examples/toy/model-stochastic-production-degradation.ipynb +++ b/examples/toy/model-stochastic-production-degradation.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -37,12 +37,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -79,12 +79,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABqy0lEQVR4nO2dd3wcxfn/38+d7tR7t2zLvdu4xWBaTDfGFAPGQEJRCibf9BASSggtEEhCKvkFExIFCAZDwBQbDMb0ZuOGu3EvsmVJVj21O93N74/ZO6+kO+lcZNlm3q+XXrqdndl9dmZ3n53d+cwjSikMBoPBYGiLo7sNMBgMBsOxiXEQBoPBYAiLcRAGg8FgCItxEAaDwWAIi3EQBoPBYAiLcRAGg8FgCItxEN2IiCgRGXAU9vOGiNxwBLbznoh850jYdLiIyH9E5DeHUd4jIv2OpE3HO/bzUUQeE5G7bOu+JyL7rHrLFJHTRGSTtXxZtxkdge5uXxE5Q0Q2dtf+jxQx3W3A8YaI3AMMUEp9s7ttCUc4+5RSF3afRd2PiLwH/Fcp9UQwTSmV1H0WHfsopW4O/hYRF/BH4BSl1BdW2n3Ao0qpvxxt20TkP8BupdSvIuWxt280+Y+ATQoYqJTabO3/Q2BwV+3vaGF6EIZuR0TMg4qNY7A+coE4YK0trbDNctQcg8fXIcebvUcUpZT5C/MH/BIoAeqAjcA5wGTAC/gAD/CFlbcH8CpQCWwGvmvbjhO4A9hibWsZ0Mtap4CbgU1ANfB3QKx1/YF3gP1ABfAMkHaI9r0HfMdW9rvAeqvsOmBshDo4D9gA1ACPAu+32c63rO1UAW8ChbZ151t21QD/z14WuBH4GPiTdXy/ieJ4xwDLLZvnAM8Bv7HWpQPzgHLLlnlAT2vdA4AfaLLq5FFb3Q+wfqcCT1nldwC/Ahw2Wz8C/mBtextwYQfnzW22tl4HTGuzPmzdA9utNl0FNKN795egb8LVVhsO7aj9rfQJwFKgFtgH/LEDW28F9gJ7rLa018l/rHYZBNRb6zxWG20BAkCjlRZr1eG/rO2VWGWdHbR3rFWnOy07HwPirfyTgN3ALUCZtc0ia91N6PPba+37tQjHpoABkfKjr9kXrTbfBvzIVvYe4H/Af616/I5Vr59abbEXfT24rfwfWPurt/YxI3gMtm0Otdqw2mrTS2zr/oO+9udb7bkY6G+tE6veyixbVgMjjtp9sLtvxMfiH7pruAvoYS33sTXYPejXFfb8H6BvgnHAaOukO9t2Ea62tinASUCm7SSeB6QBva1yk611A9A36Fgg29rHnw/Rvvc4cHOejr6Av2bZMwDbjd1WJss6Wa8EXMBPgRbbdi5FO8Oh6JvZr4BPbGVrgcutdT9GX6R2B9EC/NBaH9/J8brRN+6fWrZcaW0v6CAygSuABCAZeAF4Odzx29LsN8OngFessn2AL4Fv22z1oW/sTuB76BuqRDh3pqNvPg70jaIeyO+s7tEOYiXQy6qP4I35POuYf2HVt7uT9v8UuM76nYR+LRTOzsnoG/MIIBGYTRgHYdu+AmJs5bcD59qW5wKzrG3lAEuAmR2095/QD1UZVr2/BvzWyj/Jyn+fdexTgAYgva1tHVzDYY/FWnagH9R+bdVnP2ArcIHtGvIBl1l544FxwCmW/X3QTv4n4fZnO4bd1m+X1XZ3WPs7G31tDbbZtx/thGLQD0fPWesusGxNQ58zQ7HOp6NyLzyaN97j5Q994ZYB5wKuNuvuwXYDRl/QfiDZlvZb4D/W743ApR2cxKfblp8HbouQ9zJgxcHaZ6W9x4Gb85vAj6Oog+uBz2zLgn6qC27nDaybqLXssC7iQqvsp23K7qK1g9jZyf7tx3smbW7KwCdEuEmgnXRVuONvU/cD0Dd9LzDMtm4m8J7N1s22dQlW2bwoz6WVwfbvqO7RN9xv2ZbvAp5vU78l6BtPR+3/AXAvkNWJXf8GHrItD+IQHQT6FVQzVg/ASrsGeDdce1vnQz2WU7PSJgLbrN+T0L0T+/7KsJwdh+8gTm57/gG3A8W2a+iDTrb/E2BuuP3ZjiHoIM4ASrF6pVbas8A9NvuesK2bAmywfp+NfmA5xV7+aP2ZbxBhUPpD00/QJ0qZiDwnIj0iZO8BVCql6mxpO4AC63cvdJc8EqW23w3opz5EJNfab4mI1KK7u1mHYF9bOrMnSA/0TR1rn8q+jHYEfxGRahGpRr9eE/Rxhyu7u8327dvq8Hit7ZVY2wmyw1Y2QURmicgOq+wHQJqIOKM4ziz0E94OW5q9/cDWRkqpButn2I/cInK9iKy01csI23F0Vvf2Oulht0kpFbDWF3TS/t9G3+w3iMjnIjI1wr5atRGtj/9gKUTX4V7bcc9C9ySC2PeVjXa0y2z5F1jpQfYrpVpsy6Fr4whQCPQI7tva/x1oRxfOXkRkkIjME5FS6xx7kAPt2hk9gF1WGwaJeI5hO1al1Dvo11l/R7f14yKSEuV+DxvjICKglJqtlDodfTIp4OHgqjZZ9wAZIpJsS+uNftoDfaL1PwQTHrT2NVIplQJ8E30DPlj72hKtPXvRNzQARETsy9Z2Ziql0mx/8UqpT6yyPduU7Ulr2trZ0fHuBQqs7QTpbft9C/q1y8lW2TODu46wLzsV6NcJhW22XRI+e2REpBD4J/AD9GvENGCNzY7O6t5u5x67Tbb6L4HI7a+U2qSUugZ9c34Y+J+IJIbZV6v2pXV9Hiy70D2ILNu5kKKUGh7h2CrQPYThtvypKvqRZZ2d453l34XurdjP3WSl1JQOyvwD/T1uoHWO3YHteuyEPUAvEbHfb6M+x5RSf1VKjQOGoZ3/rVHu97AxDiIMIjJYRM4WkVj0x81G9Ec50O9t+wQbWym1C/2647ciEicio9BPcf+18j8B3C8iA0UzSkQyozAjGf3Bq0ZECrCdFAdjXxieAH4uIuMsewZYN7a2zAeGi8jl1iiOHwF5tvWPAbeLyHDLplQRmW4rO1JELrPKfr9N2YM6XvR79RbgRyLiEpHL0e9r7WUbgWoRyQDubrPtfej3zO1QSvnRr/YeEJFkqy5+xoH2OxgS0TeWcgARKUL3IIJEW/dYNl0kIudYw0xvQd+EP+mo/UXkmyKSbT2tVlvbCrTfPM8DN4rIMBFJoH2dRY1Sai/wFvCIiKSIiENE+ovI1yPkD6Ad6Z9EJMeyu0BELohylxHbM8r8S4A6EfmliMSLiFNERojI1zrYRjL6u5pHRIagv0VFa9NidK/gF9b5Owm4GD3QokNE5GsicrJ1DtSj2ztce3YJxkGEJxZ4CP2kU4p+GrvdWveC9X+/iCy3fl+Dfk+7B/2x7m6l1NvWuj+iL8a30CfYv9AfvTrjXmAsehTQfOClw7AvhFLqBfTIntnoD2Uvoz8Uts1Xgf6o+hD6A9pA9EiU4Pq56CfU56wu9xrgwjZlf2eVHYYeWdN8KMerlPKiP3jfiH6VNaNNffwZXacVwGfo1xV2/gJcKSJVIvLXMPv+Ifri24oesTQb/Y7+oFBKrQMeQTu0fcBIWtdZVHVv5d2I7kX9zTqui4GLrbroqP0nA2tFxGMd99VKqcYw238DXW/voD+gvnOwx9uG69EfYNehR3v9D8jvIP8vrf1+Zp0/bxO9buBfwDDr9dDLB5vfeiiYiv5WtQ1dj0+gR2JF4ufAteh2+yd6JJ2de4AnrX1cZV9htdnF6OujAj2g5Xql1IYobE+x9leFfi21H/h9FOWOCMEhlQZDl2H1ZnYD31BKvdvd9hgMhugwPQhDlyAiF4hImvUaJPi+9rNuNstgMBwExkEYuoqJ6BE7wdcjl4V71WEwGI5dzCsmg8FgMITF9CAMBoPBEJYTahKqrKws1adPn+42w2AwGI4bli1bVqGUyg637oRyEH369GHp0qXdbYbBYDAcN4hIRBW9ecVkMBgMhrAYB2EwGAyGsBgHYTAYDIawGAdhMBgMhrAYB2EwGAyGsHSZgxCRXiLyroisE5G1IvJjKz1DRBaKyCbrf3qE8jdYeTaJyA1dZafBYDAYwtOVPYgW4Bal1DB0NKTvi8gwdMzeRUqpgcAia7kVtimbT0ZP63x3JEdiMBgMhq6hy3QQ1hzxe63fdSKyHh1B6VJ0OD6AJ9HhIH/ZpvgFwEKlVCWAiCxET2P8bFfZazAYvhp4Fu+lYWX5QZVJGJ1N0skdzV5+YnJUvkGISB9gDDpwRq7lPEDPZZ8bpkgBrUP+7aZ1eD77tm8SkaUisrS8/OAa3WAwfPVoWFmOb68n6vy+vZ6DdignCl2upBaRJOBF4CdKqVp71EillBKRw5otUCn1OPA4wPjx483MgwaDoVNc+UnkzBwVVd6yWau62Jpjly7tQVhh8l4EnlFKBSOA7RORfGt9PlAWpmgJrePl9uQQYgQbDAaD4dDpylFMgg71t14p9UfbqleB4KikG4BXwhR/EzhfRNKtj9PnW2kGg8FgOEp0ZQ/iNOA64GwRWWn9TUHH0j1PRDYB51rLiMh4EXkCwPo4fT/wufV3X/CDtcFgMBiODl05iukjdJjJcJwTJv9S4Du25X9zCIHjDQaDwXBkMEpqg8FgMITFOAiDwWAwhMU4CIPBYDCE5YSKKGcwGAzhsKunfXs9uPKTDns7cOIrrE0PwmAwnPDY1dOu/CQSRocNwXxQ2/kqKKxND8JgMHwlOBj1dDTb+SoorE0PwmAwGAxhMQ7CYDAYDGExDsJgMBgMYTEOwmAwGAxhMQ7CYDAYDGExDsJgMBgMYTEOwmAwGAxhMQ7CYDAYOsG310PZrFUHFar0RMAI5QwGg6EDEkZn02D9PhwV9vGIcRAGg8HQAUkn55/Q8y11RJc5CBH5NzAVKFNKjbDS5gCDrSxpQLVSanSYstuBOsAPtCilxneVnQaDwWAIT1f2IP4DPAo8FUxQSs0I/haRR4CaDsqfpZSq6DLrDAaDwdAhXRly9AMR6RNunYgIcBVwdlft32AwGAyHR3eNYjoD2KeU2hRhvQLeEpFlInJTRxsSkZtEZKmILC0vP7Gn3jUYDIajSXc5iGuAZztYf7pSaixwIfB9ETkzUkal1ONKqfFKqfHZ2V+d0QUGg8HQ1Rx1ByEiMcDlwJxIeZRSJdb/MmAuMOHoWGcwGAyGIN3RgzgX2KCU2h1upYgkikhy8DdwPrDmKNpnMBgMBrp2mOuzwCQgS0R2A3crpf4FXE2b10si0gN4Qik1BcgF5urv2MQAs5VSC7rKTkP3UlLyLKX7Xgst5+VeTEHBNd1okcFgCNKVo5jCXuVKqRvDpO0Bpli/twIndZVdhmOL0n2v4fGsIylpGB7POkrBOAiD4RjBzMVk6HaSkoYxbuxskpKGdbcpBoPBhnEQBoPBYAiLcRAGg8FgCItxEAaDwWAIi3EQBoPBYAiLcRAGg8FgCItxEAaDwWAIi3EQBoPBYAiLiShnOKIYZfSxwdN7KnhpX1XYdZfnpnNdj6yjbNHRx7N4Lw0r9QzP5epV6nouYdfyJCD8efnq8p/jqXwntJyUcTaXjP1Dh/sIxqoGHZr0RIs8Z3oQhiNKUBkNaGW0zVkYjh4v7atiraexXfpaT2NEx3Gi0bCyHN9eDwB1PZfQlLADiHxeeirfIYVaAFKobeUswpEwOhtXvnY4vr2ekDM6kTA9CMMRJ6iMXrb82u425SvN8KR45o4Z2Cpt2opIIVhOTFz5SeTMHMWu5Um4GN7peVlLCteeu5zZb4/tdNv2WNXBXsSJhulBGAwGgyEsxkEYDAaDISzGQRgMBoMhLMZBGAwGgyEsxkEYDAaDISxd5iBE5N8iUiYia2xp94hIiYistP6mRCg7WUQ2ishmEbmtq2w0GAwGQ2S6sgfxH2BymPQ/KaVGW3+vt10pIk7g78CFwDDgGhExkWQMBoPhKNOVIUc/EJE+h1B0ArDZCj2KiDwHXAqsO4LmGY4gdvV0MHwoQFltE8q3iafnXQRAUtoUpp3+/aNi09oPS/hyyb7Q8qAJuQw/oyC6wkuLYfX/wq8beSWML4pcdOlSVq9efSD7yJGMHz8+uv12QFuFemdU10zH54ujuPijI2pHV3Mo9WdXTNvx7fWEhGyRsNdrunioUh3nj4ZI9gQ5nhTX3fEN4gcissp6BZUeZn0BsMu2vNtKC4uI3CQiS0VkaXn5iadkPB6wq6eTkoaRl3sxAJ/tHceuOt106e4deKrbdRi7jC+X7KNit1bRVuz2tHIWnbL6f1C6un166erIjiNYdPVqSktLdfbS0lY3u8PBXsfRoFQjInVH3I6u5lDqz66YtuPKTyJhdHaHZe31WqWS2BbIOQSro7MHjj/F9dFWUv8DuB9Q1v9HgG8dzgaVUo8DjwOMHz9eHa6BhkMjqJ62s6H2bDZwNnNmTgz1Io4mWT2TmHbLWOY+svzgC+eNhKL5rdOKozuGvLw8ioqKKC4uPvj9dkC4Oo6Eevt/OIQusaOrOZT6CyqmD4VgvT66IHLP8GCJZM/xprju1EGISBwwFTgD6AE0AmuA+UqptQezM6VU6DFORP4JzAuTrQToZVvuaaUZDAaD4SjS4SsmEbkX+BiYCCwGZgHPAy3AQyKyUESidtsiYn/xNg3taNryOTBQRPqKiBu4Gng12n0YDAaD4cjQWQ9iiVLq7gjr/igiOUDvcCtF5FlgEpAlIruBu4FJIjIa/YppOzDTytsDeEIpNUUp1SIiPwDeBJzAvw+2p2IwGAyGw6dDB6GUmt/J+jKgLMK6cEEA/hUh7x5gim35deDofdE0GAwGQzui+QbRE7gGOJ023yCAN5RSgS610GAwGAzdQocOQkSK0UNM5wEPo3sLccAgtAjuThG5TSn1QVcbajAYDIajS2c9iEeUUuE+JK8BXrI+Iof9BmEwGAyG45vOvkGsARCRHyul/mJfZ0vb3IX2GY4DymqbqPA087vPPwXg0tEFXHty++eGdPeOkB4iKymWnJS4Vspr0ErsYMSvYNzgLotzHUkxXbpa6yDCUbr6gB6iE1U1aLGXfTx/UBncVjFs52BUz6/890k2bt4CwKr8PnyZ3xenK4bS2B70DuwBIDFpOYmJa1i2fCEez9W43ZnAwA62Gh1Vc56ndl64keqQMnUq6TOuilg20vH7/e+R32Mny5YvJCd3L/X1I4CidueAv7aZlL0Tyag9P6JiOpLCP7i8bPm17dLtpIun3bnYEcH41J0puA81jnUrhXZdKQnO90hK+0Iv542ECx+KajsHQ7RK6hvCpN14BO0wHMdUeJpp8PoBWLe3lldWtpetJKVNocpbCECD10+Fp1mn25TXebkXhy5We9zgLotzHUkxnTdS3/zbMvLKA44jClX1yJEjycvLCy3blcF2xbCdg1U9b9y8hcaA1oeuyypgX3wiAL0DezgjRg/+S0xcg9utJUh+fwNe7/6ot98RtfPm0bRhQ7v0pg0bIjqOIJGOP7/HTuLiKgBwu/eRmKhfYLRVktf7vqQy9l0gsmI6ksLffp7Z0+1sC+SEpt2I5pyzx6fuSMF9OHGs7QptX6XQUFEYddlDpbNvENcA1wJ9RcSuRUgGKrvSMMPxRYLbyZyZE5kx69Ow6/UcTHoepmCe66ZObJWnoOCa0FNa27jBXRbnOpxiOhLjiw70GKJQVY8fP75VT6CtMjioGLZzKKrneIfwi3vu49W5b5Hgqeajaee3qyevN5dxY2fj/ODISorihgyh8OmnWqXtuO76qMqGO/5lyxcC+YwbO5v5r5/Vap1dSf7ZvEvATafq6XDqc/t5FonNgXw2B/K5dmxxVOecPT51tPkORVUdVGiX3fsMkBT9uXuIdPYN4hNgL5CFnhYjSB1wfGnGDQaDwXBQdOYgdiqldqCV1GEREVFKmTmQDAaD4QSjs28Q74rID0Wk1RdHEXGLyNki8iThv08YDAaD4Tinsx7EZPRsq8+KSF+gGohHO5a3gD8rpVZ0qYUGg8Fg6BY6G+baBPw/4P+JiAv9LaJRKVV9FGwzGAwGQzcSdcAgpZRPKbUX8InIN0Wkaz+fGwwGg6FbiSpgkKWYvgg95PUC4EXgsS60y3CMYxchZcbuZH+z/kw1btV79Fv1MW+8EMP05ha2jjoNmNhKGHVS2XZGsgGKf6M3Fk5wVrcX6sv1cNLcHZB4YFx5ODFdW1yZC3Glf8Sy5ckkDKjDV3U6MLa1OK4jQVwY7GFMXa7+pPReQuLya6mvqqShphqA9FTBERNjDddsb19QOGcXhL1SM4z3mk5F+dJpTO/LSbWVRBu6ZlV+Hzbk9OLTFZsoSUqjwFPdrp7c7n14vbmh9C3+LM774FUCXh/n7SnnGyt0YEdnZiYx2TqiWkt5Gf79Wi+xwVXFtlQPrh6ZwKGHL7WfM3YRnF1w1zR5PTGZme3K1tXVUV/vCQ0Dzk6vId4R2267diKJ4F748gVe33pgLtAp/aYwfdD0dvk2Vm6kaEER58VsICMuA+ggJGpb0aXtnO4o/G1normtHz1GmRWJMZDtJ6P5LHIYxVpVwybqcFn1kZeXx4UXXtjuGA6XzuJBnG/Nx7QNuAJ4CqhUShUppY6QWslwPGIXIe1v7s3mulMBmFSykv61WsHbv3YPk0pWAq2FUcrfQpk/1dpQBMFZfTl46/Vvb71eJrKYri2u9I9wxm8HwBm/HVe6js3cShwXSRAXAXsYU3I34o2vBaChphpvUyMAgUCAQEtLWPvswjm7IOyDQH92ueMBKEtI4ouUjKht2pDTi/IkXZcFnmrGle3Qh2arJ68317oZwyWZLvo79X63OfJYmKcdQqChIeQQAPz79xNoaABgi7uBCq/+fTjhS+3njF0EZxfcBRoaaNnfXshXX+/B6/WGln2BFhoDze22ayeSCO71ra+zsXIjoJ2A3VkEmdJvCoMzBgPQ0NJAZZOWfUUMiWo/r9qc05HC30Yjmiurfp1G9zYAmpN3UpuvNUSbqKOC5nb5jzSdvWJaAPQDTldKfdNyCmb2VgNwQIQ0r+RXbKg9G4Dc5FgyRo3gwrdfJmPUCHKTY0P5g8KoNPHQJPFa5NPRE7w7UedxJ4aSCgquYdzY2YwbOzviFAlB/I19GDd2Nv7GPq1XBMVxRfM7nSqjLcEwpi6HD39tHuPGzqZm9SQaN13I5Ms/Y/OaC/hy1Xlh7Rs/fjxFRUUUFRWRl5dPWtpILeIKxFEYKOXDS8aQ0xA+lnFHZHtqmDtmID9c9Q6nluppN+z1VLbveuo9YwH44fALWXjmJSw88xL6+kpBKXr9aQY0vEugYj45M0eRM3MUgYr50PCuXkcLGf44y+68DizpnOA5Y+/RwAHBnSMhIWJZt9sdqj+Xo/XLj+B22/5FEsQNzhhM8eTikBNoy/RB0ymeXEzx5GISYlrbFDyP29VF8LwKc04Hz5usngem4Eg6OT9U3x1NzRHv7cspU18lJXMkzpQD11MWsaH66IreA3TuIMYCnwJvW9Hjvo0O4tMpIvJvESkTkTW2tN+LyAYRWSUic0UkLULZ7SKyWkRWisjSKI/FYDAYDEeQDh2EUmqlUuo2pVR/dES40YBLRN4QkZs62fZ/0MNk7SwERiilRgFfArd3UP4spdRopdTBv+w0GAwGw2FzMKOYPlFK/RDoCfwJOKWT/B/QZr4mpdRbSqkWa/Eza1sGg8FgOAbp7CN1n7ZpSqmAdaP/lmgO9Sb/LeCNCOsU8JaILOuspyIiN4nIUhFZWl4e/cyIBoPBYOiYzoa5/l5EHMArwDKgHB1RbgAwCTgX/epp98HsVETuBFqAZyJkOV0pVSIiOcBCEdkQKWqdUupx4HGA8ePHmzmhDAaD4QjRmZJ6uogMA76BfuLPBxqA9cDrwIOW2jpqRORGYCpwTqRJ/pRSJdb/MhGZC0wATFhTg8FgOIp0KpRTSq0D7jwSOxORycAvgK8rpRoi5EkEHEqpOuv3+cB9R2L/BoPBYIge6aqZukXkWfRrqCxgH/pV1O1ALBBUwnymlLpZRHoATyilpohIP2CutT4GmK2UeiCafY4fP14tXXpij4ptG+YxGNpx1dsLWP/xewCU1TazMXEA5QVjj/j+g+FE33jvcio8zcwr+RXr9tYyLD+FOTMnhoLFFD79FDuuu56mDRuIGzKEN3IzccYG+O6AzfxrRwF7yabGnUMf31biVRMSq7UOIxMrGZ9czpLUPdQneYn39qfRvYXEpmQmXPJZK1uWvX8WHt9ukrwHxoaTmA3J+VRVrMJfk8MFnngWJDXg87up+fQq4lQTqUlf8kTh1a2OJ1K9zv3o73gsJWuSp47aranE+YaTMPAtAkrY/e5EPK5mApm55PXvzwIvbMnpSa8+ffDUrdflkocC4G0uYyIfcaH7CyorV+Op6sW6xb/gzfMqQeCD8y9n/MvvUZaYSEGL7phflJrAr04dx28+e5j3vUNJSh5K7c6dDF75CSevX8ZfrrwZQXjplWd4z1dLbYyQM1CP7R962iRGnTuZ4uJiSktLycvLw7dnP31rkhjiS+fGC12gAizaU8xbi1xsTu2Bw60/Swa8ARzxscQOH0VL8yLysneQHZtOha+K+vKezHDVsmO2FkQWXttDV5qlHra3+0a3YkdeBjFJTrIHfUict4WBr49k1aVaqDbqlcFUpKyk6VQncUOHUrtvKTG7hd4fnMyqSzfiTqmhpSWfmJi91Dam8XqsrsvLGjYRn7SfzKwxVFevpqkpi7J9+twLqpsffn8z82rqAPAFfDS66vDFNdLgayDBlcDgjMHs3raacz7/mO/tLud9Zz0VGT1IcLXWPeSPf4f4pGocZQ7qE1L0adZQS31CCvvK8/k0YQ9465niymF60fsHgklZwXzmPrIcgGm3jGXuI8up2O0J6SGCquptD71HQ201a2I/Izu7iphcLY7zJ+3B6enB3jVjSR32FgkxXs6sLuTZpkySc7eR5dYq+ETXIEZe8IeI121HiMiySKNFox7FdLAopa5RSuUrpVxKqZ5KqX8ppQYopXpZw1dHK6VutvLuUUpNsX5vVUqdZP0Nj9Y5fFWwq07toR3Xf/we5dv1SdVQupP4XUc+npM9nKg9zOiw/BQuHV3QLn/K1KnEDRkCQKCxGb9HK2H7JdTjcOrOa7lKoVHiACj1JrC6XquIU8onEVunQyrG1vUiZW/7kCR5ZV6SPC0HEmyKa39NDr5dgwCIcXhwit53ha8PmxrPbHc8kerVU/066W6tTk5I3Udqb/3bIX4coh+uvCnZ+JwuQDuHoLK5LRsanbzTqI/JU9WLmm1f03UDBETnGbffR069VpCXxMQxv0Z3tN/3DmWrX6uet8QmsrT/cAAECV3E+WWVpLRom8q3bws9MNgV3BXeBra4rc67CqA/BcKOwkKq09NDtjpiFM5YrYnNy9pKfJJ+pnMnVpCYtbP9wdnUw/Z23xyXTDna+ftw0uhoL6NqOtWJL1e3T4L0JrVU15Hrizi8tbouaxvTWO2JD5WpKutPo0dPydHUlMXePXqqF7u6eV5NHbv0qUXAC44mt96HKyE0dcb++DyW9dP3xoqMHiEHYGdfeX8aPWnt0uOTa8nN0k5yo9vF60mRRX5BBk3IDTkHu6q6obYaX5N+KIjJ3YY/SW/X6elBy76+AHi9XhqadJsk523CnVTR6f4Ol6jmYjIcWwRVp21DO2b36cuMux/i7pn/RwIwZ2bEOE+HRNtwosEwo5FIn3FVKHC946c/0IlF8zkLCAaTnDHrU9ZbtobCbRb9kYxZq8iowBZesT0FnjQKSDsQdjH45DZlNnOffVL//tlj7J13EcTCdX/5duhpbs7Mse2OJ1K9VnkLuW7qfF6ePR4cMOPuh1j2+jzAz8VPPMrv7/+bNruoiH/NfYtenmrmnjeBZcvvBmDcGB3y8rwP1gMJjBs7mwWz3wPgzj9MYv7bL4X2Nbk6k8nV+mlz4hsftrKjn7OMuWNO4dRn1oI4uOG5l3nMylP49FNw3fUMBgrvfog5994WKmcPffrYr34HtNDrTzNwvP1sqE1iiovJt46hVV0W/YWPn/krNMdyyjdeZd5Lp4fK8I5VT0VPtQrB2rbdMxpqKXrgUV57/msgQuHTT7HGCida+PRTVCy/ljg4EBo0qJ667nrYrvMULSiCWCierM+RP9/7O6r3DefSy39BcXExTqe2vW3I1l5N8OElY3joTr3t2x5oHT500lPL8cU6KHz6KcoeuQ3wc9ctD7fKU1xcTKUHLrVt/9KiIl57/ms4gOIbP9f2RcHwMwpC8zAFz8Ugrrg4Ztz9kA6n6uvHKVe0Dg+74Ll5gAOK5iOvn4WvJY9Tph7ZELJtidpBiEgBUGgvE2lkkcFgMBiOf6KdzfVhYAawDvBbyQozsshgMBhOWKLtQVwGDFZKdf30gQaDwWA4Joj2I/VWwNWVhhgMBoPh2CLaHkQDsFJEFsGBSciVUj/qEqsMBoPB0O1E6yBetf4MBoPB8BUhKgehlHrSCjs6yEraqJTydZ1ZBoPBYOhuolJSi8gk4ElgOyBAL+CGY22Y64mkpLarQJXPx9kbN/Dt9W+HFKqFTz/Ffb/6LR8W9sXriqPJqfA7ndSlFhBXW4pL+YiL18Kdi1Jiuf2cr7dSW8MBpW1H2MtUxq0lsW81kpBCtnMLzlI3g94ZzVZ/EzsDWugUaGigT1IaZ81+nlmvz2Lbei3eS6xykF5VzcW1OmJaUKk8Y9anISV27/1LSA7U06sgH9/eegbG9+Ksn16qdRBeDzkDrE5sMN5vG8UqxReF4ky/tGIKDRLHa8OGcXb2vSS4nVw3dT7z/vMwJLyPK9ZJc2MzMd5aXP4G3L4mVFw8ySOG07ReK6Djhg6lvGIVjTW9YedvcOTdRADFc55H+X7ut4gLNJK4oSev1V+EX2JY1et0NqdU4QDu2JNHbOHPcCXvxV+vBWgPpf6QHfSjZ30cTQ01qEADcfExlKQkUcg2bqv5G74mH0g87hg3v0m9md3OnvRq2cVuV096+nbx7eLn+Ntl36YsI5f0hgaqEhPJaWpk6cVntlKxP/PtK2mpqmFSXQWSdSqSfQo43cxPLIFAMzcP/Iizen6DHc5CegX2ElABxjaW8ZdLftCuLj9mEwFfgN4vJLPq5gRaRLFv8RkEGhpwJCQQO2QIlK5mpH814wvcfBLTQlVyFQBev4OYlhYyWvzUZzZQX59Ode1M0tL+SVLifjJaXHjczSR5Yxm3r7BV++6c+SCKfBwJCTT4GtiQuolLH3gQ0DoIj2qioLBXSCVeVFTEIw88jKe5nhifnxfHfR2nX/jNU3eyOe1cfIES0lUNAL0dbvo547ju7KnsyO9Fr8Y66pVCOaBvYb9W10BpaSlerxe3201zsxc/TppcyeS6NnOqvM+kuuV4fPV8Ue3mLXcfLlnjI8nfi9hYLYirkTRSPHFM2fgU5fj5aEwKX5w9kP4ffQ1RTbjjXMQ1NxIjMTQ7mykZX81i9ziaa5J1dezZxvg9O/jytBaWJ45FqVhEvCjlJiPzJABGJMVz/8BDm1j7SCipHwHOV0p9XSl1JnABOiaEoYuwq0B3J8WwqI9WU8YNGULK1KkAvDpqApsL9EXlUAGcfj0C2R+bhMOtC+9KSGF+rf5sZFdb25W2HWEv06PXTnJTygBwlrpJXaIfLnYGvNQove+6+Fj2pOsTe9v6bTjrtXLWRw0pNVqBa1cqXzq6gGH5Wr260ZtOnUOrbit8NWxq3KWNSMwGtxWSMVIMa9A3FivcY4PEURHQ201wO8lK0tNxpBQuIS5Nb1cQcOh6anTGUh3bPuxjY01v6nZMwCoADi15rnWk0eTQyl4HAZzBMCdK6QHgQPn6ZBoq4kLbGle7hPw6Ky53oAGUdqo5nn2M8SyzinshoJXUE5pW0tOvJ0ouaClhSNlmAAbuKyHTo290KR4PmVWN7exuqaoh4NWqW0kbDW6twibQjANddlTlVgr8Wkle4ixgVbJNDW+ry5hEJw6XvlXEB5zEKP3bkZCAM1OrmUv9qax26vxVyVXEJOh43S78xAf0ueHYH0tzqVZ0+/bn4arXLzCSvLHk1bePUR7TawKO1F56v7E9GFIzMGRenjOVJEuBn5eXx8iRet+qrAxHk1aKK4cQcOo68AVKCAS0TTXKH3qgGbRtNTn79+p6UgoJE1A5MTEJt1ursP04aVDa7p2OQj5WXwcgOaWJUal6m+5AT+oSDqjpm11eahO1Tc4yH4UrdJicutgSfDH6ganJ30SLdQ4tdo9jl1Pf7EtTM1jdQ1/7n8gZ7ED/VspNTEz0scsPlWgdhEsptTG4oJT6EjOqqcsJqkALqhrBodWehU8/FVKp1iWm4VZu3r/xMm5+/Wn+b/6TbLxoHGsu/zpLrpzMR9POp1dDbattBtXW2ZbDiYZgmdi4eFRDOtdNnc+gd0aT6xlD4dNPETd0CLnDhnPDcy+TO2w4MTnZobL+RD8P3fIQuwYs5t1zS3V+axoGgGtP7s2cmROZM3Mi8fkD2Zk5gaKiIrJctukqkvM6jPcbYnxRKNb0Dld/6mOzmTNzIsN6pJKTom8miamxpGeN5IJLX8Oz6AZq3r+J84pWUdzyOM9W/4FxY2fTc8FIei7Q8aLXLf4Fu0onMe2WscTGxRAfG8OcmRPJ79mXxN5jGH7HR4jDidMhzJk5EUFQaCW0Z0chu989g8mXf8bkyz+j33w/35i3iA8vGcNF78/jog/e4qNp59OnNI89pdOZfPlnNH7Ym4YPe3DB9HcY+0IhNz9dxQcXzODsd1eSv66BG557mZ71zZy7YR1fXDaJ4WVxpDW2nx4CwOF2ULhwBbF5CcQmV9DrTzOITS7HleyFovmMbijgW7vref/cK+kfs58YpzNsXcYMGEPcSeMpXLiCpPg0smMzuPnhh7n54Yf57i9+oeMzF/Q+0EbuRFpa8rnosiVMveJzzr1mBad9YwXnentxdYKPoqIirnI2M6m6D+OmrGHclDUUTP+4XfvGZOcQ2z+HXn+aQWPznlbHVuBMZ5y7Tygmc1ApHl/fTEZlE3f+9gEcAT+guGD+ElyJycQmF4TO0bihuhfeu2YNFy95mo+mnc8ly9/m0mULmTtmYKu/t88cw6cXnsGnF57BkH2xjC1zsvGicWRWV9NQm8rkyz/DU5OKg1gWF72IA4hvrA7VUTyxONxOCheuoCzHQQJC8eRiJMFPU0oDt971QyjZQtPOtfzknttx+H0UerexePqFjPWX0COpkZsffhhHtZ/8PXt5/9wref/cK1k06eyQjYfae+iMaD9SLxWRJ4D/WsvfAE6MdzkGg8FgCEu0DuJ7wPeB4LDWD4H/1yUWGQwGg+GYINpRTM3AH60/g8FgMHwF6NBBiMjzSqmrRGQ1oU9vB1BKjeoyywwGg8HQrXTWg/ix9X9qVxtiMBgMhmOLDkcxKaX2Wj//Tym1w/4H/F9nGxeRf4tImYissaVliMhCEdlk/U+PUPYGK88mEbnhYA7KYDAYDIdPtMNczwuTdmEU5f7DgfAfQW4DFimlBgKLrOVWiEgGOkTpycAE4O5IjsRgMBgMXUOHSmoR+R66p9AP2GJblQx8rJT6Zqc7EOkDzFNKjbCWNwKTlFJ7RSQfeE8pNbhNmWusPDOt5VlWvmc72tfxrqT+3otfsMSawaQi2UFWXYAB+33sSm5BUDy+/Y7W+Qf+hEa/m59v/IR9a1eT2uLlhovdVK2spXZHPCTnMWPyFezNzCWvsoKAamHcznU8lvcxcxZDeYOb7P6D+SSvP8tytOBO3I2cpj5kkvcjALxNjQTqBnPZzOd5Y85YfD4fVfP6h1S0cUOHUL59W0gr8dg9d1KLk+zCvmzbvQ1vgpeHbnmIov+MZyNeBueN4+q/rQXguR8OJ2v7QDJ39QGgty+egZJKojuW9+VzKsWDOyaVhJYAvVUeLakD2V/xMc2u3STE+1DN9WQ7q/lvzk8AyKtoYZjPSU5yHDu3VuOJd3DnHyaxbPm1eDzrSEoaFvo/buxsnrjhPup8u3EnuGnwtrA9cRAVoydy+Zvz8Mb2weuOpZ59tLRspGBQFp+PauTzxNPIyB7D/qovGNv0GXHrY9iaOIQt2YUkKBc7k1zk7N/LjS/+nSZXIg5nDskxpxFQAaqaP8TXUo43qyfxnj2UxjZTcmYS+0p2ktBSS5zDQe7KRHIzU3nr1FSmzM1hn2cnPoeXprQUWmJiaIpJZuiAQnzuFK4671Re+N0/yGl0gigCHj/OgHDFsNOojXHz4a7V7K6vxB1w0+SvZk/zCjwp+YyfeCo9Cvvz1ltv0dzczJgxY/jPtvUE/M1ckb2da67Vl+PclzZTUuKhubmCGFcmuTlT8VW/wVUXFjKg/Lc89vZT7K4sRSnFlqYSGgPN9O3Xl+nTd+CSGD7413B2VO6iuaUZhQJ/C317NPHnaRlQuppbP4ihquBsAIL3oYBzH9XTvgV5I1l65+1k1NRQn7CNEbtycTkTOKVgAFcNn0QgJp0fLLif9DF9qdxTQk25Dt3JwKF4r/wWuX16sejOW4lt8dJn/x78AXC0KM495Vvkpu+jUnmZv+gdlAoAgnK4gRZGDh3M7BdeZO/evfzsZz/T26zciqrW4sox/U6mIGcqnoYqbl83j2aXizifD6fLi4iix9QpJI8cTP6KxZQU62uoVupB+UmKgfO/nszoSbB1Wz0vvlxKY3Mc1c5GHIE8ahNS6HftFZQPOpXU5W9R/epT7Fd5+B3xpAWaqJZ4+l96Bbd8/hZrS8tYVllL5pBhAPzpT3+ioKB92N9o6EhJ3dk3iNnAG8Bvaf2kX6eUqjwkayDX9uqqFMgNk6cA2GVb3m2ltUNEbgJuAujdu/chmnRssET5Qo4hqy5AfrVWVmrpVXtH7m9RSEDnSW3x0ruhGsihduU+mqpdxI3KY9TmcvzEgEBZZj6rYhKh4WOGJpYQrNJlOYWUJKVR4Klmd1w2nzE25CDis5qJzdViO3eLn0BAS00dCQnEWCra7D59GXraJABqcdKEVht7E7zUZ2lV8BSViJXcisxdfYivyaAxtZL+kkAGTpqBnuTTLPvwAdXUgUAPBlLm8NEiiSRQzV6y2GnFaQZIKm2mKeCA5Dg88Q7K0rXwKy/3YkqDeZKGkZd7MQBNDaspb6hBNWZQV7uXZnayO9DE5uSBZLhzqShbyWdbnqfJ78G9JZWVi9Oo823k1B/dyq7EHlQsdVJb/F8qnYm0BAI4m5oIeL2cPEOHtfxk4zZeXT2PlsA/Wx3zT79xPc0pAd7+cj3rvtU+vvPPbjwHgA82vM07mza3W9///j/Sb+BQnnjiCR7/X+sQmwkxsVwx7DTcAT/z1n/Egi9bh1VNTtjBxAlaGb5+/Xq++OIL5s6dG1r/Qu/kkINY+PZOViwvRwREqnE4/s6AfvFcfameimLBF++xZtdGRISAChAQRUNjA9delUZcwMU7az9mS9l2FAoHDpw4aPRaz4J5I1m0bQ37Vr2BiD4xRATXSSOIceczHNi3djnljQ3EiIfa5grcARfZCXr6GH/NLpZvX0VsfQn1VZUE/C04Yly4h4zDmZFNTiCAf+1KfP4Wdrb4CIgDB0JlbRmZhZm0NOynZG8poEAEhQNRfgbnaqV3c3Mzy5dbIUFrSsDfjMTEkpmRQ2paHs0t+whs2kDA5aIRQBQiihZPPSUxBdQlZFJRrm9hXppRgNsBzixFQgo0NsLu3R5UoJ46JXidtbRII/6mZgq9O0koW8O27VV4VS1K4qlDIKAYulnH2y5vamTDjh2ktgRC9nYFHToIpVQNUANcAyAiOUAckCQiSUqpMNHLo0cppUSk88mgOt7G48DjoHsQh7OtY4GsugDLrmztzE979gNAGH7HR63SZc5LuK0YyTvOG6MTi+bD7DHE5eg5ec664XHO2lrCNU/exBmvroD4LJgxn1HFFzEKoOghnluxiWxg7nkTOO+DV4EkJl/+GQDLlh+I4RuHgzinm4uee7nDY4hDaYWrLU7vdJKYrpJgcjE7ntFzBhVPLmbu2uWQAdNumcyCe5+lCph89zUMs23v8QcfBbQ6efP9H+MinaLbf83PH/gzTY0N3Pv1dCoqKvjH65+yrrGW3/7w2zz3fjO1pTu48sorqaqqorq6mpqaGmpqavj3v6+hoAC2le3mjx981tr4d97g3Jv+Tt6gXLIvGMivp68kxuEgMTmZRqcDh9vFwz0z+GHFJiqdDgb3G8xiTw2xLhcX9Sxk/wcLuHTVfL7x4ZfM/8MUhiwJMG3INNxuN56XXsLlcPCLfzzKjz7+Ef23nMQvb7yf0vkPEOMQ+l71W+bM+ifxMb1YXDSL3794Hif3zOWi+x/mmf83D4fDwbd/diWjR49GRCg9YxQ3ugfidDjI+enlOBwOnE4nBQUFzJj1KfGD7qPim2NwOByICE6nk5ceupu4GJhRVMQ3v6lfADgcDq74YgsiwtwxB6azWNymauznQ87UUXwy80BvvWzWKp0+c5SOqQws3fpF6BwonlzMh7993jpH9UwAy8OEcZ72xkvg3cvcMRM5+69al/vOpae2y/fmRRP495mDuWD+klD87Rl3P6TP8SZ47fxRvDlST0VxwcK1FP9W9waKbv8DxcXF5JJPReX+Vtv8+3d+EPrdp08fNm60Jo+wzfn1wM/fYz9w5z/uIOY7Wt39/Sce5YHb7wTgzrsf4PSFc2BIf1bu1+t/d8+vAfjFPffxygtfo6kWfnX354wfeQoAky//jDMXPAfAB5Ov1vuafA38jlb114qrL2NSn0Ju6ORaPFyiDTl6MVoD0QMoQ8emXg8MP4R97hORfNsrprIweUqASbblnsB7h7Avw3FMc3MzixYt4oMlH1FdW8OSrSv5+INPGTv6awBUlu+j+C8P8fcH7mxV7vx3+4FjNCrgZ/369aSnp5Ofn8+QIUNITU0NdcV7paXwnQljuPCXv+Kdx/9DrMvNDQ/8mjXzdI/psssu41/TL8bpcHDDcy9bzhPGjBkDCzeRMWEMi+78LcMW6XmlnjtnKm+ed+CSyB2RS+6IXO6bfB8AOzZ+CUBysp6rKrN/JtdPvp61ux8HYPi0aaxcsDBUPicpkZykRE477TQ+fHndgX1b5OXl4cjK13n79GlXf664RDKtXl6QOGtOIQCX68BsOcGneIPBTrRK6t8ApwBvK6XGiMhZQKffHyLwKnAD8JD1/5Uwed4EHrR9mD4fuP0Q92c4RgkEAqzY+AmlFbv5aM8zfDr/fUqryylybOauu+7C6/Vy0UX66U1EyF2fi1NiaGnRr9WSU9M566JpfOfaK8nOzublp7aREJ9KUdGlvPfkClJ79GPB2rUR958eH8/pfXtz+eWXs/f1dwAYNWoUWxbqVwsxMTE4HdGO4zAYTjyidRA+pdR+EXGIiEMp9a6I/LmzQiLyLLonkCUiu9Ejkx4CnheRbwM7gKusvOOBm5VS31FKVYrI/cDn1qbuO4xvHoZuRAUUmzdv5oule1m7x8O6N68md906fnaSfk3yyNO30dBUT3x8PLnJWeSmZdOrl57BMzk5mU8//ZT35y4kJSmF7931Y35//99C23bHxjLu1K9z7bX6tceSN98DIC4urp0dBoPh4InWQVSLSBLwAfCMiJQB9Z0VUkpdE2HVOWHyLgW+Y1v+N/DvKO0zHAMEAgH2lZdTV+cJpc37yTye3PQkACLQt6+fs2NjrWXh3ptnkZ6SxbfuOZ8379PvYSffeOC0OeWUU1j1zvE7Ms1gOJ6J1kFcCjQCP0XP5JoK3NdVRhmOH5YvX878+fP55JNP+Oyzz6iuriYpMZFZT+rxAkOmDuHGYTdy0s5ihvVIIvHmN0OBbQD69xwKmHfgBsOxSKcOQkScaB3DWUAAHVnO8BUkEFB8ub2Rjx5+mJ/97Ge4XC7++9//8uc//5nhw4czffp0qvaV0qugR6jMwPMH8p3J34HiuR1s2WAwHIt06iCUUn4RCYhIqjXs1fAVoqHBxyef7OWvf7mBV+euobrOD9zGueeey7hx4/jFL37Br371KzIy9JDC4JA+0yMwGI5/oo1J/QowBliI7duDUupHEQt1A92tpC4peZbSfa+FlvNyL6agoPVnmKf3VPDSvqrQclltMxUeLXJpioGC2gY+8TzUqswp7h/jx8eN774BQP9xpzH5e9cw8blXCAQc3Laikrp9jYgPvLExuJtbUC5Izo1nX3UmiZ7d5NT+m3u++Qh7MhLp3SwEpBRHrG7K3c4CCgI7+T/fr5kV92u2ebKIa9hJTGoKjrWrWHvrgyQlOzh5fAInD0zmR/etIDfXpm9cWhwKE/mbjcMIBBTx+yoJKD8k9mRQ0iDw1jOox06G//Ihdlx3fSi29idxeiaWU5sWUJ9yFjUJip8M0zGmz+xxPr+/YCaPP/goFb4a8nv3YNeOEuKdqdx61w+5894/425RjErTYR93bq2mzBFg84jEUJzrOTMnRmyvv838NvWp6eQOHc6eLzfjqNxHij8OX7MfV6yTrF5JvBqXxYb+I3AoRUVGKoVs46eVf+ZPGT9lB30Yum8/G9IzSa7fydikN7nkkcUkIFywcC1FC4rYWLmRwRlaHHb139ZSUOojedhINpSvYv0QxU9O6sm+d9ZQvj2ZXbED2JLUgs8FGc4Yqlu8pMW4ueG5l3noVi22u+333+XLv86jpUQPV03ADa5q+vzmslbH9uMHPiSptJmEWP0MWJbupDQrhiHLnya1sZyC/v0pbyhna496qgbHs9h1BQAn+14MbWNKvylMHzS91TlbU7Wak/2L+Hrdslb7S1AppO87nVznZWzKvo1mh5en43qFjj+og8ipS6MsuRqAjPhMsuOz+V+qYkF+DM4UN19U1NC/NsBDS6r41YRMvkx20KO2AaUUo3dVcsqOCgCaq1uIrVvKoktWUF82mU2FY2hI8tHoGkB2bQOjPD/jkmfqScAR0kGUehPI692f0pKd5DlrKMqzdA5WDOy/F91EU2MFce5UAkrhcnhwOz2olliIH0XGoGmtFPp//84P8DX7KRz9XdaU/Q+/20mCU3jt1BHsdvYkpUKru+MSBHesFyWKGIefQIuTpP0J1Gd4EFcA5XOwy92bnt5d5O/QMxpcOrqAa0/u3eocKqttxld7Eun+Mzn97T/jdXgJxOrrUFJ68PNHfx3xXO+IIxGT+iXgLvRH6mXWn/ly2IbSfa/h8ejx6h7PulbOIshL+6pY6zkQQ7jC00yDV8fsLaht4JRd+9pvWDUAegqOJs9etiz7GICAiiFgNWFNooMmt35qb3ILNYk63RezB/Hqi/mM5UvpUamdgiO2HqdTx9Dt1bKHcXXLWL7YQ8ndv2b3lVPZ/4IefVwz8nyG/+FO/t8z/bn1uly+npLc2jmAdg6lWuEZcMQjVjRap7eGWI9Wk1a09OHLxjMBSJk6tVXY0SDxPkVqgz6GBrWTD/a8BcDA+F6hEKTxzlTSY7SOwd2icPoPlI/LjsOTpz+AD8tP4dLRHU89UJ+ajjdWx5UOxMUSyNDH5Yp1Ep+sb8DrB4ygPEX3jvIa9jGuXtfluPql9PLoCQEGlOzkwmV6wF0CQiZawT2l35SQcwB4d4ifkjxdNzl7mxm6Rtd/bUkaqka3V4bPQbLVpmkxbgaNbn/dtpS4iUeP1KrxK3aT2C7PMJ+TnIDeTlJjgJwqXVFr4vpTE69DwjbsKcO9sapdWYCNlRt5fevrQOtzdlugBx/7T2+X35u4k6pcLeRsdnipcmotyeCMwUzpNwWAwPCEkHNoaGmgslEL1ebHtrDep8/v/rUBLtyjbT1tTwM9rXjqu1PjWd7zQAxmr7uA5mRdN5sKx7A/Tb/WzKptYFCJ3m4CDjJj9XkzMrGSPLeOC53nrGGkX5+v9hjY/bMgLkbHJW8JuPH6db3WeIUaj5Zr2RX68cluXLH6d5ozm1jrYftr3iUUtBzQELvcTTicemh2i99JoEGXcTS6UD7dRj29uxi2S18r6/bW8spKHSvcfg7tbtjM3pZPAHC6h+BwHgjt21VE+5E6TSn1F3uCiPw4UuavMsF5fuwK5LYMT4oPKVZnLNFTIcyZOYG5t1qfd342v1V+xzMv40ArNu1qT8SBQ2Da729opbgM/v6h7Xfx5CVw0QTOWfcsF8xfwuzXr4YWuHbKRmacehlPfvEuNQ21ZGVl8YObv8cNN9zAuHHjmLZiE5x9A9eN+Q1vnjc8zIQfFlY8YnXXgyhnHLc++Vvm3HwRsJ9pv7+BuY8sD2VNn3FVKK72ciu98JZr2fXTOSQDi4te5OTiKw7UV0Jfhif0JadoVKvtAPidWmF9qLibGykqKqK4WCtVi37bWt774Ktvkd5UzefTg3NTTgP0qI0gwY/uhZOfYscjB4Rs0wdNZ/qg6aHlIop47jzdRhuCgrqi+bjfuR53AVz49FNR291IE8MePr9dfQTJSY6D5Dim3TI2lOfOmWOZMQs2cCr3zpzIfT+eRgIxFE8u1u0MFI+x6mFB63oInrOnz91GgMyQ0j7IgpdOoUVqyZk5itK39Yj04nNbq3+/fslUuIRW2y+efBUyfyWDm2HumIEsm6OFguMevoBxwK+ssoPnL2N/YgLf/Mu3AfjXDU8B8RTfuJQxc14ns7qKFTOu5oGfvwekc+ePl7Jj0YHBEOOTyxmfXA5Ff7SU0W4960BQJQ1MHlYCwwgppgF+9IdJ/P76mwF9nj0368DUJYlpbhLT3Nb5d+AcXLb8Wr7Bq4y7YHZoGWDc2NnMmBW83lv3bPX+8njsDxNDeaD1OXRy8RUQC3OKJvLs0m3AYK75Z+T7zJEg2h5EuOm2bzyCdhiOIkopvlx3oBdT6alicI8BvPLKK5SUlPDXv/6VcePGdaOFBoPhWKCziHLXANcCfUXkVduqZMAI144zfIEA7+6p5JaRI1m7dhf3/1lPbvi984sQES655JJuttBgMBxLdPaK6RNgL5AFPGJLrwNWdZVRhiOL3+dn1qxZ3PXeasqbvIwaNYqbb8mjd58DgjWDwWBoS2ezue5AT4cReSiI4ZjH7/Vz2223kRfn4scj+3DH4pU8+0b7j8QGg8FgJ6pvECJyuRX6s0ZEakWkTkRqu9o4w6FTsqyEb3zjGwT8AdyJblasWMGfJg5lfHaq6TEYDIaoiHYU0++Ai5VS67vSGMPhs2XLFhbetZCSpSX069ePseePJSk3Sc9vbxyDwWA4CKIdxbTPOIdjG7/PzxfPfsGIESPYt3Yf478znnXr1pGUm9TdphkMhuOUaHsQS0VkDvAyEIptp5R6qSuMOl55w3sS73uHkrRiEx7P1fj9DTg/eBX8XvBrIdBmR29SfLs5uVhHwUpQ5VzW1ATF2eC9CNztRU9tafLs5e/f+QGBs85FOWIoWlDEl5VfsuWdLVx88cVwCSRmJRJrzZpqJ2u3hzcvmkDmlX6cwI7zxtCUN5O6xF6h8fKDJuQy/AwtMmspK2e9cjBl9gaqi/5An/3lfHbXgwDEuhrIdTVQ1TQBVyAZfv1HnA4/7kCsHl/urae8OZE5995GxS4POAYx95HW9sTv8dA7wakjkrkywXcgyldDcwszZn3K9/ZqkdEPZ33KsL37SGmM5a5bn8btrEOpxlBEMYChp01i1LmTW+3jlf8+ycbNOqS61++lxQrTSmwc7qaGdnX03TdfYkmzdqxV8WmkN1Z32ibRsrFyI0ULirgERUK4GKwdEN/Qg7mPLKef34XL6Wu3fu2HJXy5RAstK3Z7yOp54OGgYreHuY8sZ9Te5pDQCyCusoU5995G+SgdG3rOq/8CoCG5H1/0G8qwRfOolWxSVDlFCx6koeVS9qfmM23FJsobyqls0oMZMxN/jDMmwANvPosj5hZGe5fQ0Qj92PV9yNxTwF2LnqbplMHEIHz42+fpoXKoFn1ssxfvDAnGGnKcBJJdIb3GngvyCSgvjz0zj8rMLHIr9rHjuuvJc5wL0EqtH6J0tT4vS1dr3U4n6UmNAeY+shyHHwL+Mu6e+X/09vpJcDuZc+8roVjs4fB41oX0D8E46G2xH9+A5hZyAo5QGwHtrseBZcPoWzGIuY8sp9aRQZJnd0iDEzt0CHl33NFuH4dLtD2IFKABHbjnYutv6hG35jjnfe9Qtloxkt3uTJxOHT8Xvw+UVof2Zhsn24LjNcRWsSLe+pzjToTEjtWR/cedRlySjiLmDyhK3ngJX6OPoblD+evLf+X5558nMSu8k3FecBYV1k3DKQ5irBtUTukykr3lgL6RBG8yAOd8/jEDdu8AYHdWFhusifgc/liaffr4XIFkYqxTKVMlMRgd52lon0Sy8/XxtDTvg8CX7WzqneAkOai+8+1HNegbeVZibGiaCDubspdRkaAvqoCqB+UNrSvfvo31H7/XrszGzVtoDOidtARa9BQggKuxnnQrLKSdJc1JVMWnAZDeWM2EWE+7PIeCXRVrV1xHw/6slTQmaFtdTh8JrvaO7csl+6jYrW3N6pnEoAlaGT5oQm7IWdhV1dX9YmnKCP+MuDV/JA0JPQFIUeXk+/W0FIXbl5FZoxXklU2VNPi0HU0BF/4WfQ7spA+f+7/e4fHkl5xEZr1+CGkOQIslwawWH2Wx+rx8ZWUJ6/bqa6NPM/SxRcBT0kxwdoGc/fs5aXv7UfdxQ4aQMtW6TY288sDNP2+kXu4gvSzdiSdeH09s1ki8CbouE9xOspL0g5c9FrudvNyLWzkEexx0O/bj8+TFEpfdPo6J/XrsWzGIjIYsADLShV7u0nb5jzRR9SCUUmGixxrC0c9ZxtwxpwAHYvvaY9o+PX8QAI8X6Ztl0X/GQ2ws3DgfIqhi7Uz+3jXANWzevJmfT5lM06YtnH/uk1w/7fpOy577o4fBmj0r+HRTWDQbrrueAb53KLzlxnbK3GkbVzNt42oKn36K8S+/B44Y7r7/Dh66czYEoOj2O1h2m6V+fei8UGxiir7LKNBxryH0lN9W9WyPZbzjuj+E0nNSYslJiaV48sRQnjkzR1G04HH2sJviycXcc+fPUQgz7n6o1T7CEe8QfnHPfa0U529eNCFi/vTGar645PyI6w8FuyrWrriOhorcxVTkLua2G5dSdu8zEfNl9UxqV8fDzygI9QiDCmGAqsHxVA2O59eTdVxygBnTdF3+be5b9K6v5aNpwedA/f++N6YxZvcafj19LkULdE+y+JzWiunT574FdPxqM4Y0GhPg/t9fx7j/LaVBwRm3X9Xu/Is0n1awpzPj7od0mfh8Cp8uotQ6vsI/tFGljy/Sf22JkF6aFUNpVgx3zmytko6GgoJr2s3BFolwxxdUa985c2y7+qhMqOCntwRV/RcclF2HQrSjmAaJyCIRWWMtjxKRX3VWLsK2BovISttfrYj8pE2eSdaIqWCeQ5uF6gTlhRdeYOzYsXhL99Hz3ju4/vrOnYPBYDAcLNG+YvonOia0D0AptQq4+lB2qJTaqJQarZQaDYxDv7oKFyzgw2A+pZQJTmTxyCOPcNVVVzFs2DD6PfYXkk8zEhWDwdA1RPuROkEptaTN+PmWI7D/c4AtliDPEAVXXHEF1dXV3HXXXYz+8K3uNsdgMJzARNuDqBCR/qC/JInIlegpOA6Xq4FnI6ybKCJfiMgbIjI80gZE5CYRWSoiS8vLy4+AScceDSW72P7ffxMIBOjTpw/3338/bre7u80yGAwnONH2IL4PPA4MEZESYBvwzcPZsYi40ZP/3h5m9XKgUCnlEZEp6OG1A8PkQyn1uGUb48eP7zz60XHGhx9+yJp7b8MR42LXrl0UFhZ2t0kGg+ErQlQ9CKXUVqXUuUA2MEQpdbpSavth7vtCYLlSql2EHKVUrVLKY/1+HXCJSNZh7u+447XXXuP888/HlZrOyPt+Z5yDwWA4qkQ7iulBEUlTStUrpepEJF1EfnOY+76GCK+XRCRPrA8eIjLBsnN/uLwnKs888wzTpk1jxIgRjLjrAWKzcrrbJIPB8BUj2ldMFyqlQjI9pVSV9ernUIe6JgLnATNtaTdb234MuBL4noi0AI3A1Sqa4NldSNtY0pfnpnNdj6xW6Vv9OfRzlnW6rSy3n2WvjwBgamIMTp/w8uyxOPIEB27efrKSko1NnNQvhW/3zuHfycmUZOYybNE8ADLiMshOyA4pXAGWLl3K6tU6jGJuZS5b4rdQtKCI5MYVnJLsaBfhrrp6NU1NWRQXF9Pcsz/9GtNx/HQOAx0Z+HGx5hatbdiafy5bXGW03P83AiOG4RAt7hoQSKR/Syrr7vqYdBVLlYQE9vj2ekLahYTR2SSdrIV95du3Mefe2/gkrz/LcnRvKDErBUdMDHErNtF84XTO+uQ9rrruenJ7ZrPoa6cxbcUm6nMbmLzLxxm3zuZmdQ7bA18yZ/FtOFoUgdiEUDS4cuXG29TI7+5pPSq6wa8g0EjRgiJyF67irA1OdjxzPTklDWzPFZ1emYu7wc1tj9yG9DsbFb2GDYCmDRu0erfMS1ya74D2xYp3rBvpQOxuvPU0VbvCK37DML56IqOqT6Ls3mfwNWbiij/wvBRUSbdVTwd54csXQuFDe8rZpNdncdetT9OD09jfowQs4flaT2NIqVySlEaBpxqAVW8vCAkQ4ypbqEz2tou3bcffEqDF28zfv/MDlg8YzJo+AwAIKMWQLZsY9eV6Ng4YyroBA3lj7ltUJKWSU9XAAz9/j6TGAJ54B8/N+jQUV7ytDUA7FXOwDpIaA5Q5AqGobMHYzpGwq5mjyX8kWLe3lhltji9SnlF7m0lqDPDAz98jvSGLqsSKLrWtLdF+pHaKSGjeBhGJB9rP4xAlVk8kUylVY0t7zHIOKKUeVUoNV0qdpJQ6RSn1yaHu60hhj8u71tMYcgr29H7OMr7u7njKqtWeFCq8B+4+MT4HErACKysfe/ZqRejoM9z8+tc9iHe5GPXlCjJqdgPQ4GsITW9gV7iuXr2a0lKtrExoSqB/Y38ATkl2kO08cPMO0tSUxd49+kKojHWwNVkPSotVTTg5MI1DSWwlDTH6+BziJCFeq7R7uh2kOvWotippZk2mjqebMDobV76+Sfn2emhYqR3Y0NMmhS7oZTmFlCSlARAIBAi06H1vyu3Bu6dO0nn6jWd/fJ5OT3Dwep4+VbOcuQx2aeWrClTT4j5wbAkpqbjj4ttXeqCRfXFahXzWBicFpfr4/AN6sePkXgDUZ9XjTdCqbOWE+IT2qtZI2GNsx/UtIGW0FbPbFu8YaBW7O2V0LnF9tXitleI3AqM8J5Pn1e3lit9PwlBtn10lbVdP23l96+tsrNTnSXmPraGbTGZ9AfklJwH6gWd40oG6K/BUM65MDy5c//F7lG/fBkBCjxy8g7VS3h5v2o44EkC06nlNnwGUputY0mXpmazrp53FugEDKc/MBCCnspQhW/QDhT3msz2uuN0GaK1itteBPS65PbZzJOxq5mjyHy6Xji4IOYVIcdPteeyK7qrECsp7bO1S+9oSbQ/iGWCRiAQlk0XAk11j0rFLMC5v8Cmrbfqy5Xd3uo33Gwp5v0HHXQb4zIox/f0nHmXmKeN4YskaXnzpJQJ1vwY33PDcy7y3oIjR7Kb4HCvGtE/HDg4qWYPk5eW1iq/80OSHWsXDtVNcXIzTCUVFRTz+4KMA9Lp/Rjt7P3lwI9mkc9MdP+AT23H74hopiWvkjNuvCqmTb+BbJJ2cH+oxhFTVwKhzJ4fmSHpuxSaygbnnTWDtHS/rOrziFF2vGSkUXvsUvqfm0Lt8F3MvPJWxL7xMJfC1319L2axVJJPL6JnTrf2W85vJv+uwznW+WIonF7PjmeshAwqffopCYHyY/BvbtG9n2GNst8IW7ziEFbs7HawJSaLE6aY0uZqBt3+jVbJdJd0RgzMGUzy5ONRbAK2qjkE7het6ZHFdjwOf+YJK5SDZffqGFOudmupKxulK5vtPPMrbKzbRA5h7wckMnr8MT2oetz71GJ+s2EQvYO6Yk0MK+Bl/6DjMfSQbItWBPbZzRwTVzNHmPxyuPbl3pz2USHnaxgk/GkT7kfph4AFgqPV3v1Kq46vScFC8+uqr/HPJcgZnZ3L++Ud2igeDwWA4FKLtQaCUegN4owtt+cqydV8pt159NX3S0/jJGSeTkJDQ3SYZDAaDiSjX3Xiampi1cD4FBQX89IxTiI2J2mcbDAZDlxLtR+rfAZcopVKVUilKqWSlVPjP74aDIikujku/NpEFCxaQEnfI3/0NBoPhiGMiynUTPp+PDRs2AHDq4GH079+/my0yGAyG1kTrIJaKyBwRucZ63XS5iFzepZad4PzsZz9j3LhxVHnqutsUg8FgCEu0L7ztEeWCKMCEHD0Eyj/czqPFL3HLLbeQXt3U3eYYDAZDWExEuQ6wq6TXehpDQiJvcxkbGp2c98H6kHp62fK7W8Werfrdj6ld+AEAX7hiKIlLgfnn8/X91fzxgxWM6FvI2AQHpSV7cEkaO667nkBDA3Xxscy59zbcQ2IIxMRw2yO3MSGlkR6Zu5n38te5LODHhYN3Xj6X6QEvzY4W5r9+FmnpXny+sUARiUnLSUxcw7LlC1vZZFdbl5aWkpeXF1U9KK+fslmr8PUMAFC2ZBV5ngy2xu3uUFELB1TV/0tVLMiPwZniZk11A4MbFGVLVpEYSKHaWxaKi7w3NYtpKzaxPacXeWV7+MeV5+O87GbKsvKZMvs1yMjkglI/l/90Drf5zqS8cjFv/u1AZLj147L44tRcdjpGsNepbXJ5LuDCZZ+z45nIquVIbd2deBbvDQkN7fUNOnxpMDpdELti2k5H7ROM+w3tVcRB5XtHsZfD4fMH2JPo0LqHWAdJzQFmLPm0VVzpaOrYrp4+WBva0lYxHaStmjkalXN3Eoxp3pYhGUP45YRfHvH9RTuKqaeIzBWRMuvvRRHpecStOcawq6SHJ8Vzea6WNk3kIwrZDrRWT9tjz9Yu/ICmUl22JC6FJqebJl8LTy5ZQ3JsLD+efilOpwOXpBGndJznPklpZFpzLqkYN1jTWvTI3E18kp5aIUAAH/pG7Udh/SQpqYqcHG1TYuIa3O597Wyyq63z8vIYOdIWuD0CjiQX4m4/74Q3W9hcoLcVSVFrV1XPj21hvU8rmAc3KC7YrRXQKs1BdaI+tkHrl5Ffo1W+udXlDN6indlJX66gsELPLv9lios387Q98fE9yc44ObS/nJIGhi7T5fc6B1MrOh52XWJvlvf/GhBZtRyprbuThpXl+PbqGNP2+t5YuTGsI7Arpu1Eap+sJHco7ndbFbFd+R4p9nIk+u5sJqNaq+OTmgPk1OmZAuxxpaOpY7t6+mBtaItdMW3HrmaORuXcndhjmh8ton3FVAzMBoKPLN+00s7rCqOOJYIqaTsXur/gQvcXNnXyJWHLxuXFU7hwBeU/ngbAL3/3Mh8MHMbE7Hy+8/BfAHj2u3obhf/8Dfa5Wue/fhYAD93yEJ/NuwS8GZxy2ashlfSlNgX0TXf8oN1cS15vbjv1NBxQW0eLM9mNM9lNTtEoXJbCOOeigeQAwzmnw7J2VbXMX8ngZpg7ZiBlS1YB8eTM1BGr+zJJF7j3Ni5Y9Q4zpj2klbwOmPG/1kGRpq3YBDnQa/qplM1aRRy5DH50CQA7rrueDHS86aDafe6Yk3XPIyGRwqfbxCluQ7i27m5c+UnkzBzVqr47UtSGFNNRkJMcR05yHHfOHNtORWxXvh8sI3Z5GbHLy51/mHRI5e0cjIK7MyLFtw4Sjcq5O7HHND9aROsgspVS9rPuP23jSBs6RilFbGwsNw3q/KndYDAYjgWiHcW0X0S+KSJO6++bfMWm3z4cKqvr+cez77JixYruNsVgMBiiJloH8S3gKqAUHWr0SvSEfYZOCAQCvLJoOTW1DWRas1caDAbD8UC0o5h2EOlFu6FDZs2axfaS/Vx6zhh69+7N2u42yGAwGKIk2lFMT4pImm05XUT+fTg7FpHtIrJaRFaKyNIw60VE/ioim0VklYiMPZz9dQe7G7384he/oH+vbMYMO3Y/fhkMBkM4ov1IPUopVR1csCLKjTkC+z9LKRUpRNKFwEDr72TgH9b/44and+tDu+ScMVgRVA0Gg+G4IVoH4RCRdKVUFYCIZBxE2UPlUuApK9ToZyKSJiL5Sqm9XbnTgxZM2cNI2gg0e/hB72y2XX8bKSXziK2K54Gfv0fPERdRl1THo7/6o86YK4AKDVkdGN+L4Ql9UbkB3AnlfDbvEhrd24j3HhAJlZaWUlxcTIWvhkyVpEVsBR6aEnawbPm1uN378HjSKS4uxl/npb8/j+EJffHtrwdaB/IBLYTbL57QEFo7bQV19rCU4cKuRkrfGAuD6izB3V5PSB/RloMVZ9nDmzqyLiLQ0MCun86h+dReEGhkxx/vJ/D1i9jcs7Cd3Xb8tV4CHp81BLd1qNTDonT1gcBBpat1wKA22AVxbY8tUj2FE0x1JIiLRDBU56i9zTQ0t/DAz98LresxKpOi6yOPulv7YQlfLtF6m7K6Jio8OiJffL2fxsSDi9kabPe2aYcjjoNjX/h2rBPtTf4R4FMRecFano4OIHQ4KOAtEVHALKXU423WFwC7bMu7rbRWDkJEbgJuAujd+/Bf4wQFU8OT4qMTTAXDSNou/JoGHyW+GPwxqaQV9Cd+ezwxfhctQG2yh1pHA6n+YMwHhdMK3Vnh0xFYhyf0pa5iMMlZQAzEe/uSk6aFTnZxW056Fv39+uadvHsC9ATSwOXqj8/XB4Cyqgr8qonhCZEvtEGpfdjiLA27zi6os9dFUFR2XY+sVnUWKX2oy8XkZn2crvwkEkZnt9uXXQgVjTAqYXQ2DbZlp30QgLhCL1Anl+5kUa9e7ey2E/D4UF4/4NChUuHwHcTIK1sv541sn8YBQVxbZxCpnsKJ3iCyIC4S9vCkWUlu7F35+Ho/e1Z1PFDxyyX7QnGwKzxeGppbSIiNoTHRSY9R0Q/IiNTOhyuOswvdjkXh2/FAtB+pn7K+E5xtJV2ulFp3mPs+XSlVIiI5wEIR2aCU+uBgN2I5lscBxo8frw7TJuAQBFNWGMkgd//kJxQve58nJvZjzsyJ/P6TfxKIaeHOP0zi8QfXkE0aN93xg3abCT7B5xSNoql4Ik1VE5naRtQ2fvx4xo8PEyhzFmSXXELO1FGtkoM9k5yZo3AVLwtt304OozgrisO0h6WMFHY1Uno0HKw4yy7Ea4tj/krAReHTT/ET4CdWelv77IjbSc7MUe16WIfM+CL9FwVBQVw0HCnBVEfhSu09iY7I6pnEtFvG8tysT4HYDoVokTgcUV5HHOvCt+OBg4kotw44XKdg316J9b9MROYCEwC7gygBetmWe1ppxzSrV6/m0Ucf5YK8XiRZ0woYDAbD8Ui0Oogjiogkikhy8Dd6ltg1bbK9ClxvjWY6Bajp6u8Ph4tSih/+8IekpqZyff+h3W2OwWAwHBbdFd8yF5hrjeyJAWYrpRaIyM0ASqnHgNeBKcBm9FTjx7ww7/nnn+f999/nH//4Byn/W9Dd5hgMBsNh0S0OQim1FTgpTPpjtt8K+P7RtOtw+fTTTznppJP47ne/y1vGQRgMhuOc7upBnJD8+c9/pr6+Hqfz4Ib4GQwGw7FIt3yDONHwNLWE4ksnJiZ2szUGg8FwZDAO4gjwx7e2MWLECHbs2NHdphgMBsMRw7xiipJNr/ycMs8iAJrT63CVCut+OhJPs4ffLd3J+QU92Xr7rbwX0GrSrF4n0SN1OCtveZH+ueMpcXt4/MFHqfBWk+VOi7ifoEr6YEKCBrGriu1K4ApfzSFvsyOCquq2ivNI6UeatgpuO3blth1fzwAbY2Hq/JWt0je4FUO8B6ZDiVSXRwq7erojxXR3El/v71APkdQYwBPv4DmjVD5hMQ4iSso8i2hOqyO2OhlXqZC8Smvy/rarliZ/gJ+fNJqdAS81yk+qOOmROpxUdya1/mpK3B5qnE3kkECWO43hA8MPgbWrpKMNCRrEriq2K4EHxh+QkhzsNjvCrqq2K84jpXcFdqV2W+zKbTtT6vTUJm0Z4hUuS0sGItflkcSuno6kmO5OeozK7FRJ7Yl3UJauv7cZpfKJiejBQicG48ePV0uXtpsY9qA4EKqytfr342f03ISnfWMFax88HYCsb79IQa9Ceo07h22fzg/NJTPj7odY+kut+Rv/8Jnc9ohOf+iWIxM6sTOCT752VXC0Kt1jHXv7RGqrI0lX1d+J1i6G4xcRWaaUCjM9g/kGcVh8+umnIMLQC6/vblMMBoPhiGNeMR0Gl112GRc//Cru+GPv/bHBYDAcLqYHcYjsq2kGMM7BYDCcsJgexCHgaWph2l9X8CP3XdAz+umVDQaD4XjC9CAOgecWl1Lb5Oeyyy7rblMMBoOhyzAO4iDxer3895M9nDogjXHjxnW3OQaDwdBlGAdxkDz//PNUeHxcf1qP7jbFYDAYuhTzDaINDdVeGuq8zH1nOUllm8lu0UKglpMzAQd/ufVPFGTkUZN3JQ/cfifjJZY4Rxx/+9VHQDq9/RmUzVpFOor9eClaUERySzIJMQkd7vdIE1QCH6sq3cPhaCm1D5dIsabh2FVPGwx2jINoQ0OdF1+zjk2c3eIkxZlKrb8Grb4N8MfLH+StxkV4Y52It4U4Rxwx4qJFtVDjbGaX1DIR2I+XL1U1AAkxCWTEZxy1Y7ArgY9Fle7hcDSV2odLpFjTcOK1i+HExDiIMLhinUy7ZQxr79hJIx5G/+4KXnv6HpRSXPKnC1h110oIwPd/+2veu+dDACbdcwa/v/9vNKLVsX+79WkAiicXU7y3+Kja31Gs5uMde1zs44GDiTVtMBxrHPVvECLSS0TeFZF1IrJWRH4cJs8kEakRkZXW36+Ptp1tKS338oM7NvPZZ591tykGg8FwVOiOHkQLcItSarkVl3qZiCxUSq1rk+9DpdTUbrAvLPMX7mdPaTM9e/ZkWXcbYzAYDEeBo96DUErtVUott37XAeuBY3oayKamJhZ9WM2p41Pp2bNnd5tjMBgMR4VuHeYqIn2AMcDiMKsnisgXIvKGiAzvYBs3ichSEVlaXh5+xMjh8uKLL+Kp93P+WcfuB1GDwWA40nSbgxCRJOBF4CdKqdo2q5cDhUqpk4C/AS9H2o5S6nGl1Hil1Pjs7K4ZFfL444+Tl+Nm5BATTtRgMHx16BYHISIutHN4Rin1Utv1SqlapZTH+v064BKRbhm6opTi//7v/7juylwcjvYBaAwGg+FEpTtGMQnwL2C9UuqPEfLkWfkQkQloOzsOb9VFiAgzZszgjFNSu2P3BoPB0G0c9YhyInI68CGwGghYyXcAvQGUUo+JyA+A76FHPDUCP1NKfdLZtg81otzHLyxi7ab1ADwxZDiguGHlMpIy1/Lusvc4+/Q0cgsbqa9NZdWK04hxpZMZSGJEQk9y6jLY4mzgyZ7ZDN39EUgTSrmI8btocfro0y83FAu6qKjooG0zdC8dqdHDxaoOF2va6CAMxzIdRZQ76sNclVIfAR2+q1FKPQo8enQsgrWb1lPhrSbLnYY9XvGaHZ/y5NM76NvTTUp6KmWlerCVu8VHpiMWgG1xu/kkeRswmbK4OrKa4hCgxelD4vRhHslY0Iaji12VbidSrOpjPda0wXAwGCW1RZY7jZvu+AH/eu4NAL5/3618bfjd5GXGcNdvNjDxyemQBIsf/FOrckULdK9gzuSJFC14nF1o9bThxCCSKj0YUzocptdgOFEws7lGoKSkhGXrG7nwtBQcDlNNBoPhq4e580Xg2WefRSk4f2Jyd5tiMBgM3YJxEBHYtWsXIwfE0SvX3d2mGAwGQ7dgvkFE4C9/+Qvvj3i9u80wGAyGbsP0IMIQ8DYDEBNjhHEGg+Gri+lBtEEFAqz6+c3cufFzpgzobmsMBoOh+zA9iDbUbViLt3wfw4dHnB/QYDAYvhKYHgSwqk8Tq7IKeWbBbHYv+whHXByD/t8DNFwfoNkFJxdfQYPaSYL0Dlt+Y+VGihYUsbFyI4MzBh9l6w3dRTDud9s0E2vacKJgHASwKquQ3TE9KKjfQtOH7zB4Ql8ScFDlgqpEgXpIkN6c2eP8dmWn9JsS+j04Y3CrZcOJSySFtVFPG04kjIOw6Nmyh1/F5nFBXT2XnhzPsN8tY+XbYwFYfNWLEctNHzSd6YOmHy0zDccIJ3Lcb4MhiPkGYWPUqFF868ahnHRSt8wsbjAYDMcUpgdhIy8vj6lT+nS3GQaDwXBMYHoQFvVbd/DUU0/R7PV3tykGg8FwTGAchEXpgkXMnDmTQODoxscwGAyGYxXjINDiuIqPl3DBBRcQH2feuhkMBgN0X0zqySKyUUQ2i8htYdbHisgca/1iEenTlfbUbdyMt6KSK664oit3YzAYDMcV3RGT2gn8HbgQGAZcIyLD2mT7NlCllBoA/Al4uCttqvhoMeJ0cvHFF3flbgwGg+G4ojt6EBOAzUqprUopL/AccGmbPJcCT1q//wecIyJdNnNe4+49pI0ewSMPvIYj4CchZTuz3x5LCrVdtUuDwWA45umOF+4FwC7b8m7g5Eh5lFItIlIDZAIVbTcmIjcBNwH07h1+KozOOP+X36al2QdLoWTfENLj6yChiVpSSMo4+5C2aTAYDMc7x/0XWaXU48DjAOPHjz+kIUjPXvY9/WMGwHVHyDKDwWA4vumOV0wlQC/bck8rLWweEYkBUoH9R8U6g8FgMADd4yA+BwaKSF8RcQNXA6+2yfMqcIP1+0rgHaWUESgYDAbDUeSov2Kyvin8AHgTcAL/VkqtFZH7gKVKqVeBfwFPi8hmoBLtRAwGg8FwFOmWbxBKqdeB19uk/dr2uwkwU6QaDAZDN2KU1AaDwWAIi3EQBoPBYAiLcRAGg8FgCItxEAaDwWAIi5xIo0dFpBzYcYjFswij1D7BMcd84vNVO14wx3ywFCqlwgZSP6EcxOEgIkuVUuO7246jiTnmE5+v2vGCOeYjiXnFZDAYDIawGAdhMBgMhrAYB3GAx7vbgG7AHPOJz1fteMEc8xHDfIMwGAwGQ1hMD8JgMBgMYTEOwmAwGAxh+co7CBGZLCIbRWSziNzW3fZ0BSLSS0TeFZF1IrJWRH5spWeIyEIR2WT9T+9uW480IuIUkRUiMs9a7isii632nmNNOX/CICJpIvI/EdkgIutFZOKJ3s4i8lPrvF4jIs+KSNyJ1s4i8m8RKRORNba0sO0qmr9ax75KRMYe6n6/0g5CRJzA34ELgWHANSIyrHut6hJagFuUUsOAU4DvW8d5G7BIKTUQWGQtn2j8GFhvW34Y+JNSagBQBXy7W6zqOv4CLFBKDQFOQh/7CdvOIlIA/AgYr5QagQ4hcDUnXjv/B5jcJi1Su14IDLT+bgL+cag7/Uo7CGACsFkptVUp5QWeAy7tZpuOOEqpvUqp5dbvOvRNowB9rE9a2Z4ELusWA7sIEekJXAQ8YS0LcDbwPyvLCXXMIpIKnImOp4JSyquUquYEb2d02IJ4K/pkArCXE6ydlVIfoGPj2InUrpcCTynNZ0CaiOQfyn6/6g6iANhlW95tpZ2wiEgfYAywGMhVSu21VpUCud1lVxfxZ+AXQMBazgSqlVIt1vKJ1t59gXKg2Hqt9oSIJHICt7NSqgT4A7AT7RhqgGWc2O0cJFK7HrH72lfdQXylEJEk4EXgJ0qpWvs6K6TrCTPmWUSmAmVKqWXdbctRJAYYC/xDKTUGqKfN66QTsJ3T0U/MfYEeQCLtX8Wc8HRVu37VHUQJ0Mu23NNKO+EQERfaOTyjlHrJSt4X7Hpa/8u6y74u4DTgEhHZjn51eDb6/Xya9SoCTrz23g3sVkottpb/h3YYJ3I7nwtsU0qVK6V8wEvotj+R2zlIpHY9Yve1r7qD+BwYaI14cKM/br3azTYdcax37/8C1iul/mhb9Spwg/X7BuCVo21bV6GUul0p1VMp1Qfdru8opb4BvAtcaWU70Y65FNglIoOtpHOAdZzA7Yx+tXSKiCRY53nwmE/YdrYRqV1fBa63RjOdAtTYXkUdFF95JbWITEG/q3YC/1ZKPdC9Fh15ROR04ENgNQfex9+B/g7xPNAbPU36VUqpth/CjntEZBLwc6XUVBHph+5RZAArgG8qpZq70bwjioiMRn+UdwNbgSL0g+AJ284ici8wAz1abwXwHfQ79xOmnUXkWWASelrvfcDdwMuEaVfLUT6KftXWABQppZYe0n6/6g7CYDAYDOH5qr9iMhgMBkMEjIMwGAwGQ1iMgzAYDAZDWIyDMBgMBkNYjIMwGAwGQ1iMgzAYDhFr5tT/s373EJH/dVbGYDieMMNcDYZDxJrXap41i6jBcMIR03kWg8EQgYeA/iKyEtgEDFVKjRCRG9Ezayaip1z+A1q4dh3QDEyxBE390dPNZ6MFTd9VSm042gdhMETCvGIyGA6d24AtSqnRwK1t1o0ALge+BjwANFgT6H0KXG/leRz4oVJqHPBz4P8dDaMNhmgxPQiDoWt414q9USciNcBrVvpqYJQ1s+6pwAt6ZgQAYo++mQZDZIyDMBi6Bvu8PwHbcgB93TnQMQtGH2W7DIaoMa+YDIZDpw5IPpSCVjyObSIyHUJxhE86ksYZDIeLcRAGwyGilNoPfGwFkv/9IWziG8C3ReQLYC0nYLhbw/GNGeZqMBgMhrCYHoTBYDAYwmIchMFgMBjCYhyEwWAwGMJiHITBYDAYwmIchMFgMBjCYhyEwWAwGMJiHITBYDAYwvL/AdntDFG6KTIEAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -114,6 +114,7 @@ "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", "plt.plot(times, sol,'--', color='black', label='ode solution')\n", + "plt.legend()\n", "plt.show()" ] } diff --git a/examples/toy/model-stochastic-schlogl.ipynb b/examples/toy/model-stochastic-schlogl.ipynb new file mode 100644 index 0000000000..e33ced0826 --- /dev/null +++ b/examples/toy/model-stochastic-schlogl.ipynb @@ -0,0 +1,149 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Schlogl's model\n", + "\n", + "This example shows how the model representing Schlogl's system of chemical reactions can be used ([Schlogl, 1972](https://link.springer.com/content/pdf/10.1007/BF01379769.pdf)).\n", + "This model describes the stochastic process made of four chemical reactions, two of them being the reverse of another, that take place on a single molecule type.\n", + "Given an initial concentration of the substance, $n_0$, the process can be described by the following equations:\n", + " $$2A \\xrightarrow{k_1} 3A$$\n", + " $$3A \\xrightarrow{k_2} 2A$$\n", + " $$\\emptyset \\xrightarrow{k_3} A$$\n", + " $$A \\xrightarrow{k_4} \\emptyset$$\n", + "\n", + "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pints\n", + "import pints.toy as toy\n", + "import pints.toy.stochastic" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAY8klEQVR4nO3df/RcdX3n8eeL3yKkQINuCKSJVLCRg1HHFavtIlAOUjGtRyvBtGg5m666yLpuXay7h9PT6sEqVnrO2u23GsCKKQWpIBULpSi7FeN+oxFCQFERTDaYL1ogKy0/yrt/3DvsZTLznTs/7p2Z+3k9zpmTzJ079/O5907e+Xw/3zuvq4jAzMzSsc+kO2BmZvVy4TczS4wLv5lZYlz4zcwS48JvZpaY/SbdgTKWLl0aK1eunHQ3zMxmypYtWx6KiCM7l89E4V+5ciXz8/OT7oaZ2UyRdH+35Z7qMTNLjAu/mVliXPjNzBLjwm9mlhgXfjOzxFRW+CVtlLRb0raO5edLukfSXZL+qKr2zcysuypH/JcDZxQXSHotsBZ4SUS8GPhohe2bmVkXlV3HHxG3SVrZsfgdwMUR8Xi+zu6q2jeztHx28wNct3XnM8/XrlnOOa9cMcEeTa+65/iPA35J0mZJX5H0il4rStogaV7S/MLCQo1dNLNZdN3WnWzf9SgA23c9+qz/BOzZ6i78+wFHACcBvwv8lSR1WzEi5iKiFRGtI4/c6xvHZmZ7Wb1sCVf9zqtYvWzJpLsy1eou/DuAayPzdeBpYGnNfTAzS1rdhf/zwGsBJB0HHAA8VHMfzMySVtkvdyVtAk4GlkraAVwEbAQ25pd4PgGcG77pr5lZraq8qmddj5fWV9WmmZn152/umpklxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwS48JvZpYYF34zs8S48JuZJcaF38wsMS78ZmaJceE3M0uMC7+ZWWJc+M3MEuPCb2aWGBd+M7PEVFb4JW2UtDu/21bna++VFJJ8v10zs5pVOeK/HDijc6GkY4DTgQcqbNvMzHqo8taLt0la2eWlPwbeB1xXVdtms+Kzmx/guq07n3m+ds1yznnlign2aPp1HrO27bseZfWyJRPo0eypdY5f0lpgZ0R8q8S6GyTNS5pfWFiooXdm9btu606273oUyApXt4Jmz1Y8ZkWrly1h7ZrlE+jR7KlsxN9J0sHA75FN8/QVEXPAHECr1YoKu2Y2UauXLeGq33kVb/mz2yfdlZnRPmY2nDpH/McCq4BvSfoBcDTwDUn/psY+mJklr7YRf0TcCTyv/Twv/q2IeKiuPpiZWbWXc24CbgeOl7RD0nlVtWVmZuVVeVXPuj6vr6yqbTMz683f3DUzS4wLv5lZYlz4zcwS48JvZpYYF34zs8TUdh2/maWnV64O/P9cojJ5RcV1ymbybN/1aNdvQw+ah1RmH2aNR/xmVpleuTrFXKIyeUXFdcpk8qxds7zrfw7D5CGV2YdZ4xG/mVWqW65O50i8TF7RIPk857xyRdeR+LB5SGX2YZZ4xG9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwSU+UduDZK2i1pW2HZRyTdI+kOSX8t6bCq2jczs+6qHPFfDpzRsexm4ISIOBH4DvD+Cts3M7Muqrz14m2SVnYsu6nw9GvAm6pq32wW9QoW6zSr4WBF7X3tDF3rdgzKBrONokxYXFNMMqvnt4Grer0oaQOwAWDFimYefLOifsFjbe3AsFkuSsV9LYau9ToGZYLZRtUOY1u9bEkjjvFiJlL4JX0AeAq4stc6ETEHzAG0Wq2oqWtmE9MrWKzTLIeDtfXa17LHoCplwuKaoG/hl3QQ8Hrgl4CjgH8CtgF/ExF3DdqgpLfl2zs1IlzQzcxqtmjhl/T7ZEX6y8BmYDdwEHAccHH+n8J7I+KOMo1JOgN4H/DvIuKxEfptZmZD6jfi/3pEXNTjtY9Jeh7Q9ecySZuAk4GlknYAF5FdxXMgcLMkgK9FxH8YpuNmZjacRQt/RPxNn9d3k/0U0O21dV0Wf6p818zMrApl5viPBtYBr6Fjjh+4MSKerrSHZmY2Vv3m+C8DlgM3AB/m2XP8ZwAfkHRhRNxWdUfNzGw8+o34L4mIbV2WbwOulXQAPeb4zcxsOi0a2dAu+pIu6HxN0gUR8UREfLeqzpmZ2fiVzeo5t8uyt42xH2ZmVpN+c/zrgHOAVZKuL7x0KPCTKjtm1lTFTJhhM2jKZvq0tXNnqsij6dzmuLY7ab2yhLqtA8Pv8yQygvrN8X8V2AUsBS4pLN8DlPrSlpk9WzETZpgMmkHXL+bOVJFHU9xmZ3uzqleWUK91RtnnSWQE9Sv8D0TE/cCreq0gSY5eMBtMOxNmGIPm2XT+ZFBFHk1xf5qQc1PmGBfXGXWf684I6jfHf6uk8yU96whIOkDSKZKuoPv8v5mZTal+I/4zyOKTN0laBTwMPIfsP4ybgI9HxDcr7aGZmY1Vv8iGfwY+AXxC0v5kc/3/FBEP19A3MzOrQOlbL0bEkxGxC3hS0npJi+b4mJnZdCpV+PM5/V+XdDXZVT6nAv+z0p6ZmVkl+l3HfzpZQNvpwK3Ap4FXRMTba+ibmZlVoN+I/0vAC4DXRMT6iPgC4DROM7MZ1q/wvwy4Hfg7STdLOg/Yt8yGJW2UtFvStsKyI/Lt3Jv/efjwXTczs2H0C2nbGhEXRsSxZHfQWgPsL+lGSRv6bPtysstBiy4EbomIFwK35M/NzKxGfW/E0hYRXwW+mid1ngacDcwtsv5tklZ2LF5LdjtGgCvI7uX7X8t316owiawQq1ev3JlBM3+KFvuclMm5mZRe+zyNfa1Kv1/uroyIHxSX5Xfcugm4SdmNc5dHxI6S7T0/vyQU4EHg+Yu0vQHYALBihYtQlSaRFWL16ZU7M2jmT9Fin5MyOTeTslhfpq2vVeo34v+IpH2A64AtwALZHbh+nmzkfhrZFFDZwv+MiAhJPTN+ImKO/CeKVqvlLKCK1Z0VYvXplTszaOZP0WKfk1G2W7Vp7lud+n1z982SVgNvJYtuWAY8BtwNfBH4UP7t3rJ+JGlZROyStIweN2o3M7Pq9J3jj4jtwAfG1N71ZKFuF+d/Xjem7ZqZWUmlIxsGJWkT2aWgx0vakV8KejHwK5LuJZsmuriq9s3MrLvSV/UMKiLW9Xjp1KraNDOz/iob8ZuZ2XQqPeKXtBz4ueJ7IuK2KjplZmbVKVX4JX0YeAuwHfiXfHEALvxmZjOm7Ij/14DjI+LxCvtiZmY1KDvH/31g/yo7YmZm9Sg74n8M2CrpFuCZUX9EvLuSXpmZWWXKFv7r84eNUd3haA5jm5zisW9KGNg0B7HNss4QudVHLeGis1481jZKFf6IuELSAcBx+aJvR8STY+1JguoOR3MY2+QUj30TwsCmOYhtltV1HMte1XMyWYzyDwABx0g615dzjq7ucDSHsU1O+9g3gcPOqlHXcS071XMJcHpEfBtA0nHAJuDlVXXMzMyqUfaqnv3bRR8gIr6Dr/IxM5tJZUf885I+CXwmf/5WYL6aLpmZWZXKFv53AO8C2pdv/i/gE5X0yMzMKlX2qp7HgY/lDzMzm2H97rn7VxHxG5LuJMvmeZaIOLGynpmZWSX6jfgvyP98fdUdMTOzeix6VU9E7Mr/+s6IuL/4AN45bKOS3iPpLknbJG2SdNCw2zIzs8GUvZzzV7ose90wDea5/u8GWhFxArAvcPYw2zIzs8H1m+N/B9nI/gWS7ii8dCjwDyO2+xxJTwIHA/93hG1NvbIZOZ0ZHYPqtt3FMmJ6Za0U+zGpPJ8m5Ao1MZ/H+uv12e1c3jaJz0a/Ef9ngbPIAtrOKjxeHhHrh2kwInYCHwUeAHYBj0TETZ3rSdogaV7S/MLCwjBNTY12TgtkJ7nbyV+7ZvlIJ7/XdottFzNViu31Wt5rm3Uoc8ymXa9jb83W67NbXF40ic/GoiP+iHgEeARYByDpecBBwCGSDomIBwZtUNLhwFpgFfAwcLWk9RHxmeJ6ETEHzAG0Wq29riiaNf0yckbN6FjsJ4VuGTG92isun3SeTxNyhZqUz2Pl9frsTsvnodQcv6SzJN0L3Ad8hSys7cYh2zwNuC8iFvKEz2uBXxxyW2ZmNqCyv9z9Q+Ak4DsRsQo4FfjakG0+AJwk6WBJyrd195DbMjOzAZUt/E9GxI+BfSTtExG3Aq1hGoyIzcA1wDeAO/M+zA2zLTMzG1zZrJ6HJR0C3AZcKWk38NNhG42Ii4CLhn2/mZkNr+yIfy3ZfXffA3wJ+B7Z1T1mZjZj+o74Je0L3BARrwWeJrsTl5mZzai+I/6I+BfgaUk/U0N/zMysYmXn+P8fcKekmynM7UfEu3u/xczMplHZwn9t/iia+S9VmZmlqGzhPywiLi0ukHRBr5Vtcb0ycsa13c5lTciI6ZVjNEiGTxPyf2x69cu+mqZ/i2UL/7nApR3L3tZlmfVRzOQYZ0ZHr+00ISOmV//buSdli3c7K2X1siUDv9dsMb3+XVf1731U/dI51wHnAKskXV946VDgJ1V2rKlGzeSpe7vToNe+DZPh04T8H5s+ZbKvpkm/Ef9XyRI0lwKXFJbvAe7o+g4zM5tq/dI57wfuByYfJ2dmZmNRNp3zjZLulfSIpEcl7ZG0d7C0mZlNvbK/3P0j4KyIcIqmmdmMK5vV8yMXfTOzZig74p+XdBXweeDx9sKI6PxSl5mZTbmyhX8JWTrn6YVlwd7f5jUzsylXqvBHxNur7oiZmdWj7FU9x0m6RdK2/PmJkv7bsI1KOkzSNZLukXS3JF8uamZWk7K/3P1z4P3AkwARcQdw9gjtXgp8KSJeBLwE33PXzKw2Zef4D46Ir2f3Rn/GU8M0mOf6/zJZ1g8R8QTwxDDbGoeqgruK252mcKZpNswxK4a3dTt3i22zM/it3/s7OeTNZlXZEf9Dko4lj2KW9CayKIdhrAIWgMskfVPSJyU9t3MlSRskzUuaX1hYGLKp/trBXZAVgl7/yEfZ7jSFM02zQY/Z2jXLnynkvc5dr20W31v2/UXj/KyY1a3siP9dwBzwIkk7gfuA9SO0+TLg/IjYLOlS4ELgvxdXioi5vE1arVal2f9VBXe1t2vlDXLMigFYi527btvsDM8a9P0OebNZVvaqnu8Dp+Uj830iYs8Ibe4AdkTE5vz5NWSF38zMalD2qp4PSTosIn4aEXskHS7pD4dpMCIeBH4o6fh80anA9mG2ZWZmgys7x/+6iHi4/SQi/hE4c4R2zweulHQHsAb40AjbMjOzAZSd499X0oER8TiApOcABw7baERsBVrDvt/MzIZXtvBfCdwi6bL8+duBK6rpkpmZVansL3c/nE/LnJov+oOI+NvqumVmZlUpO+InIm4EbqywL2ZmVgPfgcvMLDG+A5eZWWLKFn7fgauEJubz9MvCKWuxzJtiW6Mcs87snWG3WfY8djs2TfwMWPP4Dlxj1M51Wb1sSSPyeYr9b+fVDFv4i8eml1GOWa/3DbPNMuex17Fp2mfAmsl34BqzJuXzlM3CKavKY9OZvTOqfn1d7Ng06TNgzeQ7cJmZJabsVT1HS/prSbvzx+ckHV1158zMbPzKZvVcBlwPHJU/vpAvMzOzGVO28B8ZEZdFxFP543LgyAr7ZWZmFSlb+H8sab2kffPHeuDHVXbMzMyqUbbw/zbwG8CDZLdcfBNZUJuZmc2Yslf13A+8oeK+mJlZDcpe1XOFpMMKzw+XtHGUhvMpo29KumGU7ZiZ2WDKTvWc2OUOXC8dse0LAMdAmJnVrOw3d/eRdHhe8JF0xADv3Uv+HYBfBT4I/OdhtzOIXlkxnTEC3fJeuhkltyYFncd7FnJr2ud+mL6O8l6zupUt3pcAt0u6On/+ZrKiPayPA+8DDu21gqQNwAaAFStGL7C9smKKeSplc1VGza1JQefxnvbcmmLfBu3rKO81m4Syv9z9tKR54JR80RsjYvswDUp6PbA7IrZIOnmRNueAOYBWqxXDtNVpkPyVxYwjtyYFs5RZM0rWz7hzgsyqNsgduLYDQxX7Dq8G3iDpTOAgYImkz0TE+jFs28zM+ij7y92xiYj3R8TREbESOBv4exd9M7P61F74zcxssoa+MmccIuLLwJcn2Qczs9R4xG9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS8xEL+esWjEorKrwrDramGZlw+/MbHo0esTfDgqD6sKz6mhjmhX3vyjFY2E2Kxo94od6gsJmKYysCqnvv9msafSI38zM9ubCb2aWGBd+M7PEuPCbmSXGhd/MLDEu/GZmiXHhNzNLTO2FX9Ixkm6VtF3SXZIuqLsPZmYpm8QXuJ4C3hsR35B0KLBF0s35zdzNzKxitRf+iNgF7Mr/vkfS3cByYKYK//Zdj/KWP7s9qUya9j53Lktl/82aYqKRDZJWAi8FNnd5bQOwAWDFihX1dqyPYgZNKpk0vfYxlf03axJFxGQalg4BvgJ8MCKuXWzdVqsV8/PzA7fRHp06R8bMUiRpS0S0OpdP5KoeSfsDnwOu7Ff0zcxsvCZxVY+ATwF3R8TH6m7fzCx1kxjxvxr4TeAUSVvzx5kT6IeZWZImcVXP/wZUd7tmZpbxN3fNzBLjwm9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwS48JvZpYYF34zs8S48JuZJcaF38wsMS78ZmaJceE3M0uMC7+ZWWImdc/dMyR9W9J3JV04iT6YmaVqEvfc3Rf4H8DrgNXAOkmr6+6HmVmqJjHi/7fAdyPi+xHxBPCXwNoJ9MPMLEm133MXWA78sPB8B/DKzpUkbQA2AKxYsWKohlYftWSo95mZNdkkCn8pETEHzAG0Wq0YZhsXnfXisfbJzKwJJjHVsxM4pvD86HyZmZnVYBKF//8AL5S0StIBwNnA9RPoh5lZkmqf6omIpyT9R+BvgX2BjRFxV939MDNL1UTm+CPii8AXJ9G2mVnq/M1dM7PEuPCbmSXGhd/MLDEu/GZmiVHEUN+NqpWkBeD+Id++FHhojN2ZBd7nNHif0zDKPv9cRBzZuXAmCv8oJM1HRGvS/aiT9zkN3uc0VLHPnuoxM0uMC7+ZWWJSKPxzk+7ABHif0+B9TsPY97nxc/xmZvZsKYz4zcyswIXfzCwxjS78Tb+pu6RjJN0qabukuyRdkC8/QtLNku7N/zx80n0dN0n7SvqmpBvy56skbc7P9VV55HdjSDpM0jWS7pF0t6RXNf08S3pP/rneJmmTpIOadp4lbZS0W9K2wrKu51WZP8n3/Q5JLxu23cYW/kRu6v4U8N6IWA2cBLwr38cLgVsi4oXALfnzprkAuLvw/MPAH0fEzwP/CJw3kV5V51LgSxHxIuAlZPve2PMsaTnwbqAVESeQRbifTfPO8+XAGR3Lep3X1wEvzB8bgD8dttHGFn4SuKl7ROyKiG/kf99DVgyWk+3nFflqVwC/NpEOVkTS0cCvAp/Mnws4BbgmX6VR+yzpZ4BfBj4FEBFPRMTDNPw8k8XGP0fSfsDBwC4adp4j4jbgJx2Le53XtcCnI/M14DBJy4Zpt8mFv9tN3ZdPqC+Vk7QSeCmwGXh+ROzKX3oQeP6k+lWRjwPvA57On/8s8HBEPJU/b9q5XgUsAJfl01uflPRcGnyeI2In8FHgAbKC/wiwhWaf57Ze53VsNa3JhT8Zkg4BPgf8p4h4tPhaZNfrNuaaXUmvB3ZHxJZJ96VG+wEvA/40Il4K/JSOaZ0GnufDyUa4q4CjgOey95RI41V1Xptc+JO4qbuk/cmK/pURcW2++EftHwHzP3dPqn8VeDXwBkk/IJu+O4Vs/vuwfEoAmneudwA7ImJz/vwasv8ImnyeTwPui4iFiHgSuJbs3Df5PLf1Oq9jq2lNLvyNv6l7Prf9KeDuiPhY4aXrgXPzv58LXFd336oSEe+PiKMjYiXZOf37iHgrcCvwpny1pu3zg8APJR2fLzoV2E6DzzPZFM9Jkg7OP+ftfW7seS7odV6vB34rv7rnJOCRwpTQYCKisQ/gTOA7wPeAD0y6PxXs32vIfgy8A9iaP84km/O+BbgX+DvgiEn3taL9Pxm4If/7C4CvA98FrgYOnHT/xryva4D5/Fx/Hji86ecZ+H3gHmAb8BfAgU07z8Amst9hPEn2k915vc4rILIrFb8H3El2xdNQ7TqywcwsMU2e6jEzsy5c+M3MEuPCb2aWGBd+M7PEuPCbmSXGhd+sQ56E+c7870dJuqbfe8xmiS/nNOuQ5x7dEFkqpFnj7Nd/FbPkXAwcK2kr2ZdofiEiTpD0NrKkxOeSReN+FDgA+E3gceDMiPiJpGPJvmhzJPAY8O8j4p66d8KsF0/1mO3tQuB7EbEG+N2O104A3gi8Avgg8FhkwWm3A7+VrzMHnB8RLwf+C/CJOjptVpZH/GaDuTWyex/skfQI8IV8+Z3AiXlS6i8CV2cRM0AWNWA2NVz4zQbzeOHvTxeeP03272kfssz4NTX3y6w0T/WY7W0PcOgwb4zsfgj3SXozPHOf1JeMs3Nmo3LhN+sQET8G/iG/AfZHhtjEW4HzJH0LuIuG3fLTZp8v5zQzS4xH/GZmiXHhNzNLjAu/mVliXPjNzBLjwm9mlhgXfjOzxLjwm5kl5l8BeqV64YNsGHsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_0 = 0\n", + "model = toy.stochastic.ProductionDegradationModel(n_0)\n", + "\n", + "times = np.linspace(0, 100, 100)\n", + "k = [0.1, 1]\n", + "\n", + "values = model.simulate(k, times)\n", + "\n", + "plt.step(times, values)\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute the stochastic mean $M(t)$ which gives the average number of molecules of $A$ at time $t$. This function can be described by the following ODE (Erban et al., 2007): $ \\frac{\\text{d}M}{\\text{d}t} = -k_1 M + k_2 $.\n", + "\n", + "We will plot the ODE solution, and compare it to 10 stochastic simulations to show that the stochastic simulation average to the desired function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def pend(y, t):\n", + " dydt = [-k[0] * y[0] + k[1]]\n", + " return dydt\n", + "\n", + "x_0 = [0]\n", + "times = np.linspace(0, 100, 100)\n", + "\n", + "from scipy.integrate import odeint\n", + "sol = odeint(pend, x_0, times)\n", + "\n", + "for i in range(10):\n", + " values = model.simulate(k, times)\n", + " plt.step(times, values)\n", + " \n", + "plt.title('stochastic degradation across different iterations')\n", + "plt.xlabel('time')\n", + "plt.ylabel('concentration (A(t))')\n", + "plt.plot(times, sol,'--', color='black', label='ode solution')\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" + }, + "kernelspec": { + "display_name": "Python 3.8.0 32-bit", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pints/tests/test_toy_stochastic_production_degradation_model.py b/pints/tests/test_toy_stochastic_production_degradation_model.py index 261458dbd8..9e7fae2858 100644 --- a/pints/tests/test_toy_stochastic_production_degradation_model.py +++ b/pints/tests/test_toy_stochastic_production_degradation_model.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 # -# Tests if the degradation (toy) model works. +# Tests if the production and degradation (toy) model works. # # This file is part of PINTS (https://github.com/pints-team/pints/) which is # released under the BSD 3-clause license. See accompanying LICENSE.md for diff --git a/pints/tests/test_toy_stochastic_schlogl_model.py b/pints/tests/test_toy_stochastic_schlogl_model.py new file mode 100644 index 0000000000..76c86410b1 --- /dev/null +++ b/pints/tests/test_toy_stochastic_schlogl_model.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +# +# Tests if the Schlogl (toy) model works. +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +import unittest +import numpy as np +from pints.toy.stochastic import SchloglModel + + +class TestSchloglModel(unittest.TestCase): + """ + Tests if the degradation (toy) model works. + """ + def test_n_parameters(self): + x_0 = 20 + model = SchloglModel(x_0) + self.assertEqual(model.n_parameters(), 4) + + def test_simulation_length(self): + x_0 = 20 + model = SchloglModel(x_0) + times = np.linspace(0, 1, 100) + k = [0.1, 0.2, 0.3, 0.4] + values = model.simulate(k, times) + self.assertEqual(len(values), 100) + + def test_propensities(self): + x_0 = 20 + model = SchloglModel(x_0) + k = model.suggested_parameters() + self.assertTrue( + np.allclose( + model._propensities([x_0], k), + np.array([7.2, 0.015, 2200.0, 750.0]))) + + def test_suggested(self): + model = SchloglModel(20) + times = model.suggested_times() + parameters = model.suggested_parameters() + self.assertTrue(len(times) == 101) + self.assertTrue(np.all(parameters > 0)) + + +if __name__ == '__main__': + unittest.main() diff --git a/pints/toy/stochastic/__init__.py b/pints/toy/stochastic/__init__.py index 568bb8a96d..48ffa809b2 100644 --- a/pints/toy/stochastic/__init__.py +++ b/pints/toy/stochastic/__init__.py @@ -11,3 +11,4 @@ from ._degradation_model import DegradationModel # noqa from ._logistic_model import LogisticModel # noqa from ._production_degradation_model import ProductionDegradationModel # noqa +from ._schlogl_model import SchloglModel # noqa \ No newline at end of file diff --git a/pints/toy/stochastic/_schlogl_model.py b/pints/toy/stochastic/_schlogl_model.py new file mode 100644 index 0000000000..19ec41e123 --- /dev/null +++ b/pints/toy/stochastic/_schlogl_model.py @@ -0,0 +1,54 @@ +# +# Schlogl's stochastic toy model. +# +# This file is part of PINTS (https://github.com/pints-team/pints/) which is +# released under the BSD 3-clause license. See accompanying LICENSE.md for +# copyright notice and full license details. +# +from . import MarkovJumpModel + +import numpy as np + + +class SchloglModel(MarkovJumpModel): + r""" + Schlogl's system of chemical reactions has a single type of molecules and + starts with an initial count :math:`A(0)`. The evolution of the molecule + count is defined through the rates :math:`k_1`, :math:`k_2`, :math:`k_3` + and :math:`k_4` and the following equations: + + ..math:: + 2A \xrightarrow{k_1} 3A + 3A \xrightarrow{k_2} 2A + 0 \xrightarrow{k_3} A + A \xrightarrow{k_4} 0 + + Extends :class:`pints.ForwardModel`, :class:`pints.toy.ToyModel`. + + Parameters + ---------- + initial_molecule_count + The initial molecule count :math:`A(0)`. + """ + def __init__(self, initial_molecule_count=20): + V = [[1], [-1], [1], [-1]] + init_list = [initial_molecule_count] + super(SchloglModel, self).__init__(init_list, + V, self._propensities) + + @staticmethod + def _propensities(xs, ks): + return [ + 2 * xs[0] * ks[0], + 3 * xs[0] * ks[1], + ks[2], + xs[0] * ks[3] + ] + + def suggested_parameters(self): + """ See :meth:`pints.toy.ToyModel.suggested_parameters()`. """ + return np.array([0.18, 0.00025, 2200, 37.5]) + + def suggested_times(self): + """ See "meth:`pints.toy.ToyModel.suggested_times()`.""" + return np.linspace(0, 100, 101) From 865e2017889e3048d1ad198bd2d3f2c600faf0cb Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 20:32:57 +0000 Subject: [PATCH 26/41] fix propensities schlogl --- examples/toy/model-stochastic-schlogl.ipynb | 73 ++++++++++++++++++--- pints/toy/stochastic/_schlogl_model.py | 4 +- 2 files changed, 65 insertions(+), 12 deletions(-) diff --git a/examples/toy/model-stochastic-schlogl.ipynb b/examples/toy/model-stochastic-schlogl.ipynb index e33ced0826..dca2d2545c 100644 --- a/examples/toy/model-stochastic-schlogl.ipynb +++ b/examples/toy/model-stochastic-schlogl.ipynb @@ -19,7 +19,60 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "D:\\Part B\\python\\python.exe\n", + "started\n", + "Collecting git+https://github.com/pints-team/pints.git@additional-stochastic-models\n", + " Cloning https://github.com/pints-team/pints.git (to revision additional-stochastic-models) to c:\\users\\victor\\appdata\\local\\temp\\pip-req-build-s9fa4com\n", + "Requirement already satisfied, skipping upgrade: cma>=2 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.1.0)\n", + "Requirement already satisfied, skipping upgrade: numpy>=1.8 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (1.21.2)\n", + "Requirement already satisfied, skipping upgrade: scipy>=0.14 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (1.7.2)\n", + "Requirement already satisfied, skipping upgrade: matplotlib>=1.5 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.4.3)\n", + "Requirement already satisfied, skipping upgrade: tabulate in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (0.8.9)\n", + "Requirement already satisfied, skipping upgrade: threadpoolctl in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.0.0)\n", + "Requirement already satisfied, skipping upgrade: kiwisolver>=1.0.1 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (1.3.2)\n", + "Requirement already satisfied, skipping upgrade: python-dateutil>=2.7 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (2.8.1)\n", + "Requirement already satisfied, skipping upgrade: pillow>=6.2.0 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (8.4.0)\n", + "Requirement already satisfied, skipping upgrade: pyparsing>=2.2.1 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (2.4.7)\n", + "Requirement already satisfied, skipping upgrade: cycler>=0.10 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (0.11.0)\n", + "Requirement already satisfied, skipping upgrade: six>=1.5 in d:\\part b\\python\\lib\\site-packages (from python-dateutil>=2.7->matplotlib>=1.5->pints==0.4.1) (1.14.0)\n", + "Installing collected packages: pints\n", + " Running setup.py install for pints: started\n", + " Running setup.py install for pints: finished with status 'done'\n", + "Successfully installed pints-0.4.1\n", + "done\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " Running command git clone -q https://github.com/pints-team/pints.git 'C:\\Users\\Victor\\AppData\\Local\\Temp\\pip-req-build-s9fa4com'\n", + " Running command git checkout -b additional-stochastic-models --track origin/additional-stochastic-models\n", + " Branch 'additional-stochastic-models' set up to track remote branch 'additional-stochastic-models' from 'origin'.\n", + " Switched to a new branch 'additional-stochastic-models'\n", + "WARNING: You are using pip version 19.2.3, however version 22.0.2 is available.\n", + "You should consider upgrading via the 'python -m pip install --upgrade pip' command.\n" + ] + } + ], + "source": [ + "import sys\n", + "print(sys.executable)\n", + "print(\"started\")\n", + "!{'D:\\\\\"Part B\"\\\\python\\python.exe'} -m pip install --upgrade git+https://github.com/pints-team/pints.git@additional-stochastic-models\n", + "print(\"done\")" + ] + }, + { + "cell_type": "code", + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -39,12 +92,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -57,10 +110,10 @@ ], "source": [ "n_0 = 0\n", - "model = toy.stochastic.ProductionDegradationModel(n_0)\n", + "model = toy.stochastic.SchloglModel(n_0)\n", "\n", - "times = np.linspace(0, 100, 100)\n", - "k = [0.1, 1]\n", + "times = np.linspace(0, 100, 1000)\n", + "k = model.suggested_parameters()\n", "\n", "values = model.simulate(k, times)\n", "\n", @@ -81,12 +134,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -99,7 +152,7 @@ ], "source": [ "def pend(y, t):\n", - " dydt = [-k[0] * y[0] + k[1]]\n", + " dydt = [-k[1] * (y[0] ** 3) + k[0] * (y[0] ** 2) - k[3] * y[0] + k[2]]\n", " return dydt\n", "\n", "x_0 = [0]\n", @@ -108,7 +161,7 @@ "from scipy.integrate import odeint\n", "sol = odeint(pend, x_0, times)\n", "\n", - "for i in range(10):\n", + "for i in range(3):\n", " values = model.simulate(k, times)\n", " plt.step(times, values)\n", " \n", diff --git a/pints/toy/stochastic/_schlogl_model.py b/pints/toy/stochastic/_schlogl_model.py index 19ec41e123..2534905e1a 100644 --- a/pints/toy/stochastic/_schlogl_model.py +++ b/pints/toy/stochastic/_schlogl_model.py @@ -39,8 +39,8 @@ def __init__(self, initial_molecule_count=20): @staticmethod def _propensities(xs, ks): return [ - 2 * xs[0] * ks[0], - 3 * xs[0] * ks[1], + xs[0] * (xs[0] - 1) * ks[0], + xs[0] * (xs[0] - 1) * (xs[0] - 2) * ks[1], ks[2], xs[0] * ks[3] ] From 71bf8711703d8b7e31eeb4a1a86609c29d1fa802 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 20:45:48 +0000 Subject: [PATCH 27/41] finished schlongl ipynb + small fix for ipynb of production --- ...el-stochastic-production-degradation.ipynb | 12 +-- examples/toy/model-stochastic-schlogl.ipynb | 75 +++---------------- 2 files changed, 16 insertions(+), 71 deletions(-) diff --git a/examples/toy/model-stochastic-production-degradation.ipynb b/examples/toy/model-stochastic-production-degradation.ipynb index ccf527aa10..12b37b1f59 100644 --- a/examples/toy/model-stochastic-production-degradation.ipynb +++ b/examples/toy/model-stochastic-production-degradation.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -37,12 +37,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAY8klEQVR4nO3df/RcdX3n8eeL3yKkQINuCKSJVLCRg1HHFavtIlAOUjGtRyvBtGg5m666yLpuXay7h9PT6sEqVnrO2u23GsCKKQWpIBULpSi7FeN+oxFCQFERTDaYL1ogKy0/yrt/3DvsZTLznTs/7p2Z+3k9zpmTzJ079/O5907e+Xw/3zuvq4jAzMzSsc+kO2BmZvVy4TczS4wLv5lZYlz4zcwS48JvZpaY/SbdgTKWLl0aK1eunHQ3zMxmypYtWx6KiCM7l89E4V+5ciXz8/OT7oaZ2UyRdH+35Z7qMTNLjAu/mVliXPjNzBLjwm9mlhgXfjOzxFRW+CVtlLRb0raO5edLukfSXZL+qKr2zcysuypH/JcDZxQXSHotsBZ4SUS8GPhohe2bmVkXlV3HHxG3SVrZsfgdwMUR8Xi+zu6q2jeztHx28wNct3XnM8/XrlnOOa9cMcEeTa+65/iPA35J0mZJX5H0il4rStogaV7S/MLCQo1dNLNZdN3WnWzf9SgA23c9+qz/BOzZ6i78+wFHACcBvwv8lSR1WzEi5iKiFRGtI4/c6xvHZmZ7Wb1sCVf9zqtYvWzJpLsy1eou/DuAayPzdeBpYGnNfTAzS1rdhf/zwGsBJB0HHAA8VHMfzMySVtkvdyVtAk4GlkraAVwEbAQ25pd4PgGcG77pr5lZraq8qmddj5fWV9WmmZn152/umpklxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwS48JvZpYYF34zs8S48JuZJcaF38wsMS78ZmaJceE3M0uMC7+ZWWJc+M3MEuPCb2aWGBd+M7PEVFb4JW2UtDu/21bna++VFJJ8v10zs5pVOeK/HDijc6GkY4DTgQcqbNvMzHqo8taLt0la2eWlPwbeB1xXVdtms+Kzmx/guq07n3m+ds1yznnlign2aPp1HrO27bseZfWyJRPo0eypdY5f0lpgZ0R8q8S6GyTNS5pfWFiooXdm9btu606273oUyApXt4Jmz1Y8ZkWrly1h7ZrlE+jR7KlsxN9J0sHA75FN8/QVEXPAHECr1YoKu2Y2UauXLeGq33kVb/mz2yfdlZnRPmY2nDpH/McCq4BvSfoBcDTwDUn/psY+mJklr7YRf0TcCTyv/Twv/q2IeKiuPpiZWbWXc24CbgeOl7RD0nlVtWVmZuVVeVXPuj6vr6yqbTMz683f3DUzS4wLv5lZYlz4zcwS48JvZpYYF34zs8TUdh2/maWnV64O/P9cojJ5RcV1ymbybN/1aNdvQw+ah1RmH2aNR/xmVpleuTrFXKIyeUXFdcpk8qxds7zrfw7D5CGV2YdZ4xG/mVWqW65O50i8TF7RIPk857xyRdeR+LB5SGX2YZZ4xG9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwSU+UduDZK2i1pW2HZRyTdI+kOSX8t6bCq2jczs+6qHPFfDpzRsexm4ISIOBH4DvD+Cts3M7Muqrz14m2SVnYsu6nw9GvAm6pq32wW9QoW6zSr4WBF7X3tDF3rdgzKBrONokxYXFNMMqvnt4Grer0oaQOwAWDFimYefLOifsFjbe3AsFkuSsV9LYau9ToGZYLZRtUOY1u9bEkjjvFiJlL4JX0AeAq4stc6ETEHzAG0Wq2oqWtmE9MrWKzTLIeDtfXa17LHoCplwuKaoG/hl3QQ8Hrgl4CjgH8CtgF/ExF3DdqgpLfl2zs1IlzQzcxqtmjhl/T7ZEX6y8BmYDdwEHAccHH+n8J7I+KOMo1JOgN4H/DvIuKxEfptZmZD6jfi/3pEXNTjtY9Jeh7Q9ecySZuAk4GlknYAF5FdxXMgcLMkgK9FxH8YpuNmZjacRQt/RPxNn9d3k/0U0O21dV0Wf6p818zMrApl5viPBtYBr6Fjjh+4MSKerrSHZmY2Vv3m+C8DlgM3AB/m2XP8ZwAfkHRhRNxWdUfNzGw8+o34L4mIbV2WbwOulXQAPeb4zcxsOi0a2dAu+pIu6HxN0gUR8UREfLeqzpmZ2fiVzeo5t8uyt42xH2ZmVpN+c/zrgHOAVZKuL7x0KPCTKjtm1lTFTJhhM2jKZvq0tXNnqsij6dzmuLY7ab2yhLqtA8Pv8yQygvrN8X8V2AUsBS4pLN8DlPrSlpk9WzETZpgMmkHXL+bOVJFHU9xmZ3uzqleWUK91RtnnSWQE9Sv8D0TE/cCreq0gSY5eMBtMOxNmGIPm2XT+ZFBFHk1xf5qQc1PmGBfXGXWf684I6jfHf6uk8yU96whIOkDSKZKuoPv8v5mZTal+I/4zyOKTN0laBTwMPIfsP4ybgI9HxDcr7aGZmY1Vv8iGfwY+AXxC0v5kc/3/FBEP19A3MzOrQOlbL0bEkxGxC3hS0npJi+b4mJnZdCpV+PM5/V+XdDXZVT6nAv+z0p6ZmVkl+l3HfzpZQNvpwK3Ap4FXRMTba+ibmZlVoN+I/0vAC4DXRMT6iPgC4DROM7MZ1q/wvwy4Hfg7STdLOg/Yt8yGJW2UtFvStsKyI/Lt3Jv/efjwXTczs2H0C2nbGhEXRsSxZHfQWgPsL+lGSRv6bPtysstBiy4EbomIFwK35M/NzKxGfW/E0hYRXwW+mid1ngacDcwtsv5tklZ2LF5LdjtGgCvI7uX7X8t316owiawQq1ev3JlBM3+KFvuclMm5mZRe+zyNfa1Kv1/uroyIHxSX5Xfcugm4SdmNc5dHxI6S7T0/vyQU4EHg+Yu0vQHYALBihYtQlSaRFWL16ZU7M2jmT9Fin5MyOTeTslhfpq2vVeo34v+IpH2A64AtwALZHbh+nmzkfhrZFFDZwv+MiAhJPTN+ImKO/CeKVqvlLKCK1Z0VYvXplTszaOZP0WKfk1G2W7Vp7lud+n1z982SVgNvJYtuWAY8BtwNfBH4UP7t3rJ+JGlZROyStIweN2o3M7Pq9J3jj4jtwAfG1N71ZKFuF+d/Xjem7ZqZWUmlIxsGJWkT2aWgx0vakV8KejHwK5LuJZsmuriq9s3MrLvSV/UMKiLW9Xjp1KraNDOz/iob8ZuZ2XQqPeKXtBz4ueJ7IuK2KjplZmbVKVX4JX0YeAuwHfiXfHEALvxmZjOm7Ij/14DjI+LxCvtiZmY1KDvH/31g/yo7YmZm9Sg74n8M2CrpFuCZUX9EvLuSXpmZWWXKFv7r84eNUd3haA5jm5zisW9KGNg0B7HNss4QudVHLeGis1481jZKFf6IuELSAcBx+aJvR8STY+1JguoOR3MY2+QUj30TwsCmOYhtltV1HMte1XMyWYzyDwABx0g615dzjq7ucDSHsU1O+9g3gcPOqlHXcS071XMJcHpEfBtA0nHAJuDlVXXMzMyqUfaqnv3bRR8gIr6Dr/IxM5tJZUf885I+CXwmf/5WYL6aLpmZWZXKFv53AO8C2pdv/i/gE5X0yMzMKlX2qp7HgY/lDzMzm2H97rn7VxHxG5LuJMvmeZaIOLGynpmZWSX6jfgvyP98fdUdMTOzeix6VU9E7Mr/+s6IuL/4AN45bKOS3iPpLknbJG2SdNCw2zIzs8GUvZzzV7ose90wDea5/u8GWhFxArAvcPYw2zIzs8H1m+N/B9nI/gWS7ii8dCjwDyO2+xxJTwIHA/93hG1NvbIZOZ0ZHYPqtt3FMmJ6Za0U+zGpPJ8m5Ao1MZ/H+uv12e1c3jaJz0a/Ef9ngbPIAtrOKjxeHhHrh2kwInYCHwUeAHYBj0TETZ3rSdogaV7S/MLCwjBNTY12TgtkJ7nbyV+7ZvlIJ7/XdottFzNViu31Wt5rm3Uoc8ymXa9jb83W67NbXF40ic/GoiP+iHgEeARYByDpecBBwCGSDomIBwZtUNLhwFpgFfAwcLWk9RHxmeJ6ETEHzAG0Wq29riiaNf0yckbN6FjsJ4VuGTG92isun3SeTxNyhZqUz2Pl9frsTsvnodQcv6SzJN0L3Ad8hSys7cYh2zwNuC8iFvKEz2uBXxxyW2ZmNqCyv9z9Q+Ak4DsRsQo4FfjakG0+AJwk6WBJyrd195DbMjOzAZUt/E9GxI+BfSTtExG3Aq1hGoyIzcA1wDeAO/M+zA2zLTMzG1zZrJ6HJR0C3AZcKWk38NNhG42Ii4CLhn2/mZkNr+yIfy3ZfXffA3wJ+B7Z1T1mZjZj+o74Je0L3BARrwWeJrsTl5mZzai+I/6I+BfgaUk/U0N/zMysYmXn+P8fcKekmynM7UfEu3u/xczMplHZwn9t/iia+S9VmZmlqGzhPywiLi0ukHRBr5Vtcb0ycsa13c5lTciI6ZVjNEiGTxPyf2x69cu+mqZ/i2UL/7nApR3L3tZlmfVRzOQYZ0ZHr+00ISOmV//buSdli3c7K2X1siUDv9dsMb3+XVf1731U/dI51wHnAKskXV946VDgJ1V2rKlGzeSpe7vToNe+DZPh04T8H5s+ZbKvpkm/Ef9XyRI0lwKXFJbvAe7o+g4zM5tq/dI57wfuByYfJ2dmZmNRNp3zjZLulfSIpEcl7ZG0d7C0mZlNvbK/3P0j4KyIcIqmmdmMK5vV8yMXfTOzZig74p+XdBXweeDx9sKI6PxSl5mZTbmyhX8JWTrn6YVlwd7f5jUzsylXqvBHxNur7oiZmdWj7FU9x0m6RdK2/PmJkv7bsI1KOkzSNZLukXS3JF8uamZWk7K/3P1z4P3AkwARcQdw9gjtXgp8KSJeBLwE33PXzKw2Zef4D46Ir2f3Rn/GU8M0mOf6/zJZ1g8R8QTwxDDbGoeqgruK252mcKZpNswxK4a3dTt3i22zM/it3/s7OeTNZlXZEf9Dko4lj2KW9CayKIdhrAIWgMskfVPSJyU9t3MlSRskzUuaX1hYGLKp/trBXZAVgl7/yEfZ7jSFM02zQY/Z2jXLnynkvc5dr20W31v2/UXj/KyY1a3siP9dwBzwIkk7gfuA9SO0+TLg/IjYLOlS4ELgvxdXioi5vE1arVal2f9VBXe1t2vlDXLMigFYi527btvsDM8a9P0OebNZVvaqnu8Dp+Uj830iYs8Ibe4AdkTE5vz5NWSF38zMalD2qp4PSTosIn4aEXskHS7pD4dpMCIeBH4o6fh80anA9mG2ZWZmgys7x/+6iHi4/SQi/hE4c4R2zweulHQHsAb40AjbMjOzAZSd499X0oER8TiApOcABw7baERsBVrDvt/MzIZXtvBfCdwi6bL8+duBK6rpkpmZVansL3c/nE/LnJov+oOI+NvqumVmZlUpO+InIm4EbqywL2ZmVgPfgcvMLDG+A5eZWWLKFn7fgauEJubz9MvCKWuxzJtiW6Mcs87snWG3WfY8djs2TfwMWPP4Dlxj1M51Wb1sSSPyeYr9b+fVDFv4i8eml1GOWa/3DbPNMuex17Fp2mfAmsl34BqzJuXzlM3CKavKY9OZvTOqfn1d7Ng06TNgzeQ7cJmZJabsVT1HS/prSbvzx+ckHV1158zMbPzKZvVcBlwPHJU/vpAvMzOzGVO28B8ZEZdFxFP543LgyAr7ZWZmFSlb+H8sab2kffPHeuDHVXbMzMyqUbbw/zbwG8CDZLdcfBNZUJuZmc2Yslf13A+8oeK+mJlZDcpe1XOFpMMKzw+XtHGUhvMpo29KumGU7ZiZ2WDKTvWc2OUOXC8dse0LAMdAmJnVrOw3d/eRdHhe8JF0xADv3Uv+HYBfBT4I/OdhtzOIXlkxnTEC3fJeuhkltyYFncd7FnJr2ud+mL6O8l6zupUt3pcAt0u6On/+ZrKiPayPA+8DDu21gqQNwAaAFStGL7C9smKKeSplc1VGza1JQefxnvbcmmLfBu3rKO81m4Syv9z9tKR54JR80RsjYvswDUp6PbA7IrZIOnmRNueAOYBWqxXDtNVpkPyVxYwjtyYFs5RZM0rWz7hzgsyqNsgduLYDQxX7Dq8G3iDpTOAgYImkz0TE+jFs28zM+ij7y92xiYj3R8TREbESOBv4exd9M7P61F74zcxssoa+MmccIuLLwJcn2Qczs9R4xG9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS8xEL+esWjEorKrwrDramGZlw+/MbHo0esTfDgqD6sKz6mhjmhX3vyjFY2E2Kxo94od6gsJmKYysCqnvv9msafSI38zM9ubCb2aWGBd+M7PEuPCbmSXGhd/MLDEu/GZmiXHhNzNLTO2FX9Ixkm6VtF3SXZIuqLsPZmYpm8QXuJ4C3hsR35B0KLBF0s35zdzNzKxitRf+iNgF7Mr/vkfS3cByYKYK//Zdj/KWP7s9qUya9j53Lktl/82aYqKRDZJWAi8FNnd5bQOwAWDFihX1dqyPYgZNKpk0vfYxlf03axJFxGQalg4BvgJ8MCKuXWzdVqsV8/PzA7fRHp06R8bMUiRpS0S0OpdP5KoeSfsDnwOu7Ff0zcxsvCZxVY+ATwF3R8TH6m7fzCx1kxjxvxr4TeAUSVvzx5kT6IeZWZImcVXP/wZUd7tmZpbxN3fNzBLjwm9mlhgXfjOzxLjwm5klxoXfzCwxLvxmZolx4TczS4wLv5lZYlz4zcwS48JvZpYYF34zs8S48JuZJcaF38wsMS78ZmaJceE3M0uMC7+ZWWImdc/dMyR9W9J3JV04iT6YmaVqEvfc3Rf4H8DrgNXAOkmr6+6HmVmqJjHi/7fAdyPi+xHxBPCXwNoJ9MPMLEm133MXWA78sPB8B/DKzpUkbQA2AKxYsWKohlYftWSo95mZNdkkCn8pETEHzAG0Wq0YZhsXnfXisfbJzKwJJjHVsxM4pvD86HyZmZnVYBKF//8AL5S0StIBwNnA9RPoh5lZkmqf6omIpyT9R+BvgX2BjRFxV939MDNL1UTm+CPii8AXJ9G2mVnq/M1dM7PEuPCbmSXGhd/MLDEu/GZmiVHEUN+NqpWkBeD+Id++FHhojN2ZBd7nNHif0zDKPv9cRBzZuXAmCv8oJM1HRGvS/aiT9zkN3uc0VLHPnuoxM0uMC7+ZWWJSKPxzk+7ABHif0+B9TsPY97nxc/xmZvZsKYz4zcyswIXfzCwxjS78Tb+pu6RjJN0qabukuyRdkC8/QtLNku7N/zx80n0dN0n7SvqmpBvy56skbc7P9VV55HdjSDpM0jWS7pF0t6RXNf08S3pP/rneJmmTpIOadp4lbZS0W9K2wrKu51WZP8n3/Q5JLxu23cYW/kRu6v4U8N6IWA2cBLwr38cLgVsi4oXALfnzprkAuLvw/MPAH0fEzwP/CJw3kV5V51LgSxHxIuAlZPve2PMsaTnwbqAVESeQRbifTfPO8+XAGR3Lep3X1wEvzB8bgD8dttHGFn4SuKl7ROyKiG/kf99DVgyWk+3nFflqVwC/NpEOVkTS0cCvAp/Mnws4BbgmX6VR+yzpZ4BfBj4FEBFPRMTDNPw8k8XGP0fSfsDBwC4adp4j4jbgJx2Le53XtcCnI/M14DBJy4Zpt8mFv9tN3ZdPqC+Vk7QSeCmwGXh+ROzKX3oQeP6k+lWRjwPvA57On/8s8HBEPJU/b9q5XgUsAJfl01uflPRcGnyeI2In8FHgAbKC/wiwhWaf57Ze53VsNa3JhT8Zkg4BPgf8p4h4tPhaZNfrNuaaXUmvB3ZHxJZJ96VG+wEvA/40Il4K/JSOaZ0GnufDyUa4q4CjgOey95RI41V1Xptc+JO4qbuk/cmK/pURcW2++EftHwHzP3dPqn8VeDXwBkk/IJu+O4Vs/vuwfEoAmneudwA7ImJz/vwasv8ImnyeTwPui4iFiHgSuJbs3Df5PLf1Oq9jq2lNLvyNv6l7Prf9KeDuiPhY4aXrgXPzv58LXFd336oSEe+PiKMjYiXZOf37iHgrcCvwpny1pu3zg8APJR2fLzoV2E6DzzPZFM9Jkg7OP+ftfW7seS7odV6vB34rv7rnJOCRwpTQYCKisQ/gTOA7wPeAD0y6PxXs32vIfgy8A9iaP84km/O+BbgX+DvgiEn3taL9Pxm4If/7C4CvA98FrgYOnHT/xryva4D5/Fx/Hji86ecZ+H3gHmAb8BfAgU07z8Amst9hPEn2k915vc4rILIrFb8H3El2xdNQ7TqywcwsMU2e6jEzsy5c+M3MEuPCb2aWGBd+M7PEuPCbmSXGhd+sQ56E+c7870dJuqbfe8xmiS/nNOuQ5x7dEFkqpFnj7Nd/FbPkXAwcK2kr2ZdofiEiTpD0NrKkxOeSReN+FDgA+E3gceDMiPiJpGPJvmhzJPAY8O8j4p66d8KsF0/1mO3tQuB7EbEG+N2O104A3gi8Avgg8FhkwWm3A7+VrzMHnB8RLwf+C/CJOjptVpZH/GaDuTWyex/skfQI8IV8+Z3AiXlS6i8CV2cRM0AWNWA2NVz4zQbzeOHvTxeeP03272kfssz4NTX3y6w0T/WY7W0PcOgwb4zsfgj3SXozPHOf1JeMs3Nmo3LhN+sQET8G/iG/AfZHhtjEW4HzJH0LuIuG3fLTZp8v5zQzS4xH/GZmiXHhNzNLjAu/mVliXPjNzBLjwm9mlhgXfjOzxLjwm5kl5l8BeqV64YNsGHsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -79,12 +79,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -110,7 +110,7 @@ " values = model.simulate(k, times)\n", " plt.step(times, values)\n", " \n", - "plt.title('stochastic degradation across different iterations')\n", + "plt.title('stochastic production and degradation across different iterations')\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", "plt.plot(times, sol,'--', color='black', label='ode solution')\n", diff --git a/examples/toy/model-stochastic-schlogl.ipynb b/examples/toy/model-stochastic-schlogl.ipynb index dca2d2545c..9844ca8504 100644 --- a/examples/toy/model-stochastic-schlogl.ipynb +++ b/examples/toy/model-stochastic-schlogl.ipynb @@ -17,59 +17,6 @@ "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)." ] }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "D:\\Part B\\python\\python.exe\n", - "started\n", - "Collecting git+https://github.com/pints-team/pints.git@additional-stochastic-models\n", - " Cloning https://github.com/pints-team/pints.git (to revision additional-stochastic-models) to c:\\users\\victor\\appdata\\local\\temp\\pip-req-build-s9fa4com\n", - "Requirement already satisfied, skipping upgrade: cma>=2 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.1.0)\n", - "Requirement already satisfied, skipping upgrade: numpy>=1.8 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (1.21.2)\n", - "Requirement already satisfied, skipping upgrade: scipy>=0.14 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (1.7.2)\n", - "Requirement already satisfied, skipping upgrade: matplotlib>=1.5 in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.4.3)\n", - "Requirement already satisfied, skipping upgrade: tabulate in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (0.8.9)\n", - "Requirement already satisfied, skipping upgrade: threadpoolctl in d:\\part b\\python\\lib\\site-packages (from pints==0.4.1) (3.0.0)\n", - "Requirement already satisfied, skipping upgrade: kiwisolver>=1.0.1 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (1.3.2)\n", - "Requirement already satisfied, skipping upgrade: python-dateutil>=2.7 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (2.8.1)\n", - "Requirement already satisfied, skipping upgrade: pillow>=6.2.0 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (8.4.0)\n", - "Requirement already satisfied, skipping upgrade: pyparsing>=2.2.1 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (2.4.7)\n", - "Requirement already satisfied, skipping upgrade: cycler>=0.10 in d:\\part b\\python\\lib\\site-packages (from matplotlib>=1.5->pints==0.4.1) (0.11.0)\n", - "Requirement already satisfied, skipping upgrade: six>=1.5 in d:\\part b\\python\\lib\\site-packages (from python-dateutil>=2.7->matplotlib>=1.5->pints==0.4.1) (1.14.0)\n", - "Installing collected packages: pints\n", - " Running setup.py install for pints: started\n", - " Running setup.py install for pints: finished with status 'done'\n", - "Successfully installed pints-0.4.1\n", - "done\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " Running command git clone -q https://github.com/pints-team/pints.git 'C:\\Users\\Victor\\AppData\\Local\\Temp\\pip-req-build-s9fa4com'\n", - " Running command git checkout -b additional-stochastic-models --track origin/additional-stochastic-models\n", - " Branch 'additional-stochastic-models' set up to track remote branch 'additional-stochastic-models' from 'origin'.\n", - " Switched to a new branch 'additional-stochastic-models'\n", - "WARNING: You are using pip version 19.2.3, however version 22.0.2 is available.\n", - "You should consider upgrading via the 'python -m pip install --upgrade pip' command.\n" - ] - } - ], - "source": [ - "import sys\n", - "print(sys.executable)\n", - "print(\"started\")\n", - "!{'D:\\\\\"Part B\"\\\\python\\python.exe'} -m pip install --upgrade git+https://github.com/pints-team/pints.git@additional-stochastic-models\n", - "print(\"done\")" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -87,17 +34,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):" + "Specify the initial concentration, and select time points at which to record concentration values, and the rate constant values $k_1$, $k_2$, $k_3$, $k_4$:" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -127,19 +74,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute the stochastic mean $M(t)$ which gives the average number of molecules of $A$ at time $t$. This function can be described by the following ODE (Erban et al., 2007): $ \\frac{\\text{d}M}{\\text{d}t} = -k_1 M + k_2 $.\n", + "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute deterministically the solution to the ODE equivalent(Erban et al., 2007): $ \\frac{\\text{d}a}{\\text{d}t} = -k_2 a^3 + k_1 a^2 - k_4 a + k_3 $.\n", "\n", - "We will plot the ODE solution, and compare it to 10 stochastic simulations to show that the stochastic simulation average to the desired function.\n" + "We will plot the ODE solution, and compare it to the stochastic simulation to show that the two functions are similar.\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABrrklEQVR4nO2dd5wV1fn/P88t24Bl6b2DFGnSRBGlREXQoKiJiD1qLFHzjTEQk1gSC/qzxx67sYAlFjBGVBCQDlKkd9kFYZe6LNvuvc/vj5kz98zcmblzd+/det689sXcqWdmzpznPOU8h5gZCoVCoVAAgK+6C6BQKBSKmoMSCgqFQqEwUEJBoVAoFAZKKCgUCoXCQAkFhUKhUBgooaBQKBQKAyUUFHUGItpFRL9w2DaKiHKTdB0mou7JOJdCUdNQQkFR4yCiM4hoEREdJaJDRPQ9EQ2t7nLZQURvENE11VyGpAk8hSJQ3QVQKGSIKBvALAA3A5gJIA3ASACl1VkuhaK+oDQFRU3jJABg5veYOczMxcz8FTOvFTsQ0Q1EtJGIColoAxENko4fSERrdS1jBhFl2F2EiHoT0TwiOkJE64nol9K2ZkT0OREdI6LlRPQAES2MV3Ai6k5E3+nXLiCiGQ77ZRDRv4nooH795UTUioguJaKVln3/QESf6svj9fstJKI8IvojETUA8F8AbYnouP7Xloh8RDSNiLbr15lJRE3183TWTWDXEtEeIjpMRDcR0VD92R0homfj3a+ijsLM6k/91Zg/ANkADgJ4E8B5AJpYtl8KIA/AUAAEoDuATvq2XQCWAWgLoCmAjQBu0reNApCrLwcBbANwNzRNZAyAQgA99e3v639ZAPoA2ANgoVQGBtDdpuzvAfgLtM5WBoAzHO7xtwA+18/vBzBYv+90AIcA9Jb2/QHAxfryPgAj9eUmAAZZ70067g4ASwC018/7EoD39G2d9Xt4US/nOQBKAHwCoCWAdgAOADiruuuD+qv6P6UpKGoUzHwMwBnQGq1/Acgnos+IqJW+y/UAHmXm5ayxjZl3S6d4hpn3MvMhaA3vQJvLDAfQEMB0Zi5j5m+hmawmE5EfwMUA7mXmE8y8AZqA8kI5gE4A2jJzCTM7aRflAJpBEyxhZl7JzMeYuRTADABXAAARnQytAZ8lHdeHiLKZ+TAzr3Ipy00A/sLMufp57wNwCRHJJuN/6OX8CkARNKFxgJnzACwAcIrH+1bUIZRQUNQ4mHkjM1/DzO0B9IXW839K39wBwHaXw3+Wlk9Aa/yttAWwh5kj0rrd0HrILaD52vZI2+RlN/4ETXtZppukrnPY720A/wPwPhHtJaJHiSiob3sTwOVERACuBDBTb9QBTViNB7BbN1Od5lKWTgD+o5uCjkDTmsIAWkn77JeWi21+2z07RR1HCQVFjYaZNwF4A5pwALQGulslT7sXQAcikut/R2hmqXwAIWhmF0EHj2X9mZlvYOa20ExEz9uFrjJzOTPfz8x9AJwO4HwAV+nblgAog+ZcvxyaABHHLWfmidBMPJ9Ac8QDmlZlZQ+A85g5R/rL0LUAhcIRJRQUNQoi6kVEdxJRe/13BwCTodnHAeAVAH8kosGk0Z2IOiV4maXQtIg/EVGQiEYBuADA+8wcBvAxgPuIKIuIekFvsD2U/VJRbgCHoTXWEZv9RhNRP91UdQyaWUje7y0AzwIoFyYoIkojoilE1JiZy/XjxDH7ATQjosbSOV4E8KB4NkTUgogmerkPRf1GCQVFTaMQwKkAlhJRETRh8COAOwGAmT8A8CCAd/V9P4HmVPYMM5dBEwLnASgA8DyAq3StBAB+B6AxNFPU29AcyF5CYofq5T4O4DMAdzDzDpv9WgP4EFrDvhHAd5A0An25L4B/W467EsAuIjoGzWcwRb+fTXoZd+jmorYAntbL8BURFUJ7jqd6uAdFPYeY1SQ7CoUbRPQIgNbMfHUVXS8TWvTPIGbeWhXXVCgESlNQKCzoJqz+unlqGIDfAPhPFRbhZgDLlUBQVAdqRLNCEUsjaOaYttDs9Y8D+LQqLkxEu6BFMF1YFddTKKwo85FCoVAoDJT5SKFQKBQGtdp81Lx5c+7cuXN1F0OhUChqFStXrixg5hZ222q1UOjcuTNWrFhR3cVQKBSKWgUR7XbapsxHCoVCoTBQQkGhUCgUBkooKBQKhcKgVvsU7CgvL0dubi5KSkqquyiKWkJGRgbat2+PYDAYf2eFoo5T54RCbm4uGjVqhM6dO0PLPqxQOMPMOHjwIHJzc9GlS5fqLo5CUe3UOfNRSUkJmjVrpgSCwhNEhGbNminNUqHQqXNCAYASCIqEUPVFoYhSJ4WCQlFXOHqiHJ+v2VvdxVDUI5RQqCKeeuopnDhxokLH3nfffXjssccqXYY33ngDe/dGG5jrr78eGzZsqNQ5Tz/99MoWCwCwa9cu9O3bN+4+7777rvF7xYoVuP3225Ny/ZrKHTN+wG3v/YDdB4uquyiKeoISClVEZYRCsrAKhVdeeQV9+vSp1DkXLVpU2WJ5xioUhgwZgmeeeabKrl8d7D1SDAAoLg9Xc0kU9QUlFJJMUVERJkyYgAEDBqBv376YMWMGnnnmGezduxejR4/G6NGjAQDvvfce+vXrh759+2Lq1KnG8V9++SUGDRqEAQMGYOzYscb6DRs2YNSoUejataupIbzwwgsxePBgnHzyyXj55ZcBAOFwGNdccw369u2Lfv364cknn8SHH36IFStWYMqUKRg4cCCKi4sxatQoI02I03UF69evx7BhwzBw4ED0798fW7dqqf4bNtTmdp83bx7OOussTJw4EV27dsW0adPwzjvvYNiwYejXrx+2b98OALjmmmvw4YcfGucVx8vs2rULI0eOxKBBgzBo0CBD8EybNg0LFizAwIED8eSTT2LevHk4//zzAQCHDh3ChRdeiP79+2P48OFYu3YtAE3Luu6662yfXW2AoPk7VDJjRVVR50JSZe7/fD027D2W1HP2aZuNey842XH7l19+ibZt22L27NkAgKNHj6Jx48Z44oknMHfuXDRv3hx79+7F1KlTsXLlSjRp0gTnnHMOPvnkE4wYMQI33HAD5s+fjy5duuDQoUPGeTdt2oS5c+eisLAQPXv2xM0334xgMIjXXnsNTZs2RXFxMYYOHYqLL74Yu3btQl5eHn788UcAwJEjR5CTk4Nnn30Wjz32GIYMGWIqc35+vuN1BS+++CLuuOMOTJkyBWVlZQiHY3uua9aswcaNG9G0aVN07doV119/PZYtW4ann34a//znP/HUU095esYtW7bEnDlzkJGRga1bt2Ly5MlYsWIFpk+fjsceewyzZs0CoAkiwb333otTTjkFn3zyCb799ltcddVVWL16teuzqw0IH7gSCoqqQmkKSaZfv36YM2cOpk6digULFqBx48Yx+yxfvhyjRo1CixYtEAgEMGXKFMyfPx9LlizBmWeeacTLN20anXp4woQJSE9PR/PmzdGyZUvs378fAPDMM89gwIABGD58OPbs2YOtW7eia9eu2LFjB2677TZ8+eWXyM7Odi2z23UFp512Gh566CE88sgj2L17NzIzM2P2GTp0KNq0aYP09HR069YN55xzjvFMdu3a5e0BQhuAeMMNN6Bfv3649NJLPfk9Fi5ciCuvvBIAMGbMGBw8eBDHjmkdAqdnV5tgKKmgqBrqtKbg1qNPFSeddBJWrVqFL774An/9618xduxY3HPPPZU+b3p6urHs9/sRCoUwb948fP3111i8eDGysrIwatQolJSUoEmTJlizZg3+97//4cUXX8TMmTPx2muvVer6l19+OU499VTMnj0b48ePx0svvYQxY8Y4ltHn8xm/fT4fQqEQACAQCCASiQAAIpEIysrKYq715JNPolWrVlizZg0ikQgyMjIqVXa7Z1dbEOGySlNQVBVKU0gye/fuRVZWFq644grcddddWLVqFQCgUaNGKCwsBAAMGzYM3333HQoKChAOh/Hee+/hrLPOwvDhwzF//nzs3LkTAGzNODJHjx5FkyZNkJWVhU2bNmHJkiUAgIKCAkQiEVx88cV44IEHbMsg4+W6O3bsQNeuXXH77bdj4sSJhs0+UTp37oyVK1cCAD777DOUl5fb3lebNm3g8/nw9ttvG6Yqp/IDwMiRI/HOO+8A0MxKzZs3j6sh1QZ8ynykqGLqtKZQHaxbtw533XUXfD4fgsEgXnjhBQDAjTfeiHHjxqFt27aYO3cupk+fjtGjR4OZMWHCBEycOBEA8PLLL2PSpEmIRCKGbd2JcePG4cUXX0Tv3r3Rs2dPDB8+HACQl5eHa6+91uiRP/zwwwA0J+9NN92EzMxMLF682DhPixYt4l535syZePvttxEMBtG6dWvcfffdFXo+N9xwAyZOnIgBAwZg3LhxaNCgQcw+t9xyCy6++GK89dZbpn369+8Pv9+PAQMG4JprrsEpp5xiHCMcyv3790dWVhbefPPNCpWvpmH4FJT5SFFF1Oo5mocMGcLWSXY2btyI3r17V1OJFLWVmlpvLvjnQqzLO4pPbx2BAR1yqrs4ijoCEa1k5iF225T5SKGowQhNYeXuw3h78a5qLYuifqDMRwpFDUY4mv8+S4vAuvK0ztVYGkV9IGWaAhFlENEyIlpDROuJ6H59fRciWkpE24hoBhGl6evT9d/b9O2dU1U2haK2oFL1KaqaVJqPSgGMYeYBAAYCGEdEwwE8AuBJZu4O4DCA3+j7/wbAYX39k/p+CkW9RiVwVVQ1KRMKrHFc/xnU/xjAGAAiz8GbAC7Ulyfqv6FvH0sqp7GinqM+AEVVk1JHMxH5iWg1gAMA5gDYDuAIM4vRQ7kA2unL7QDsAQB9+1EAzWzOeSMRrSCiFfn5+aksvkJR7ah+kaKqSalQYOYwMw8E0B7AMAC9knDOl5l5CDMPadGiRWVPV20kKx22HV7SUAPAQw89ZPqdrDTYiuShRIKiqqmSkFRmPgJgLoDTAOQQkYh6ag8gT1/OA9ABAPTtjQEcrIry1VesQqEq02ArvKEUBUVVk8rooxZElKMvZwI4G8BGaMLhEn23qwF8qi9/pv+Gvv1brqUj65544gn07dsXffv2NWUGffDBB3HSSSfhjDPOwObNm43127dvx7hx4zB48GCMHDkSmzZtijnnd999h4EDB2LgwIE45ZRTUFhYCGbGXXfdZaTInjFjRsxxb7zxBn73u98Zv88//3zMmzcP06ZNQ3FxMQYOHIgpU6YAiKaxdjrvvHnzMGrUKFxyySXo1asXpkyZglr6imoNpHQFRRWTynEKbQC8SUR+aMJnJjPPIqINAN4nogcA/ADgVX3/VwG8TUTbABwCcFkyCjFq1KiYdb/61a9wyy234MSJExg/fnzM9muuuQbXXHMNCgoKcMkll5i2yema7Vi5ciVef/11LF26FMyMU089FWeddRYikQjef/99rF69GqFQCIMGDcLgwYMBaCkwXnzxRfTo0QNLly7FLbfcgm+//dZ03sceewzPPfccRowYgePHjyMjIwMff/wxVq9ejTVr1qCgoABDhw7FmWee6em5TJ8+Hc8++6yRXlrG7bw//PAD1q9fj7Zt22LEiBH4/vvvccYZZ3i6piJxlKagqGpSJhSYeS2AU2zW74DmX7CuLwFwaarKU1UsXLgQF110kZGvZ9KkSViwYAEikQguuugiZGVlAQB++ctfAgCOHz+ORYsW4dJLo7deWloac94RI0bgD3/4A6ZMmYJJkyahffv2WLhwISZPngy/349WrVrhrLPOwvLly9G/f/9K34PdebOzszFs2DC0b98eADBw4EDs2rVLCYUUooSCoqqp8yOa3Xr2WVlZrtubN28eVzOoLJFIBDk5ObY9dplp06ZhwoQJ+OKLLzBixAj873//83R+OVU1AJSUlFSmuLU6DXVtRJmPFFWNyn2UZEaOHIlPPvkEJ06cQFFREf7zn/9g5MiROPPMM/HJJ5+guLgYhYWF+PzzzwEA2dnZ6NKlCz744AMAmj1/zZo1Mefdvn07+vXrh6lTp2Lo0KHYtGkTRo4ciRkzZiAcDiM/Px/z58/HsGFmJaxz585YvXo1IpEI9uzZg2XLlhnbgsGgbepqL+dVVA1KU1BUNXVeU6hqBg0ahGuuucZoRK+//nojxfOvf/1rDBgwAC1btsTQoUONY9555x3cfPPNeOCBB1BeXo7LLrsMAwYMMJ33qaeewty5c+Hz+XDyySfjvPPOQ1paGhYvXowBAwaAiPDoo4+idevWplnORowYgS5duqBPnz7o3bs3Bg0aZGy78cYb0b9/fwwaNMiYiwAALrroItvz2jnAFaklnlBYtvMQPlixB49e0l+NaVAkBZU6W6FAza03V7yyFAu3FRi/d02fYNre7e4vEI4wtj14HgJ+pfgrvKFSZysUtZR4nX+xOVyLO3eKmoUSCgpFDSaeScinbw9HlFBQJIc6KRRqs0lMUfXU5PoSz0sgZIYSCopkUeeEQkZGBg4ePFijP3RFzYGZcfDgQWRkZFR3UWyxKgrWei00BSnqWKGoFHUu+qh9+/bIzc2FyqCq8EpGRoYxIK+mYdUUmM2Cwqcvh5RUUCSJOicUgsEgunTpUt3FUCiSgtWnYNV/DZ+C0owVSaLOmY8UirqEL475SPkUFMlGCQWFokYTR1PwqegjRXJRQkGhqMFYHc0RB0ezEgqKZKGEgkJRg7FzNNttV0JBkSyUUFAoajBxRzSLkFTlaFYkCSUUFIoajDV1dqz5SPs/pDQFRZJQQkGhqMHEDl6TlxkHCrUJmZT5SJEslFBQKGowMUJBWl6Xd9RYVkJBkSyUUFAoajA+6+A1SVUoD0dHMSuhoEgWSigoFDUYv8/qU4guSzJBCQVF0lBCQaGowfhd7EdyviMlFBTJImVCgYg6ENFcItpAROuJ6A59/X1ElEdEq/W/8dIxfyaibUS0mYjOTVXZFIrags9nHdEcbfzlHHgq95EiWaQyIV4IwJ3MvIqIGgFYSURz9G1PMvNj8s5E1AfAZQBOBtAWwNdEdBIzh1NYRoWiRmPVFFhpCooUkzJNgZn3MfMqfbkQwEYA7VwOmQjgfWYuZeadALYBGJaq8ikUtQGf5QuVxynIy0ooKJJFlfgUiKgzgFMALNVX/Y6I1hLRa0TURF/XDsAe6bBc2AgRIrqRiFYQ0Qo1Z4KirhMTfSQtK0ezIhWkXCgQUUMAHwH4PTMfA/ACgG4ABgLYB+DxRM7HzC8z8xBmHtKiRYtkF1ehqFHEhqRGl2VBoEY0K5JFSoUCEQWhCYR3mPljAGDm/cwcZuYIgH8haiLKA9BBOry9vk6hqLewJVk2O5iMlJ9ZkSxSGX1EAF4FsJGZn5DWt5F2uwjAj/ryZwAuI6J0IuoCoAeAZakqn0JRG7A29ibzEctCQUkFRXJIZfTRCABXAlhHRKv1dXcDmExEA6HV710AfgsAzLyeiGYC2AAtculWFXmkqO9Ym3q57Y9EZKdz1ZRHUfdJmVBg5oWITQcPAF+4HPMggAdTVSaForYRqynY+xFU6mxFslAjmhUKD3y7aT82/1xYDVc2N/ayRiDnPlJCQZEsUmk+UijqDNe9sQIAsGv6hCq9boymwPaagpIJimQRVygQUQaA8wGMhDbSuBiac3g2M69PbfEUCoWMdT4FgRqnoEgWrkKBiO6HJhDmQRt4dgBABoCTAEzXBcadzLw2xeVUKOolsZqC/bIyHymSRTxNYRkz3+uw7QkiagmgY5LLpFAodGLGKcDeuaxkgiJZuAoFZp4dZ/sBaNqDQqFIAUpTUFQ1XnwK7QFMBnAGLD4FAP/VRyYrFIoUEDNOQVo2J8erkuIo6gHxfAqvQ0tKNwvAIzD7FMYB+AsRTWPm+akuqEJRH7EqAE4mI6UpKJJFPE3hcWb+0Wb9jwA+JqI0KJ+CQpEyYnMf2W9TaS4UycJ18JoQCGLWNBkiuoOZy5h5W6oKp1DUNNbvPYqS8irMvsJAwEe474I+0RU6EZOmUHVFUtRtvI5ovtpm3TVJLIdCUSuY8MxC/GHm6iq7HgNok5OB5o3SAZgbf2U+UqSCeD6FyQAuB9CFiD6TNjUCcCiVBVMoaiqrdh+psmsxM0j/p/2OblOOZkUqiOdTWARtIpzmME+GUwhADVhT1EvILs1jimD9euKaVh+DsZ/SFBRJIp5Q+ImZdwM4zWkHIiJWNVKhSAnMWqphH0V/CyIqS6oiBcTzKcwlotuIyBRhRERpRDSGiN6Evb9BoaizVKGioGsKZFzVyWSkzEeKZBFPUxgH4DoA7+mzoR0BkAlNmHwF4Clm/iGlJVQoqhmrIkxVaT+CJg7IRlNwSnmhUFSGeGkuSgA8D+B5fb7l5gCKmflIFZRNoagRVGd7KwSSz0YQOUUiKRSVwfMkO8xczsz7AJQT0RVE5JoXSaGoK1h74VXtaAZFTVYRh+RHEWU/UiQJT0JB9yFcREQfQItGGgvgxZSWTOEJZkZpSE1lnUqs7W2VWo/Y2XykfAqKVOAqFIjoHD3/0U4AFwN4C8AhZr6WmT+vigIq3Hn8qy3o+dcvcaIsVN1FqbPEaApV6GpmMIhICkk1bxMon4IiWcTTFL4E0BXAGcx8hS4IVFbUGsTMFXsAAMeKlVBIBeXhCLYdOF5t12dDU3CPPlJR4YpkES/6aBCAywB8TUQ7ALwPwJ/yUik8E9AD2EMRJatTwcNfbMJr3+80ratSnwJr1xOOZmZ77UCZjxTJIl5CvNXMPI2ZuwG4F8BAAEEi+i8R3eh2LBF1IKK5RLSBiNaLpHpE1JSI5hDRVv3/Jvp6IqJniGgbEa0lokHJucW6jd+v9yCVTEgJK3bHZnOpWpeCluZCDF6LmO1HBmGlKSiSRCLRR4uY+TYA7QE8CWB4nENC0OZv7qPveysR9QEwDcA3zNwDwDf6bwA4D0AP/e9GAC8kciP1FT8pTSGV+H2xIqAqxykITUG857DDKGblU1Aki3iO5s7WdcwcYeavmPk6vXff3u5YZt7HzKv05UIAG6FN2DMRwJv6bm8CuFBfngjgLdZYAiCHiNpU4J7qFaLRUo1CagjYCYUqvL54qz6b98wMNEjzIzPoV+MUFEkjnqbw/4joIyK6iohOJqKWRNRRT3HxdwDfA+gd7yK6cDkFwFIArfTxDgDwM4BW+nI7AHukw3L1ddZz3UhEK4hoRX5+frxL13n8hk9BtQqpwE5TqEqpoGkKZPgUZIUwYmxT4xSqir1HitF52mws2l5Q3UVJGfF8CpcC+BuAngCeA7AAwKcArgewBcAYZp7jdg4iagjgIwC/Z+ZjlvMzYqehdYWZX2bmIcw8pEWLFokcWifx+7RXGFaNgisfrczFv5fsTvi4gM+zhTVFMAiAXy+GSVMAG05o9fqrhhW7DwMA3l36UzWXJHXEiz4CM28A8JeKnFxPjfERgHeY+WN99X4iasPM+3Tz0AF9fR6ADtLh7fV1CheEeUMJBXfu/GANAOCK4Z0SOs7Wp5CUEnlD+BSEHyNsMR/5iMBgZT6sIoxov3Ddfd4p6waRVotfBbCRmZ+QNn2GaGbVq6FpHmL9VbqfYjiAo5KZSeGAsDWX1+FKWp3Y+RSqsv0V8yn4DfOR2blMpNUBNU6haggY31vdDeyIqylUghEArgSwjohW6+vuBjAdwEwi+g2A3QB+pW/7AsB4ANsAnABwbQrLVmeI9lzqbiWtTgL+WKFQ1f4bAkkBBdH1QlOwrlekjqBux6vLPryUCQVmXghnTXuszf4M4NZUlaeuEg1JrbuVtDqx8ylUpalOaAAiCtYakiryIinzUdXgrweDRT0LBSJqB6CTfAwzz09FoRTe8dcDdbY6sfMpJPNZv/79TqzfewyPXTrAdrthPvLFjmgWE/BoQiFpRVK4IDTHuuxT8CQUiOgRAL8GsAGASMnJAJRQqGZEJVU+BW9EImz4YbyQavPR/Z9vAABnoWBMx2nnaBbRRyr3UVXhqweauVdN4UIAPZm5NIVlUVQAv/IpJERxeRgN0r1bTRvZ7FuVz1qbTyE6TkE2H2k+Ba2hqqnRZ/O35GNE9+b24z1qIcJMV5eFgtfoox0AgqksiKJiGNEQdbiSJpOS8sTmnvDb+BSqNPqIxTgFYT6Kbosww0daIu+a+Pa/25KPq15bhufnbqvuoiQN8fzrcifMq1A4AWA1Eb2kJ617hoieSWXBFN4gm1DFVLNgaz5W7zlSZddLJokmjpMduH87vw8AYHi3ZkktkxvMmkDw2Tqao2m1a6L16MCxEgDAroMnqrkkyUM8/5qqmSUDr3r0Z/qfooaS6ugTZsaa3KMY0L4xrnx1GQBg1/QJKb1mKkj0McnPtU3jDPRq3ahKB6+JCKNo6KnZfCQczVwjdYW6h3j+dTmww5NQYOY3iSgNwEn6qs3MXJ66YikSJdUdl8/W7MUd76/G05cNTO2FUkyiwlPuEQr7fVV2EsVYBPuEeKyPdq5ak1Z9Rjznuvy8vc7RPArAVmj5j54HsIWIzkxdsRReEb3WVEef7MgvAgBs1/+vrSSq9suNcKOMIHy+WMGSe/gEFm5NTYI0MWo5mjo7uo0B3adQs0c01yUtRtSfujwuxKtP4XEA5zDzWcx8JoBzoc2poKghpLqOCvNFbewiWSN2Knps+yaZ8BPFNAhjHvsOV7y6tFJldCKqKWi/rXMoGJpCSq5eOapy3olkk3v4BEY/Ng97jxSb1ovnXxOfd7LwKhSCzLxZ/GDmLVDRSDUC8d2luucSvU5KL5MSZPtvopqC3DNv0zgTZGM+KkuhfTnCDJ/P2afg08NVa7SsrgFl232wCC99t93z/jNX5GJnQRHeX2bOhmoIhRpwT6nCq6N5BRG9AuDf+u8pAFakpkiKipDqxlpEv9RGU4A1jDMRIsxo0zgDn946AmkBX5XPXSDCTh0T4knLNY2apCdc+eoy/HToBC4Z3B7NGqbH3b9pltbnPXzC7DoVj782fgde8aop3AxtNPPt+t8GfZ2imiFUzcxrwhQgX6aiduwd+cdx879XJjxmoKJUZoL7cISRHvChZXYGAOFoTv6zdnqW0Yl0xIhm+Rhdg6uh5iNBTShbUWkIgPf336RBGgDg8Iky03qhadZAGZw0PAkFZi5l5ieYeZL+96Qa3VyzSKSBPlZSjlcX7qxQoy4fYTXFzFy+B3kWG6wdD8zeiP/++DMWpMg5ayVsscMneqycFsPnS41QcGqsmFmLehI+Bdk/gujgtRrR8lqoSS4FSlDTzUrTjCiz1u4zfSf1wXwUb47mmfr/64horfWvaoqocKMitv57P12Pf8zagO+3HazAdaIXkvMtnSgL4U8frcXkl5fEPVd6QKt2oveWatg0hWWC5qMIG6YbQIsCSkUyNCdfhxigZjcXdyQCY+a1umzOSA6GVPCELAgW74h+JzXRTJds4vkU7tD/Pz/VBVFUjIo4mo8Wa3ZSr+abD1bswey1+nxH0mXKIxFkwq9fX1tXcDy+ApmmC4WDRWVx9kwOYUtDmtCxETbl7UkL+HCiLPnCzEkoCG3ANiGevi0CTvi+rITCERBRSnIU1YRwWUpMJpg6WXLnRzznmnBPqSLeHM1i5rNbmHm3/AfgltQXT+GVRDQFY2yDx/3v+nAt1u89pl9H0hRC0ZYokaakqFQTRk75Y9bmHsGaJKbRsIZxJnqsj8xCocxBU6hMQ+GUfkPTBqJCwew01/4nVF5T6P6X/2LCMwsqdQ4riTbETny8KhfHK6lV+hLsPMnvUpaT4vjaGIXnFa+O5rNt1p2XzIIoKoZwNCfSIEWHHFTApyAdEjLZtzVOlIUx5IE52PxzodtZYo6X+eWz32Pic98nXDYn5IbgyleX4l/zd3g+NkZT8PtQFrLXsCrTeXQ2H+k+BZvcRyIkNVkjmje5vrPEoSTEH/3w02H8YeYa3PPJj0kpi1fTn/w65E5BdJxC3ZUK8XwKNxPROgA9Lf6EnQCUT6EGkVgPWBckFbpOdLlM0hTk6xccL8NrC3fGvX5VJRWTTSuHT5TjwS82ej62LBwxzF2A0BTsNZxEk+2ZjnUyH+kNvxBMZqEgBq9RnW2iTpRpAnjf0ZJKnSdRM2vEpCnIQkH7vw5bj+JqCu8CuABaMrwLpL/BzHxFisum8EIFHM2VGZws95BMmkLEeT8nUpmT/vJ/LcHYx+cBqJxzsKQ8goygJBT8PpSHnHv1FcVVU/DJIcFm7cxInV1DWqm/f74BnafNBlAze9NeOyLyu5SjqIyQ1KSWqmYRz6dwlJl3MfNk3Y9QDO15NCSijlVSQoUrFRm8FK3jscd8sGIP/jFrg+Ox8mXkkcLW67sVRzRg8XLSd542G/uOxg9xtWPR9oNGnqbKCYUwMgJ+43cwQI6agp2z995Pf4wZFWuHm1AQAsHvo5jw2upOiLdoWwFufWeVURde+z6qIUadstVRMjN2kxS5IZdZ1hSe+npLzPa6hteEeBcQ0VYAOwF8B2AXgP+msFyKBEmkkrppCnd9uBavupp+ojiZj7TfzseJfb18oO5mKG/YNdaRCOOl77YbkVhOlJSHkRGMCoU0v99036Zz2jzQNxfvxrSP18Uto5PpiTkqxP2WFBvhCEd9CnGvkBqenbsNs9ftw5IdseHNycgTFA2KSM4dejXxmc1H0fUFx7WIuZqimaUCr47mBwAMB7CFmbsAGAsgfkC6AgCwZMfBlFWiikyyQx58Cs4jbO3NR9bLu33EYl8v5iO5l+YV67Owa6wXbCvAw//dhPs+W+94nvzCUmzPL0J60JtPoTIaidP7EyYiQBPm1jQX2gQ81ZclNeDXno2w/cvUpJh+UY3cOiKD/zEHj3+lpXiTd7NL7Fdz7iz5eBUK5cx8EICPiHzMPBfAELcDiOg1IjpARD9K6+4jojwiWq3/jZe2/ZmIthHRZiI6t0J3U4V8v63AUCXd+N/6n3HZy0vw1uLdCV/jUFEZ/jBjtae4+MfnbMHRE96muPDiUzhWbH9NJ/ORtVFyO3cimkJFMm1ahY1d41Sqj9EoLHF+ZiMe+RYALJoCoSwUsW2EEx0rcEy6tpOAFNFHgG4+koVCROvFErz5lIrLwkkXHuJ81vNGIoyaNA+N4Wh2KdPBojL881tt6tB4Aq2iz3HOhv0JRb9VB16FwhEiaghgPoB3iOhpAPES678BYJzN+ieZeaD+9wUAEFEfAJcBOFk/5nki8tscW2OY8spSPPX11rj75R3WbOI7CxKfh+CJOZvx8Q95+HBlruM+cpP50nzvWSAB9978oRP2A8vMI5pl85Hl3C4fjdgU8tCK+r3WUAmrsLH7wO1yOVkRZiLZpyAikcptQhsXboum7fgx7yiW2phUZN6WOgruIalaWa0T/ITFNg/RR3sOnUDve77Eux78G4kgnp+1+GHmSkVjGVQiKGLPoRN49tutKCoNGc/Qqc7ZCTVj2ebiFb2zG95akVD0W3Xg9ZObCG2e5v8D8CWA7dCikBxh5vkADiVw/vf1HEs7AWwDMMzjsdVKKpO6iXrpZkKRK2fAYwsaTcPsvI+z3Ty6bBrpadUUXK6fiKZQEfOR/OGHI2x7n4mcNcNiPgKAEpuxCre+u8pYPv+fC/HrOCk/0qVQV6eeqRi8BmhagTnNBRvzN6/NPYLTH/4GhxxGie/QOyVf/viza5kSJTqYy1z+cIQdtYiq4sk5W/DYV1uwZMfBuAEZpZb6LtcZO9NeVWbKrWritiJ6j30WM0eYOcTMbzLzM7o5qSL8Th/r8BoRNdHXtQOwR9onV19nV54biWgFEa3Iz8+vYBGSxxGPJpuKICqeW8MoV/KA1xQFHgavOc9BK/kUKhh9JPb1MpCoIkJBFjalobCrKcDLp50uaQpdmjcEAGzQR3hXhsy06HmdnoVIiAdo5iP5XsK6T4Gg1cO9R0vw9Yb9tucRxyV74hunEb4RZuM9zFq7D+tyjyb1ul4QaVRk05xTtbZ27uJl1q27IsGDUGDmMIAIETVOwvVeANANwEAA+6DN6JYQzPwyMw9h5iEtWrRIQpEqhujlHSlOXf4eUTFdFQCpdnrNWxOdwlP7//1lP6HztNk4LPUyz//nQvvLSdczjVOIcTQ7Iw5LnaYgCYXySKUHyQX80TL0bNUIgGaaqCyZkq/CUVNgmMxHZp+CiD6Kli/3sH25RAdAriLhCGPW2r2V6vVGB3PFagpyWWUtSmZnQZFrShMjrDVOObbnH8faXPvziOckymVHsUUomMaD2L2bOiwVvE6ycxzAOiKaA8mXwMy3J3IxZja6MUT0LwCz9J95ADpIu7bX11UbD87egKYN0nHzqG622zPT/CgNRVBYktzkaMyMfUdL0DYn05TbxomKaAokfSB7jxTjBX1GqkMnykwx72Uh82herXzStV3sruJDKikPY8+hE+jQNMtw2BrjFDwJBU+3ZEL+8EtCYVutJRFZI+8rnkcyZluThYKro1l/BVra7ug2WVOI7m9/LfEMZCH77yW7ce9n6/HIxRWvw2xoClabvHldU31+AiujH5sHANg1fYLtdi9+JwAY+/h3MecRV48wjJ7QgcKSmDBjIFbjtz5nQYM0P4rKwnVZJnj2KXwM4G/QHM0r9b+EZ14jojbSz4sAiMikzwBcRkTpRNQFQA8AyxI9fzL514KdeOTLTY7bxaeV7FQN/16yG6dP/xbr9x6VVH7n/eVvMVFNYcHWfJw+/VvsPqj1LgM+MqWJtktt7T0kVeOGt1bg7Cfn44pXlsbs60lT0O+ppDyMp7/e6ujrkJHLVR5iV/PRt5sOxPULyc/EcDR7KEc85PflljpbvDHrrG/hSHQ6Trtzyojzy1tF6ggRe18RRHGsbXeYzb4ca+fC+/kr/n0JgRXm6Ax1d7y/Gr95c3nMvr9/f7XjdeX7aJih9aNPlIWM86/NPYJPfqjWPmxS8aop5DDz0/IKIrrD7QAieg/AKADNiSgXwL0ARhHRQGhtxi4AvwUAZl6vz92wAUAIwK262arGk2yhsGL3YQDA1v3HjQbfrbGXK2/Qo6NZtCFrLXbeA4WlZvtrnKgL1+yj+k8xkY64L3nf2ev24YlQ2GSztyIavH/N34Env96CBul+XD+yq+P+ABCW7POhiL35SBa0L8/fgdvH9ohbBiC5moLJmenY+Ek+BdJGNG/+uRDnPjUfANCxaaappXfSFkVQgGxqYg+djniIct/5wRoM6JBjrLeaj/wVvEgywlpZGhUOwHYekc37zckAnd6NKE+ENed0RtCPXz6rJW+88BRbN2itw6v4vtpm3TVuB+ipMdowc5CZ2zPzq8x8JTP3Y+b+zPxLKTU3mPlBZu7GzD2ZucaPlhbVJNn5e9L0hr0sFDEqo9foo0Q1BWvDdumLi02/7Roqk6YgNb4xIX0uPTy5t1tsM+hJRtySsPl6ifaSTQ4hx+ij6LOyG3hlKoP0XIO6f8GLxhIPp2dp3kfyKeiO5jkbohFEVvORYHv+cfxhxmojYKBUj5aySwNdmeAg+dnO23zAWA5H2PSeKzpPQzjBwR/msTPRssS7+qRB0QZ9wdZ8R5+CXB6nSaJmLP8Jz83dlkCpaxaumgIRTQZwOYAuRPSZtKkRvIeb1kmM+OxkCwW9J1oajvZwvZqPEvUpOEcYadh+j7Kt1c185PJYzL0w8zbrYDJ5NK/1vGv2HEFRaQind29uOsZkPgrbDzQzl8d9u/xYDaGtN+KVc9K6aFrSenF9HxEiETY9A9LTXET31/7/w4zVWJN7FFee1gmndGyCkvKIvn/svpUJGTU3ntH11nEKvgoLBXFyb/sXloQM/4UYhxPh+NqQHF6970iJJfRXLg+jUXoAhaUhnCgLo5nlPAu25mPqR1pak1tHd/dW6BpGPE1hEbQIoU36/+LvTgA1ftRxVeCmKZSUh7FFV0vfWLTL0/mEKaW03N5BakX+KOXe2MhHv8WbDtcUe9kNwJKJN2gnbOpBJaApmPwSZsnz98/NyfjcPuaJz32PyyVfhXFO2XwUZnsTn9w4xmnYZU2NiPQ5FbRyV0ZTlMvl6FOImBPiRdgsSP0Wn4J4J4aZK2TVFKL7JkdTsBdshSXlpsGdFZ3QLdEBcLZ+sAjHndtB1lit2qU5CSHQSPcr2E38s3ynt76yXOd+PlqCA8cqlxo8mcTLkrqbmecx82nM/J30t4qZq2aC3RqK4cRyUW/v/ngd3l++x3E7ABw9UY6/ffKjYRaRbdZOA4NM5ZCWZaGw51Ax7nXK66PvFs9ZatdQsalBd+7pun3K8mmtZpN8y3SeFfHZyMc4m4+k/eNpCpYWLS0gCwXLoKcEymvqWTvlPmKzthRmNo1E9/vMmgJbhYLe1Raags/kU9D/l6739Yb9+GCFe511ugf5FqyTLFXcp5CY+cg6CREA5B0pjvEZWJHNkuFIxFSf2dL5aZQRBAD79DMe71Ouc8Mf/gbDHvrG03GAlh7lb5/8GNf0WlG8ZkmdRERbiegoER0jokIiqvzonTqAW0/RLnOklSfmbMbbS3bj41Va9ILcw7Mb5JVfWIrO02bj3aVaugLb3rxLI5d7+ASW7tB6M+VxPjhmO19BdDlsY791+u1UPmtjaD1OPF8vSfyix0g+hXAkrnkoXmfU2ssN+skwvVm1rUR6tp40BTY7miMWIafNpxAbxST7poCopmDSkGw0hevfWoG7PnSeP4uZ8dmavUYj6uSQ/b8Zq03HfbPpADpPm51wBgBRxbxmSTXNYa0vPv1N/HQ0crlCFhOdVWsQmoKYVlbGq0Zk977nbjpgs2csz327DW8v2Y13lu6Ov3MF8OpofhTAL5m5MTNnM3MjZs5OSYlqCeKVuvVkvXQaRaMnPigxKK40FImG+0k1dPdBbZjIhyu13pxceVfuPoyRj36L/cfMvW2ZMY99h7wjWj6meOYja1ghYDUfRZdjG16v5iN3DUP0vBOZGEh+J4eKyuKaweIJDWsv16QpWPwyTg7jg8dj30nY5TlEyxa9dzGi2WwytPcTWM1HQlMI26QmSSTsc/H2g7j9vR+McG0nh6xT3U90rmXx/pfvOmx0hNz4YEUurn5Ni2ZPJN12sUlTYMcxOJEIIzvTWVPwOgWp3fteKUXoJXpsMvEqFPYzc83O4lRNuAkFL5XSqm0KoVBSHs1oaTcXspHQTTr2naU/Yc+hYgx/2FkVlSOO4plm5FQF8rro8W4J8dzOG122mges5peopqCfN8EZ3W5+Z5VtA2WO949jPrITCuEIvt9WgC/W7TNtC0XsHduDH/g6Zp25EXXTFIT5iBC2DArTzEexfoI04ZuyaApW+ziQ2OBckTrigN7xiJcOwkqiZiT5Xd79n/jzUrz43XZ8t0VLf5OIO8KqKZjrqFl4Z7toCl5vL2zTeejSvIHH0qYWr+MUVhDRDACfADC6PMz8cSoKVdNZtK3AqERuUtsa3GONl7ZDRBDJk7/IDZio6NFUFanrNWimCmdVQb6/RBPiaSYYjtFWYmz0xg3rQlBoT67P3SLIbPZ1i4CKwfLKhKN5io2TOxyJvSfncpqPs4MBydGsvW/5UYvpOAXiXtMdNAW7nn0idnvxfkTqD29jLRLbR6YymVYTOdLq3zH7FLT/xbN18ikwxw99Fcj1PDsjgGMloeRklU0CXjWFbGhZUs9BdJ7m81NVqJrMzoIiXP7KUuPDd9UULC/Z2lgs2laAfy+JqsT5haW4T4++kYfdy4Ln30s0O2Jl5ln2SoRj789sB3ebT8G+YEWlIZSWRwyb97WvL0eBZFqxtk///HYbQuFIzMdm9YcckVJ9e5lPweyQTOwhZqUFHOe4KCmP4GCRs/luxvKf8PB/N8aUy9nRbA5J1RzNUayOZtGwiPEUpZZxCtb5GAAtP5RXRB0WQQ12jacbzjPMOWhKlTGVJHCofB+yli5vE2UXPoUDheb37CX0VWD3vr3ea6plhyehwMzX2vxdl9qi1UyOWOYZcPcpuPeC5XBKhjli47B0Hfkan63ZCyBqu5Sv0S4nM17xEyIcic2J7zXNhdNjOfne/yHvSLFh8/75WAleWbDT2C5izL+58yxj3Z+l6SzFaeVncu+nP2Lg3+dgoT562mrntyuLm7M7HllpflvTAQDc9t4qnPbwt7bbfvjpMKZ+tA4vfbdDL1f8MkQ4NiGeeapIsgg4y/H6NtHwy/0S8W6taaPdED6ToJ6QKZKgcBXBC28v2W3yszjdf0Xt54m+U3n3pTsP2WqS4pwN0jWh8M9vt1mi8SKes9DK92XkIqtNmgIRnURE34hZ1IioPxH9NbVFqz6+Wu+cc94ub7zzvubf5SGXl85sGky25edC5Os5adzi7OXiJNuUFGEGR2LXGcsR+2UgfidNTskhD7oLRRi922SjW4uGxrqPVuVGe2D69WWt6019sprVew7HbAMcemWJmI8sNEwPoMhBU1i+67DjcRv3WVIpyFqXq09BW/b7SG9Uo9t9RKY03uJe2dKQCU1BvqYwLSUyOltoh2vzjqLztNnYezQaX+/0HJs3TDeVb+O+Qvztkx/xJynKyanxjzfAErCv96FIJCFHs1yvj5eEbOt5NGuxfc4qbe4Lb9fzoimUlIfR+29f4nO9I1hVeDUf/QvAnwGUAwAzr4U2U1qd5Ik5ztNsWqNL3HoyVgESL1+O/AEUlYWNlMJ21xD1Uq74ZR5t2V6JcKymUG7KK+SsKcQTULJQ8Jk+sojtyGyhGYnyWLUBAPhi3c/4eFVuTENi9wGaHa6JPbcG6QHHFAduWJPCmXrtljK+tXgX5m46AGbzJDux6SPM03rGZCu1aANhG6FQajNhkBPi/W/cd8x0DrtrC7pKDtRwhI3yfrPJnBbD9noWgXXfZ+uxI/+4aZ3dVLdhS1hpPOR9Q5GIqT6Lei7KGPARLh7UHu1yMmNyhVUm+sj6DA4VlaG4PIwHZpsHdCYi7CqCV6GQxczWrKV1dvCaW0ZHq6rt5qSzVsp4vR4nB6VtQjfEOvrc0gxv2HsMq35y7sXaYedTEJEd1nJZhcCxOCnF5We8bGd0PEcowqb5CwSiB/bc3O0x1xZs2HcMf5i5JuY5f7QqdjrTUinaJN5nbN3eIN2P4xbz0bUjOsc5S9TOL3AzYd3z6Xpc+4aWzdM8HadlnIJ13mYHTVY03rIwLDP8DYk7mu1w6h/5fPI+bDtWwaum8MaiXXhgtjkQUggo83HuTae1V27NQyW/GxH1JJ6ljwh+X2zSv3CEPWsKcqdGHGP9/MV7t2py0diLSmQydMGrUCggom7QrQJEdAm0SXLqDGWhiDFxityLtTZ21uRpW/YfN/a79vVlmLU2qurF+BTCjJ0FRY69aCehYdcA7jtarBdQOt7m4z7nye9QHo5g/DMLMOn5Rbbnd8Jqv3Yrl7WIe/WxEE6kSc94yY5DGPP4PJSUhxEKs6Ep9GvXGIC9KarcRUOzPke752rKn5/gt9UgLVZTGChlCPVCxKZBYeaYXjAQbTR8RFi68xBe+36nsc1vnbfZaj6yjEWwS0ZoZz5yqqdumrFTvQ5IUiHC9kLIyclaavPuOjQx+86cAgnctFW3YIRQxD41iljn9xH8Pl9Mfie3xHtfrf8ZQ6SwZOukPkDsM3AaIClIjUjwLhRuBfASgF5ElAfg9wBuTlGZqhxmxkl//S9GPjoXRaUhU4/OWnmsvZwPV+ZiV0ERQhHG3M35+N27PxjbrJV15U+HMPqxeXjt+1225XASCna9s10HTyAcYdNHY9dQbtl/HAcrmC+fbcYpmMulbSspD+Mhy2Tk+YXOETgAEAyYq/SO/CLsLChCOMJGI9KrdSPna7toXVYz2oKtBejWwhwDfvhExecQaJAeiPmoG6Z7je7WKLeYKEpDYQx98BuMefw7LNpWYNpX9ilYsa6LcfhbTB8rdh/Gat0sKSKo7Brp0Y/Nw6sLd8asdx9/wrZl9Fls8E6awopdhzDTkhbGzg/XLkYoxJYlFI54mifc7hzaKPjYY4QA8PkIAV1Dk8cbhCMcM6ZFcOfMNaYoOzlQQRwRa6pN3OeTDLxGH+1g5l8AaAGgFzOfwcy7UlqyKiRP6tUWl4dNmoLsQ8g9fMI2dUX+8VLbkazWiiW0ih8czDhOPQKnkMFjxeUoLQ9jZI/m+vH29ni73qcXrOqx3XYAeHPRLmywUeHd8Ptiq15awIdQJGJvPrL8dhsLID6is/u0MtbJ8yEDlRMKdgIg4HEuC0F52KyFzVi+x2g0th4wvy/xrOwyjVoboQ9X5uKr9T8bdmchO+XHdeFzWv7/Il1TcPIp2I2wdTOBRjhWW7hhZBdTnVywNR93WCa00crJuOTFxfjTR+YUG3bXcxJ8MiGL78XKk3O2oPO02WDWfBxyJ6Y8wli5OzaxnfjG0/wEv48QCkdMYalDH/wa7y+3H3VtLYkc0izPhCgj6nhZOIIb31qBYyXlmLl8j+fkmhXFa/TRQ0SUw8xFzFxIRE2I6IGUlqwKMWWZjLBJKMjx8Bf8c6FtgruPV+ViqqUyM3OMhBfmHTtbIMP5g3Oy+R4pLkdJeRhZaWKaS/uJduwyiXohwu5OWKEpVKQnY2fqCvgIoYh9b9P6yNyElXiOsoMzK2huyA8XRc1H8RyS1veVlR47KZCXnDeycC8PmSf/cZvTQfhf7K5h96w+WpVr3NPPx4rx65cWo8BGcxM9dqf3F298h935rJtvH9vD9H05zVDmFH1lVzahbQiHtd2xduHUMi/N32Hsd+s7qwAAp3TMQa/WjZBfWIo1lgmogGi9Cvh88OuawgXPmucy355fFHOcHcdLQ/hszV787ZMfjXWxQiF6719t2I/3l/0UIzRTgdfuzXnMfET8YObDAManpETVgPxhlYUiaJWdYfwWvYPt+cdx2DKPq+C9ZXuM8QMCu7TV1pQNMpEIOwqFXQeLbPO+HDlRhpLyCLLSog1eRSczscMuzYWMcLJ7zZX/08HopPJ2kVgRhu5TiJ0X2towu/VYhcBpIPXoM1w0hURj2u00BS/pG0qkHnm5JVGf2/0IoWB3DTutqkF6wGgQ31u2B0t3HjJpw9ZrOnU6mLWkjgu25kvHOD+rd2zqaFZawKQpONUVu7QPchlN+0YYYx//Dv3v+8r4bXecUx4qmZAeIgsAbRpnxGiUdmUJBnya+cim4yezq6AIH66MDXIAtE7A7e/9gLeXRCOnwhHG+8t+Qu7hE6brCY4Vm/1YKfIzexYKfiIygo2JKBNAusv+tQr54ywNRdBeslmGwhFc+/oyY2JwmZPbOucE/HpjbMZD4Ruw+y7C7PzBLdhagLv/s86U+gLQNYVQ2FSRvcqExnpSLze0SBe3HjnjRFkI6/fG9qqAWFPChH8uMJYHtM9By0bmKhSOsGY+8nATbg5P8TFlSc8lM2iu6rJpJBxhrPrpsDm80uX8DdJihYKXSBA51XFZOGK6hlsEUJo/mvsodlvsJ9wgLeBJ0In65igUAFz28hJc+Wo08NDNl2MlPaD1qP2S4HISnnInQY6Ss3M0r9lzxCTk7KpovCAJeT9h3LE+318P6WAsL91xEGW6fyPoI0NTcOPC57/HHz9YY+vwlgMVRDlX/XQY0z5eh8v/pWn21vYg1aGoAq9C4R0A3xDRb4joNwDmAHgzdcWqWuSX+/hXm01+g3/M3oi5m/NjjvngptPw0c2nO57Tzk4rei52H3c4EokbsmqtXKXlEZSUh9FAavy8aAozbhyOzs2yTOtaS9pRtEwck79Jpiwcwe/e/QFfrLMf7GdtbAqlMNXGmUEs+8svTNsjzJr5yCUkNVo2d0dzmt9n5P8BEDMPtCxUdh8qwqTnF+GeT6Oq/FKXyVLszEdenrv8fjWfQlSIywLJ+p4NTcHma7ULn85K83sUCu6OTFPsvr5vIiOMhaaWLo9JcRIKUhkmPb8I2w5ovXc7M6M8viG/sNT2XkMR9lRWOU22j8h0z2kBnxFq/OuXl+ADPTNx0K8Ju3jnFxFuoQjHBCbI5kJRfjGf+U+HTug5tOxDUVONV0fzIwAeBNBb//sHMz+ayoJVJXL78t8ffzZeDgDH0YQD2uc49mhnLP8pRtUDpMnTbY4JuZiPrMdHf0dQUh5BZlAWCvFfaVDvwclkZ8b2fudtznd1UpeHIljm0ni6pUkWl//D2ScZ64RjO+ipgXXXFNICPlODme4w9qRN4wyjB79Y6gxM/tcSx/NnBCvoUwjJQiGCsB6tQ2TeZjVFpvm169kJHjsfknXsghMhQ1Ow92d8vXG/sTz+GU3LkyPh2uVkYvKwjo7nF/VSfg9O1dNahj2HRXp3929i6INf40ubDAShsLujWRCORPvfhNhJq+SyH9YzxAZ0R7PXRvrzNXtj3oc8It6unFsPFMaYWK17pSok1XMcHTP/F8B/U1SOaqUiOUcClkRkMmKO1pjr6B/Uxz/kmUahAkBBYZkp/twO6wciGrP0oB8+0mzyXoJg7EwO1p40oA0Ucot0KA9HXAczuY36Fbbl28f2MEaQhyOMUJhtBZt1pKibvbg8HEHQTybfRLpkPmreMN2I9An6fcbHbTXPORG0K58H85H8kYtJlLTeqfleVv10xPQ76mj2JhTiRY0JxLvzkhBPRM7Jzz0j6MPDk/rhvWX2ETdCEMtltPNtAMD8LeYw3GP6uyiMMwjSiVAk4um7ttZf6/S2spZToId2p/l9nudDB4A/zFwTs26n5JC2e1Vb9x/Hbe/9YCmb50tWipTNvEZErxHRAZEvSV/XlIjm6OeaQ0RN9PVERM8Q0TYiWktEgyp3W4lRkSkffZY89l6QxxFYfQ6LthdYd4893iIURE88PeAzGgwvDs+g3xfT08606f3GL4974+NmJ7crpmY+isSM/LXuX1Iexv2fO0w1CiEUfKZjZKGXIQmIgJ+McnoVCnbOXS/mI9lEIkImncwpMlHzkY1PwUYDKikPx63TWmCDrikk4CeQ6401IEAgEjOKssll3HPIXig8+bU5tcyxkhBKysNYmeAofEHIMobACbdBbn4fIV36Lhbq40cCfp8njdyNrzZEtTA74WU3RiRm7pEUCYlUzrz2BoBxlnXTAHzDzD0AfKP/BoDzAPTQ/24E8ILHciWFXzwR60ROBW5OOi+9gBhNQZrX2UiF4KFxCvopxgmXHky8kpeFI652VbceqCy8Xpii9QFChqbgfg//XrI7JpZ/4sC20XKFtLBiucGV/S6yKSnN7zNMF07vwFoaO6HlI2DV3852TZEiC4WwPnjNS4dTaHZ2Aj/Npiyl5ZG4eba63v2FbbniITdMdsIRiKb8EBqC2zNxvE44gs0/F1a4d7xp3zFTsj4nQlI6DEZsskE7rTroJ08auVfszEdigKHMvxaYBUWiObu84tV8lPDMa8w8n4g6W1ZPBDBKX34TwDwAU/X1b7EmspcQUQ4RtWHmlKfSMHLD5O8Gl50wbaNgBtJadtG2H9gJLo9WssWLmyI7OyoXy/ZvB4fMA6J8GQ0RbKZFMJTu24q9wZ9Rmhft+fgysxFs2g4AcPSnDSgtMDd0vqwcBJu00cY87N2E5UvTUZoXfQ07d2ppphEJo3TvRpSFIig6noFS/WPwN2qOQHYLcLgcZT9vM45buyoLB3dsQqi8AQKNmiFSXooju340yjagQw7W7DmCQE5r+Bs0QaSsGOX5u2Ke3fGmvcEMREqLUF4Qa0LIP9hbe8bFhQgdMofm5W4+jqOntUHjxo1RXnQEpXkbsXpFAEd3b8S+tP1YvPg4yvTHHS46jG0/rkJpnha+N3f+QZTmHUCwZVf4gukIFR7E/m0FKM3TAgJ+ysxHcX4RQiHt3YWO5WP/thPG8cWlDVBaUIS0NichK82PY/l7UXpIO3bx4qba+8rbiPR2Wvl/zt2FxWXR8Sn7jhSjdO9mpLftCQAoP5SHtauWo6hFQ9w/PIg/zFgN+AJIb9ND216wB5HS43jt4+i7W74iHUcjLRDw+1CWv8O17u3euhE44Mf+bVtRmqdpmJSWhbQWnRD0+2Lq3lt5G9GmZXMg2EK7l31bgYjZDCPXvdK9m2FNh2ute+LZ7Nm8GaV5BfA3bIpAhxyEQiFTnQz6fdi1oQShY4VI69QEZWVlyNu8BqV50efnJwIatUCgUTP8fnQnPPLvL2Hlb+8fdq17gSZt4c9q7Fj37p5xHP6MhrZ1DwCCzTvCl94A+w8cQNGeDSgtCWFfZj4OHS1GaX4Rgi06w+8Dio8dNN0fAKxfnYZwg/YAgFDhQYSPxUYaprXuDvIHETqWj3BhrBUgrc1JIJ8foaP7UXo81i8n6l754X2InDhi3kg+pLftWSELhye0mZzc/wA8DWAGgMkAJok/D8d1BvCj9PuItEziN4BZAM6Qtn0DYEi88w8ePJgrSiQS4Q8++IALi0u509RZnN6hr4hNM/7SWnfnTlNncaepszitVbeY7aNGjTK2B5q0jdme2X2Ysd3foEnM9qzeZ0W3p2XGbG84YBx3mjqLO/7p85htADh76EXcaeosfv3b9bbbG4+4nDtNncXtbnnTdnuT0b/hTlNncdvrX7Td3vTc33GnqbO49VVP2m7vOfkv3GnqLG512UO22x956R3uNHUWn3bTdNvt8+bNY2bmex63v/4V09/jTlNncdNzb7Xd3vaGl7jT1FmcM+o62+2vz1nFnabO4sanT7Y//wvz+LKXFnOjIRNtt4t384uLLo/ZRmmZxvas3mfGbPc3bGpsz+w2NGZ7oGk77jR1Fg/+x1dx616vvv1jtqd37Medps7i+VsOVLruUTCjQnVv0vPf89GjRx3r3q9fWsR5eXm22/tO0urWnEUrK1T3ml9wl2vda3HxPdxp6ixuMelvtttbTX6YO02dxY8//4rt9tZXP8WP/28T/2aq/fmnv/eNa91rd+tbrnWvw/99wJ2mzopb9xoOONex7j03d2uF2z8AK5zaVa+aQjaiM68JGMDHHo+PgZmZiDjR44joRmgmJnTs6Bz5EI+VK1fi0ksvxStv/BtADpqMuhaREktPPT0attnkFzeZenNv/eZUNG3aFJd+pPUSmp13O7jcPGrUl9XYWG5+wV3o1TLTlNHR37CJsTzwugew56AlvUGj5sZyy0vvx93je5tyDAUaa2kcsrKy0PLS+wFo9lzhzAs0aaOdJ7ORsR0AnpsyCA/N3ogD/mbGdcb98Rms2n0Yo3u1xLknt8a0j9Yi2Fx7vsGmbU3HG+Vrp/WEgy07227vdnJ/YMduNO/SN2b7r4Z0QL9+/QAAQ08/Ay0vvR/TzuuFx7/agrP7tMJlwzpi1s8NgcNHkNl1CG56+FV8bMl26m+olT+r5+k454whmKeHDp/SMQeHisqR3TgHwF406Dsat18+3pjcpk/bbGzYewyZGRk4EQIaDRyHzC6aCWvaeb3Qu022Mfk7AEyYfB3++NurjN+Hi8pwx8zoyNLGwy/B03/7PTo0zcKBYyX44wdrQIHoOJDGZ0xBo0HmiQopqI3R8Psobt2756HH0TQtjFcX7MB3W/JxRvcWWJSnqVFBv89T3eOw2V8i170Wk/4KRMzRP9a6B2h1/sk5m/HDT0cQaNwKAR+Z6h6g+aYuP7Uj3lxfgrSAH02bNsUd/+91kzM6LeDHR3+fjGBOK6C8xLbuxKt7QV2Lcqp7aa26AQDGnHk65vptjm/RGQAw5PSR6HLFgygqDWFY16YY07MVpv93I4JN2sLnIwwdORaf7zAf/8jF/RFq2QbADmT1PB0Xjh2ODXuPYVdB1Hnsz9DydjXoOxrp7XrFXJ8CmpYv1z07Gg3+JboPG2tOMOnTTKGVmpXOBU9CgZmvTdL19guzEBG1ASD0rjwAHaT92uvr7MryMoCXAWDIkCEVfiqLFy8GAAw6dTiwcZNhCrDjpFYNsQW9TevOPfdcbeGj2QCAjA59Xa+X0ak/mnbMQWbmEdvt2d0HIbOx/RB5IkJm18FYg5bI7JoVsz09PYjMroMBAC1bN8IhaQY3QKuAYrtW9nPwwraGOJRfhKtO64S3Fu/GiDPGYuPCnegysANGndkNmT9EGzVfegPT8YJQwAeEIvBnZttuz8puBmA3Mho3jdk+4LTeaNpUM9W0at0GmV0HY/CIYQhsboD+w3vg3LNPwpwP1gA4gkB2C/Qc0gOZR7baPp9gTmv0GNwRS8u1hqflSS2QUVyO9HRt7EWwSVucMWow3tqzEgDQuWcL7MzIR1paEKWREILNOhhmvqc3A08M6IvMrtFGcsKZw9CjVTQ538HjpchcJvklWnbFWWPORI9WjbDvaDEyV5o/q/TW3W3LDWjOWre6BwDDTzsNXZo3wNfH1iAzlItfnNMLK7/UTDpBv8+oe80bphkRMjIZnfq7nj+z80DHbaLuAVqdfzevCTIDmvAN+AmBQMD0bhtnBjF4RB+8u3cN0vw+ZGRkYOBpZ+GTguicAA3S/Dipe1cAwNETabZ1R+BU9wROdc8oT9PmrtvfXnMMDboNRqQkhI792+D/Lh+Epzdr33TAR2jbvn3M8WPPHm04nYM5rdFnaDeMyc7A3z6NDX4INmmLYJO2MeuN7VLdsyOtRSec3q8NZq+LtaQnEB+QEF6jj9oT0X/0aKIDRPQREbWvwPU+A3C1vnw1gE+l9VfpUUjDARzlFPsTcnNzkZaWhsbNWsXdd1DHJnH3cUM4Jq2hhjJewgKd0lHLIX9eomCCfp8RuTBpUHtseeA89GilzXSmZXqMewoA8fPwi+12p5PLKRzCIvzQLo1EvE6R7ISdvyUfDKBNTnRAninlhR5REtCzXVpZvitq471tTHeTQNCOsx8bANiHiLph57S2Ihy14hHIx8hO86V3mwcDJkqWS4oHgRzCaReB4/eR4YBOC4j/zeeVgyHc0kpYefSSWOF2RvfmNntGifc+5mzYH3UuW+qYzzJOQRDwk2l0esDnwxXDO+HmUd1cr1VRnOpIqhzNXmvw69Aa7rb63+f6OkeI6D0AiwH0JKJcfST0dABnE9FWAL/QfwPAFwB2ANgGbZa3WxK8j4TZu3cv2rZtGzdKA/DW0J7SMcdxm5eGwi6dsJVNFg1A4PcRbjpLq5ABH+GP55xku58gze8zKlRm0G+KXnJKSPeL3mbh6ZYm44rhmuov8gvFi7oU1xNjNxrYCIX5W2JHlZvPYX7Ga/YcMQlz+R2IhpSIbKO15Jh5u7Bju6gb8fzs3vVzlzubB7zULREBI96ZLMgyTAMXKzecqUlWmuv2B2dvwPfbogP8xNW+ufMsYz4JH0UbzC56QkJrwypHhSUSmWTXOLbMds+2Yxc9ZMVpkKWf7IVCesCP3QejWn1AD09v0dC9LBXF6RlVt1BowcyvM3NI/3sDWhptR5h5MjO3YeYgM7dn5leZ+SAzj2XmHsz8C2Y+pO/LzHwrM3dj5n7MvKKS9xWX/fv3o2XLlliwJf74AC8DVf58Xm/HbV4qfiKzX1kJ+sn4YPq1b4zfjelhpNO2w+eLhqRaY+AjkdiEdIDWY5bp3rJhzD4Ccfz9n2smg3hTFIrnKwYsNbBJI2EXoifIyQo6ajd2cxHIDanduzUmMAJsY9jthYL2v7UR6t6yIXq6zAvhpcNgaAosrh89plWcRjERcrKcBX1G0BcTEino1qIhWjQSPhJgfP82uHt8L9w+VvM5WcfAVFR22Y3paG7TEMvXS0ToWHMLWQevCdIDPvRrn2P8Fu/Drt4mA6d7SFX0kdcndpCIriAiv/53BYDYiQVqEdOnT0dBv8vx4BfxI229DFRpmB7AqV2a2m7z0lsRmsINI7vg/9moyfHKJ3pn7Ztk6evcvzxhBRBmF5EZtmPTLMfJXJ6+bCDG9mqJiQPbYnCnypnUZKzmI5FwrlPTWP+JlQ1/PxdL/jzWURsR342dyYVgP65D/tbsOmN2I5qjmkL0fL8c0BbPXHaKq4nIKdZfRpRXCHL5fIlO7mNFPpebpmCXBFBGlMNPhOyMIG48s5sxYNBqlqqoRmMnFJo1iC3zGVKHKFFznvV69pqCDxcPamcIH9GxsNNwk4HTIEFrQslk4fWJXQfgVwB+hjYN5yUAkuV8rhYGDRqEcHNnB6CMlw83YDMgTOCltyIGgV02rGNcNd5K0EdGWuYMl5QIMreM1sxNooc3ontzvHHtUNw2todt79lHhIkD2+HVa4bi6ctOcZ3q0NqDsSuKfLjVfCQSzt0yOv77yUoLICPojzvIKRFNQcbundpOdqOvk6/zzORT0Kdttmsj6PTBywQN85H5N1CxeXqnT+pnLLdsFPW7XHlaJ8djDhbFOrDlJyPMOHblsQqFis4tbPccm9oIBfmdJiIUrK/amvvIOL/fByJCR73TItqHVAkFu07Fi1cMwjUjuqTkel4T4u1m5l8ycwtmbsnMFzKzfcKTWsIXX3yhDdrxgJeejVvWxERU2IBDRYx37eIyresvHHd2RX7xisF467phAIApp3bCrukTTI6+UT1baiOBPUz7aE2TkR7wGVNeWvPJxPcpaP+L+SqEv8LvIyz581j3g3XiadLmPEj6PZMHjcqjhi40LlsfhEvD78U0aZj2hE+hksNp5bQKsk3+9G7N8NBF/ewOiYsQLnb2eWsCQadbHhBnnmu74+I5qq3TvrrhVSgIGmVoQkC8w3ham9d8SQ9P6ocVf40GDdhZKuxylSULr9FHbxJRjvS7CRG9lrJSVQG33XYbCld+7mnfIw6T68gEfGTkfLHixXxknMfvs+39xOPmUd3Qq3UjnNOnNYCopiDPczyub2uceZKrK0grg61QMP9uYVFd/T5C52YNjGUZO5+C/P2Jsh7Uk9TlSJpS68YZnvIyxXO6mTUFn1GIeB/XlFO9jYVx+97dBM8KmykvnRDamTXdhfy+ZJOCaLSsyJFubaU6q80o5rk4Jm2xaQNNkFsTPQKxKVSsWuzqe87G6nvOxo0ju7pez07gNslKw/h+rU3aj4yXXGACO5+C27ebrXdeDJ9CHBPbXee6hx4LJg/raDJR2mkKiURtJYrXKtCfY2deOyUlJaoiSkpKjAEk8fj5qH0oqIzfR3jYoWIm8gIDPkLfdo0xonszz8cwNIfml78/E010gSI+PC+T6Vixnw7TvO7GM80fcLOGaXjysoF48YpBpoYGAM7v3ya2zFKDInrSB/UY+xxLma256O2wCoVzTzZHS8kfVk6m9oyOlYQcU2oDwN8nnowOHvwagHvOqUQyarohFDDxKn45QIt/n/vHUXj3hlMBAJ/97gxj/3svONn2PPL8wM2lDojPB4zu1bJCZcvUpzu1k83WhtUqFHKy0pCTlRZXa/MTmTpM/do1xundmuH5KYNxmUsKb6/EaAoOPgWB6KwIwRMvf5jT/ckO/kcv1vyJpomJbI7zEj5cUbwKBZ/IaApo2U6RQNrtmkhxcbFnoXBEyp7ZpXkDPH7pgJh9Aj4fGmUEbRuAJ3810HO5RAV49eqhuGJ4R1w2NHZgy+YHxuHeC/oYv22doXpldosoccJWU7B8yEG/z6SFtM7OQHZGEOP6tolJaz2ub2s8e7lzH0J0ig4WlSHop7gV3q4ht/oxXrpyiLn80j0JLefwiTLXD/moBw1RIDd0f53QGzNuHG78Tta0iULw+QjY+fB4PH3ZQABAh6ZZOL2b5lxt3TjqI3Dy+xRJMfZZksnDT2TyMQDAraO74av/O9O0zu5+3N6Z8JEJDc3peVjr6nUjuuDq0zqhTxstx5jPpyUd/O1ZWodkXN/WFfZPeMFpnIJAjO0R0WV2WoW8zqlzIJsXR+hOcnnfnq1io9cqktXYK16FwuMAFhPRP4joHwAWQcucWmspttEUnCq2nFL5nD6tcPHg2HF7otGx1tFmDdLQrom9WckOoTZmBP144MJ+tiaAgM+Ha0d0MaKd7D5+MVVoRUY92vVM7Hrr8n53nRsdym/1rTRID7ja1cV5Co6XonXjDMcPXfT2u7aIDYeNZz6Sr99Gbziz0vwx5qM7pUl/znAJ67UiC83rR3bFqV2jmp7XOazjIR4rERl/dkw6pZ3t+haN0hH0Ey6Stme6jHOY0K8N7jq3F06yNEryTGXGedyEQoM0/O/3Z+IRvRfsFARhNb/+dUJv3D+xr/FNiXd46eAO8PsI4/vFaqBW7DLALv7zGNt9rTXI7wPS/c73ddNZ3TD79jMMX4idAGmYEUC7nEw8PKmf4/uSBYAQIvK68/q1wfRJ/Uw+i2o3HzHzW9CS4O3X/yYx89spK1WKYWaU2GgKT/16oO3+4/s6Vz5rnL/1xU8a1C4hu6Z1KkrRwJpmr9J3cTttd73hLLSx8cbDrvK6RXn855bTMUwKx5XTK/9qSHsE/T7XsEy5NzXYZfR4h6ZZ+H+X9Mcb1w4FYB7NKvu2hcNbRm7wurdsiEcv7o8nfjUwxtsxSAq1PSWBkezk8iVlZwRttUsn5PkeZMevk0/BK43SA9j64HhTIy93hKzv/c/jY3P2yMhx+fF6rj1bN0KWbnN3kpFtGpu1FCFMRbi1iO7p3rIhtj803hgc58ZhG22vTWNvnTRrSGpbS/kygn6c3DaaY8pOU8gM+vH9tDGYPKyjY8dFjm50mjvjsmEd8eP95xrfXCo1hURmXtsAYEPcHWsJra96Av4GOaZ11nQGgj+cfRIuP7Uj7v98fYwt/fRuzTBvc77xEt+/cThmLNuDey7oAwaQFfTD5yNcc3pn11nMBFYVU5hierduhDW5RwFEP95erbOxZMchk2NW0Kyhtk6eC7aiLPjTaGMcg4z4aK2VXdYUREigcMb1bZeNDk2y8CvJLJaTlWbMHNeqcex1BNkZQVyqT6a+8e/jTB+TiKj5+8ST8Wsbk5v8XH1ExvVFKO+dZ5+E687o4jhq3O588n3GCwG+eHB7tGuSiS/W7cNbi3e77rv6nnOwePtBzN+aj8slR7d4zvFkwtTzeqEsHMGE/m1w14drAQCTh3XAlFNjQ07tphYVxLsn4UcAvNm4xTtw0pwCfh9+vP9c9L33f6b1og57HZPxt/P7YP6WfBSVhXGoSAte6NW6Udx3a22zDxWVmYTC3LtGuYY+22kKco/eKZLNabQ9ACPs1Sij/n9WHKd2ZahcbFsthYiQ3uYkBLLNTjU/EWb+9rSY/X0+QtucTLx05RA0s4ygfO7yQfjgptMMh+6gjk3wyCX90SA9gIbpAeMDuO+XUaefm+PRai8XDY9oDGXuHt8b795wKvq0jZ3vSPTsvYyxiIdTKgHRaFhNVPKMV0GLOpydEcQLVwxGdkbUfuz3kfHBuI3RkJ9NZprf9DGJjJEN0gK2EUXyc5Cff4nUC22QHvDcA1s0bQz+e8fI6D146L0P79oM91mcv5cN7YBrTu9sWpcR9GN0r5YxjmLxVOM11q2yM/Ds5YNMDcfDk/qjb7vGMfu6NeZO1xEpLeRjvZgzRMfJrfx2Db8wXXodMdw2JxPz/zQagBbJ8+mtI/C+5OPxyuET5aYee3rA7ypE7YSC/IyEpmed11ruVMl1+j+3nI7PfjfCtO+fz+ullyV1TXetdhZXlPLychSu+QrpbU9CWovOeP3aoViz5wjaN8mMMd/Eo0F6AEM7249kdmLbQ+PRedps221WFV7M1mZnfkkL+AwHo5WOTbPw1wm9Ma5vayzZcQi92zinWoiHU1jeqJNaYOXuw2ht0SLkeHPRAIv/3eZWBrTemZWXrhyM37690nUgktAUnFwXAZ8PZ/dphTkb9pt6qiV6eKb42DM8zkDXMjsDLbMzDA3Hq0VHXHvcya3x4pXR7JundWuG37690vXYqE/B27UAYPbtZ2DD3mOO2we6jA2we5Yr/voLzFyxB6v3HDE1eF568VGhEHdXE4ZQSKB33KxhOnZNn5DYhSxehetHdknoaLmzseBPozHy0bmmnGEiGKKhRbgVlUa1eVkI2Zkvrx/ZFdfHCd2tLPVSKJSWluLQl88gZ9R1SGvRGZ2bNcDonprW4CVrZVUiKpKXka8yRGRUnksGewurdDuXHbeO7o6LB7ePCUG9YEBbzFyxBwu2FhhRUMJ8VB6x93x/e+dZ+L8Zq23HBRiCxeXdiOfk1Av1+wjPXT4IR06YhY6IRBL2bLeeoB29Wmdjw75jnuZaFiz7y9iYUOFzT24d97hInHu04+S2jU12bytuIbd21wn6fbhkcHt8sW4frpY0nEYZ8aPcivSBbYmO2BfO4mSOGL5uRBcEA4QNe49hwVb7/GfZHu5JRv5OOjTNwvfTxqCN1GESQt36XItKQ45pz6uDeikUInrDJF6irIrZ5bWpTsqFUKhhwgqImtXs6NK8gSYU9Aa9czOt8fm1jRkM0CKKPpVi7GVCHgSjUMGdYsEDPi0jakuLVnPb2O7o3SYbo3pqg/oSFQr/vv5UrMs7mtAodGvYp8z4fs7CQdSBZI17iHcuO6GQ5vehcWYQs24bGbOtXU5mzKBGma56AEC89CWzbjvD9E3eeGZXvDx/R4XmenbiHj2k+/o3lxvrhBWnTeMMwydXGazRVFGfUOxznX37SGzPPx6zvjqo10JBhIzIDUEwhba6iiAieSqbFrmiJK6Ca4gGXGgIFVPnNYTJyU2LE5qCk23fybmZHvBjgjS4Tgyc85p9tGmDNJzlYZS4F+I9n0cv7o9/LdhhCnetLG5x/naPzO0dLJw62vV83Vs2wo6HxscN0bX6Pu4e3xt3j3fOQiz45+RTXE2Mn946Akt3mvN42jmOF3tMrZIoLI0zGdG9Gb7fdhB3ndsTZ53UAq2yM2yDOaqDei4UtP9MmoJU6Yd1aYozE4hVrwgL/jQaBwpLcPELi223ixxDiZqPqhvxbSZDw8lM007m9tHcdFY3LNp+sNINps9HWHr32DjJvquHltkZ+MuEPvF39MCyu8fGbZy95MCS8TKQLFljNuy4YIDzDGeA5uuy5leSnbypSUQtX0v73+8j/OuqIdh/rNRTWG1VUy+FgjHYS9cUZKEgO1XtIpEqwwc3nWacv2WjdBSWhNChaZZjIj1A9inUxGbKGfHxx5tLwQuje7bEAxf2xcWDnCf7O6VjE6y779xKXwtwFz51BasZTYZI60HbmY9SOYK4OpC/PKcR4O9ef6pt2LcTThNuyeajrLQAujSvmc1vzSxVimncuDF63voSOrVvh7P6dzVlnUxlpZejlL6fNsZQXd1U8nI9+ijgJ7xy1ZAaY3eMh0i6lgzHPRHhiuHOaZ3deP/G4Vjo4EhU2BP0+VAWjlR4MpzahOiPNW+Yhn9caD/P+ulxpvyU2fzAOEcTZgd9rhMv84RUJ/VSKAQCAQSbdcKIkzt4slWmAtn2KZbtwvrk6KNRPZvjF4g/p3RNQKQGqUhCvmQyvGszDE+iDb4+0DI7HbmHi+POUVEXENrB478aaExQVRncsu5OGtQObXIycFoNr4+1y1CdJIqKirB/8cco+GmL7fZEUl0nA+HothuJO7KH5sS0jmxMNa9cNQQf3Vxx85kQComo3YqawXs3DMc/LuxrCgEd0N45rLU2I6atrYrvi4hwerfmNd4ER24zaNV0hgwZwitWJD6d8759+9C2bVtMuu0+fPTMvTHbi0pDiDB7ir1OFgeOlaB5w/QYR1wkwig4XupqA66JbDtQiPs/34CXrhyc0iH5isojBlK6RT+VlIdRUh6uc0KemZFfWPu+r8pCRCuZeYjdtnr5tZbr+W4CDqpeqqbVc8OpUtrF1tcGurdshLd/c2p1F0ORJDKC7ikeaitEtfP7SiX10nxUFtJGVgZc0uIqFApFfaRaNAUi2gWgEEAYQIiZh+gT98wA0BnALgC/0md4SzrhUPUOCFMoFIqaSnVqCqOZeaBk15oG4Btm7gHgG/13ShCjhH21bECYQqFQpJqa1CpOBPCmvvwmgAtTdaE27dqh3c2vYcio81J1CYVCoaiVVJejmQF8RUQM4CVmfhlAK2bep2//GbAPyCeiGwHcCAAdO1Zssm6fL4BAdktkNoid1lGhqG8smjYm7nSmivpDdWkKZzDzIADnAbiViEwzg7MWJ2tbS5n5ZWYewsxDWrSoWCKygoICHFn0Pvbt3Fyh4xWKukTbnMykDNxS1A2qRSgwc57+/wEA/wEwDMB+ImoDAPr/B1J1/fyCAhxd8G/k7bAfvKZQKBT1lSoXCkTUgIgaiWUA5wD4EcBnAK7Wd7sawKepKkMooo1T8FXxyGWFQqGo6VSHT6EVgP/oQ70DAN5l5i+JaDmAmUT0GwC7AfwqVQUI60nmEpnBSqFQKOoDVS4UmHkHgAE26w8CSM3sFhbEfAq1bY4ChUKhSDX1slUMhdU4BYVCobCjXuY+6tGzN9rf8T6GnGmbD0qhUCjqLfWyq0w+H/wZDZGe7m0eXoVCoagv1EuhkJeXh8PzXkfezq3VXRSFQqGoUdRLoXBg/884tvQj7M/7qbqLolAoFDWKeikUQvp8Cn7laFYoFAoT9bJVFFlSlVBQKBQKM/WyVYxEtLRKfjWiWaFQKEzUy1YxFNbMRzV9Am2FQqGoaurlOIUBg09Fx7s+xZDTh1Z3URQKhaJGUS81BQZAPj8CgXp5+wqFQuFIvWwVd27fioNfPY/cXTuquygKhUJRo6iXQmH/vr04/sMXOFyQsikbFAqFolZSL4VCSGVJVSgUClvqZatozKfgU9FHCoVCIVM/hYIYvOb3V3NJFAqFomZRL4UCgUCBNCUUFAqFwkK9FAqDR5yFjnd+jAGD1HwKCoVCIVMvhYKe5UKNaFYoFAoL9VIobFq3BgWzHse+PburuygKhUJRo6iXQmH/vjwUrZ+LosKj1V0UhUKhqFHUS6EQYZUlVaFQKOyoca0iEY0jos1EtI2IpqXiGmGVJVWhUChsqVFCgYj8AJ4DcB6APgAmE1GfZF9HzKcQUCGpCoVCYaJGCQUAwwBsY+YdzFwG4H0AE5N9EX8gCF9WY6QFg8k+tUKhUNRqatp8Cu0A7JF+5wI4Vd6BiG4EcCMAdOzYsUIXmTjxAhxs1g8D+/euYDEVCoWiblLThEJcmPllAC8DwJAhQ7gi5xjcqSkGd2qa1HIpFApFXaCmmY/yAHSQfrfX1ykUCoWiCqhpQmE5gB5E1IWI0gBcBuCzai6TQqFQ1BtqlPmImUNE9DsA/wPgB/AaM6+v5mIpFApFvaFGCQUAYOYvAHxR3eVQKBSK+khNMx8pFAqFohpRQkGhUCgUBkooKBQKhcJACQWFQqFQGBBzhcZ/1QiIKB9ARSdFaA6gIInFqQ2oe64fqHuuH1Tmnjsxcwu7DbVaKFQGIlrBzPVqPk51z/UDdc/1g1TdszIfKRQKhcJACQWFQqFQGNRnofBydRegGlD3XD9Q91w/SMk911ufgkKhUChiqc+agkKhUCgsKKGgUCgUCoN6KRSIaBwRbSaibUQ0rbrLkwqIqAMRzSWiDUS0noju0Nc3JaI5RLRV/79JdZc1mRCRn4h+IKJZ+u8uRLRUf9cz9JTsdQYiyiGiD4loExFtJKLT6sE7/j+9Tv9IRO8RUUZde89E9BoRHSCiH6V1tu+VNJ7R730tEQ2qzLXrnVAgIj+A5wCcB6APgMlE1Kd6S5USQgDuZOY+AIYDuFW/z2kAvmHmHgC+0X/XJe4AsFH6/QiAJ5m5O4DDAH5TLaVKHU8D+JKZewEYAO3e6+w7JqJ2AG4HMISZ+0JLsX8Z6t57fgPAOMs6p/d6HoAe+t+NAF6ozIXrnVAAMAzANmbewcxlAN4HMLGay5R0mHkfM6/SlwuhNRbtoN3rm/pubwK4sFoKmAKIqD2ACQBe0X8TgDEAPtR3qWv32xjAmQBeBQBmLmPmI6jD71gnACCTiAIAsgDsQx17z8w8H8Ahy2qn9zoRwFussQRADhG1qei166NQaAdgj/Q7V19XZyGizgBOAbAUQCtm3qdv+hlAq+oqVwp4CsCfAET0380AHGHmkP67rr3rLgDyAbyum8xeIaIGqMPvmJnzADwG4CdowuAogJWo2+9Z4PRek9qm1UehUK8gooYAPgLwe2Y+Jm9jLR65TsQkE9H5AA4w88rqLksVEgAwCMALzHwKgCJYTEV16R0DgG5HnwhNILYF0ACxZpY6Tyrfa30UCnkAOki/2+vr6hxEFIQmEN5h5o/11fuFaqn/f6C6ypdkRgD4JRHtgmYSHAPN3p6jmxmAuveucwHkMvNS/feH0IREXX3HAPALADuZOZ+ZywF8DO3d1+X3LHB6r0lt0+qjUFgOoIcerZAGzUn1WTWXKeno9vRXAWxk5iekTZ8BuFpfvhrAp1VdtlTAzH9m5vbM3BnaO/2WmacAmAvgEn23OnO/AMDMPwPYQ0Q99VVjAWxAHX3HOj8BGE5EWXodF/dcZ9+zhNN7/QzAVXoU0nAARyUzU8LUyxHNRDQemv3ZD+A1Zn6wekuUfIjoDAALAKxD1MZ+NzS/wkwAHaGlHf8VM1sdWrUaIhoF4I/MfD4RdYWmOTQF8AOAK5i5tBqLl1SIaCA0x3oagB0AroXW2auz75iI7gfwa2gRdj8AuB6aDb3OvGcieg/AKGjpsfcDuBfAJ7B5r7pwfBaaGe0EgGuZeUWFr10fhYJCoVAo7KmP5iOFQqFQOKCEgkKhUCgMlFBQKBQKhYESCgqFQqEwUEJBoVAoFAZKKCgUCaBnJb1FX25LRB/GO0ahqE2okFSFIgH0PFKz9AydCkWdIxB/F4VCITEdQDciWg1gK4DezNyXiK6BlrWyAbQUxo9BG1B2JYBSAOP1gUbdoKVubwFtoNENzLypqm9CoXBCmY8UisSYBmA7Mw8EcJdlW18AkwAMBfAggBN6orrFAK7S93kZwG3MPBjAHwE8XxWFVii8ojQFhSJ5zNXnrigkoqMAPtfXrwPQX89YezqAD7TMBACA9KovpkLhjBIKCkXykHPtRKTfEWjfmg9a3v+BVVwuhcIzynykUCRGIYBGFTlQn89iJxFdChhz6w5IZuEUisqihIJCkQDMfBDA9/qE6v+vAqeYAuA3RLQGwHrUwalgFbUbFZKqUCgUCgOlKSgUCoXCQAkFhUKhUBgooaBQKBQKAyUUFAqFQmGghIJCoVAoDJRQUCgUCoWBEgoKhUKhMPj/CcQGxgzQgQMAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -156,18 +103,16 @@ " return dydt\n", "\n", "x_0 = [0]\n", - "times = np.linspace(0, 100, 100)\n", + "times = np.linspace(0, 100, 1000)\n", "\n", "from scipy.integrate import odeint\n", "sol = odeint(pend, x_0, times)\n", "\n", - "for i in range(3):\n", - " values = model.simulate(k, times)\n", - " plt.step(times, values)\n", " \n", - "plt.title('stochastic degradation across different iterations')\n", + "plt.title('Schlogl\\'s system')\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", + "plt.plot(times, values, label='stochastic simulation')\n", "plt.plot(times, sol,'--', color='black', label='ode solution')\n", "plt.legend()\n", "plt.show()" From 1e6227b0b7b7a70c6fdd49a9d8db482965fafd6d Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 20:51:50 +0000 Subject: [PATCH 28/41] docs fix --- ...hastic_schlogl_model copy.rst => stochastic_schlogl_model.rst} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/source/toy/stochastic/{stochastic_schlogl_model copy.rst => stochastic_schlogl_model.rst} (100%) diff --git a/docs/source/toy/stochastic/stochastic_schlogl_model copy.rst b/docs/source/toy/stochastic/stochastic_schlogl_model.rst similarity index 100% rename from docs/source/toy/stochastic/stochastic_schlogl_model copy.rst rename to docs/source/toy/stochastic/stochastic_schlogl_model.rst From 2c27265515a09538a12d5c6e51e418a15e6719cf Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 20:53:44 +0000 Subject: [PATCH 29/41] more docs fix --- docs/source/toy/stochastic/index.rst | 1 + docs/source/toy/stochastic/stochastic_schlogl_model.rst | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/docs/source/toy/stochastic/index.rst b/docs/source/toy/stochastic/index.rst index ec6bc52b3b..e25c7a2a7f 100644 --- a/docs/source/toy/stochastic/index.rst +++ b/docs/source/toy/stochastic/index.rst @@ -14,4 +14,5 @@ examples. stochastic_degradation_model stochastic_logistic_model stochastic_michaelis_menten_model + stochastic_production_degradation_model stochastic_schlogl_model diff --git a/docs/source/toy/stochastic/stochastic_schlogl_model.rst b/docs/source/toy/stochastic/stochastic_schlogl_model.rst index dd38193744..1359267ab8 100644 --- a/docs/source/toy/stochastic/stochastic_schlogl_model.rst +++ b/docs/source/toy/stochastic/stochastic_schlogl_model.rst @@ -1,6 +1,6 @@ -************** -Sclogl's model -************** +*************** +Schlogl's model +*************** .. currentmodule:: pints.toy.stochastic From 52db3d5d2ce96ef429a0df5573b9e4b693befbd2 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 21:10:08 +0000 Subject: [PATCH 30/41] more fixes --- examples/README.md | 2 ++ pints/tests/test_toy_markov_jump_model.py | 7 ++----- pints/toy/stochastic/_markov_jump_model.py | 3 +++ 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/examples/README.md b/examples/README.md index 1a3961d2be..c795ee6d13 100644 --- a/examples/README.md +++ b/examples/README.md @@ -120,6 +120,8 @@ relevant code. - [Stochastic Degradation model](./toy/model-stochastic-degradation.ipynb) - [Stochastic Logistic model](./toy/model-stochastic-logistic-growth.ipynb) - [Stochastic Michaelis Menten model](./toy/model-stochastic-michaelis-menten.ipynb) +- [Stochastic Production Degradation model](toy/model-stochastic-production-degradation.ipynb) +- [Stochastic Schlogl model](toy/model-stochastic-schlogl.ipynb) ### Distributions - [Annulus](./toy/distribution-annulus.ipynb) diff --git a/pints/tests/test_toy_markov_jump_model.py b/pints/tests/test_toy_markov_jump_model.py index 905c9c418f..ee53bdb3c7 100644 --- a/pints/tests/test_toy_markov_jump_model.py +++ b/pints/tests/test_toy_markov_jump_model.py @@ -61,16 +61,13 @@ def test_simulate(self): def test_errors(self): model = DegradationModel(20) - # parameters, times cannot be negative - times = np.linspace(0, 100, 101) - parameters = [-0.1] - self.assertRaises(ValueError, model.simulate, parameters, times) - + # times cannot be negative times_2 = np.linspace(-10, 10, 21) parameters_2 = [0.1] self.assertRaises(ValueError, model.simulate, parameters_2, times_2) # this model should have 1 parameter + times = np.linspace(0, 100, 101) parameters_3 = [0.1, 1] self.assertRaises(ValueError, model.simulate, parameters_3, times) diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py index 16c222dab8..a89bcf16d3 100644 --- a/pints/toy/stochastic/_markov_jump_model.py +++ b/pints/toy/stochastic/_markov_jump_model.py @@ -152,6 +152,9 @@ def simulate(self, parameters, times): # Run Gillespie time, mol_count = self.simulate_raw(parameters, max(times)) # Interpolate + if len(time) < 2: + time = np.append(time, time[0]) + mol_count = np.append(mol_count, mol_count[0]) values = self.interpolate_mol_counts(np.asarray(time), np.asarray(mol_count), times) return values From 019cdce13b46fb340251344e04fd5e430369c32c Mon Sep 17 00:00:00 2001 From: phumtutum Date: Thu, 3 Feb 2022 21:15:38 +0000 Subject: [PATCH 31/41] even more fixes --- pints/tests/test_toy_stochastic_schlogl_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pints/tests/test_toy_stochastic_schlogl_model.py b/pints/tests/test_toy_stochastic_schlogl_model.py index 76c86410b1..eaf29d5594 100644 --- a/pints/tests/test_toy_stochastic_schlogl_model.py +++ b/pints/tests/test_toy_stochastic_schlogl_model.py @@ -35,7 +35,7 @@ def test_propensities(self): self.assertTrue( np.allclose( model._propensities([x_0], k), - np.array([7.2, 0.015, 2200.0, 750.0]))) + np.array([68.4, 1.71, 2200.0, 750.0]))) def test_suggested(self): model = SchloglModel(20) From 14029aa58ccb4195fa9d194044b8ecd6a75ac17a Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 7 Feb 2022 13:59:37 +0000 Subject: [PATCH 32/41] change for tests --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ca85fb5aeb..e04792337a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file. ## Unreleased ### Added +- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for Approximate Bayesian computation (ABC) samplers. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. - [#1420](https://github.com/pints-team/pints/pull/1420) The `Optimiser` class now distinguishes between a best-visited point (`x_best`, with score `f_best`) and a best-guessed point (`x_guessed`, with approximate score `f_guessed`). For most optimisers, the two values are equivalent. The `OptimisationController` still tracks `x_best` and `f_best` by default, but this can be modified using the methods `set_f_guessed_tracking` and `f_guessed_tracking`. - [#1417](https://github.com/pints-team/pints/pull/1417) Added a module `toy.stochastic` for stochastic models. In particular, `toy.stochastic.MarkovJumpModel` implements Gillespie's algorithm for easier future implementation of stochastic models. @@ -24,7 +25,6 @@ All notable changes to this project will be documented in this file. ## [0.4.0] - 2021-12-07 ### Added -- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for Approximate Bayesian computation (ABC) samplers. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. - [#1409](https://github.com/pints-team/pints/pull/1409) The `OptimisationController` now accepts a callback function that will be called at every iteration; this can be used for easier customisation or visualisation of the optimiser trajectory. - [#1383](https://github.com/pints-team/pints/pull/1383) Added a method `toy.TwistedGaussianDistribution.untwist` that turns samples from this distribution into samples from a multivariate Gaussian. - [#1322](https://github.com/pints-team/pints/pull/1322) Added a method `sample_initial_points` that allows users to generate random points with finite metrics (either log-probabilities or error measures) to use as starting points for sampling or optimisation. From 0dd18ba191def969e3ea7c41787339e23c10a29d Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 7 Feb 2022 14:10:33 +0000 Subject: [PATCH 33/41] Revert "Merge branch 'i-96-abc-routine' into additional-stochastic-models" This reverts commit adbaf6360a91ba5bed12c76129507971e2243945, reversing changes made to 1ed1616b02d1ebbd47dd50c7001c738abbd44b61. --- CHANGELOG.md | 1 - docs/source/abc_samplers/base_classes.rst | 8 - docs/source/abc_samplers/index.rst | 16 - docs/source/abc_samplers/rejection_abc.rst | 7 - docs/source/index.rst | 7 +- examples/README.md | 3 - examples/sampling/rejection-abc.ipynb | 212 ------------ pints/__init__.py | 9 - pints/_abc/__init__.py | 364 --------------------- pints/_abc/_abc_rejection.py | 91 ------ pints/tests/test_abc_controller.py | 202 ------------ pints/tests/test_abc_rejection.py | 90 ----- 12 files changed, 3 insertions(+), 1007 deletions(-) delete mode 100644 docs/source/abc_samplers/base_classes.rst delete mode 100644 docs/source/abc_samplers/index.rst delete mode 100644 docs/source/abc_samplers/rejection_abc.rst delete mode 100644 examples/sampling/rejection-abc.ipynb delete mode 100644 pints/_abc/__init__.py delete mode 100644 pints/_abc/_abc_rejection.py delete mode 100644 pints/tests/test_abc_controller.py delete mode 100644 pints/tests/test_abc_rejection.py diff --git a/CHANGELOG.md b/CHANGELOG.md index e04792337a..6349ed86c6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,7 +5,6 @@ All notable changes to this project will be documented in this file. ## Unreleased ### Added -- [#1413](https://github.com/pints-team/pints/pull/1413) Added classes `pints.ABCController` and `pints.ABCSampler` for Approximate Bayesian computation (ABC) samplers. Added `pints.RejectionABC` which implements a simple rejection ABC sampling algorithm. - [#1420](https://github.com/pints-team/pints/pull/1420) The `Optimiser` class now distinguishes between a best-visited point (`x_best`, with score `f_best`) and a best-guessed point (`x_guessed`, with approximate score `f_guessed`). For most optimisers, the two values are equivalent. The `OptimisationController` still tracks `x_best` and `f_best` by default, but this can be modified using the methods `set_f_guessed_tracking` and `f_guessed_tracking`. - [#1417](https://github.com/pints-team/pints/pull/1417) Added a module `toy.stochastic` for stochastic models. In particular, `toy.stochastic.MarkovJumpModel` implements Gillespie's algorithm for easier future implementation of stochastic models. diff --git a/docs/source/abc_samplers/base_classes.rst b/docs/source/abc_samplers/base_classes.rst deleted file mode 100644 index e70b022bb8..0000000000 --- a/docs/source/abc_samplers/base_classes.rst +++ /dev/null @@ -1,8 +0,0 @@ -********************** -ABC sampler base class -********************** - -.. currentmodule:: pints - -.. autoclass:: ABCSampler -.. autoclass:: ABCController \ No newline at end of file diff --git a/docs/source/abc_samplers/index.rst b/docs/source/abc_samplers/index.rst deleted file mode 100644 index 96b4e9fc9d..0000000000 --- a/docs/source/abc_samplers/index.rst +++ /dev/null @@ -1,16 +0,0 @@ -************ -ABC samplers -************ - -.. currentmodule:: pints - -Pints provides a number of samplers for Approximate Bayesian -Computation (ABC), all implementing the :class:`ABCSampler` -interface, that can be used to sample from a stochastic model -given a :class:`LogPrior` and a :class:`ErrorMeasure`. - - -.. toctree:: - - base_classes - rejection_abc \ No newline at end of file diff --git a/docs/source/abc_samplers/rejection_abc.rst b/docs/source/abc_samplers/rejection_abc.rst deleted file mode 100644 index 4bbf4632a4..0000000000 --- a/docs/source/abc_samplers/rejection_abc.rst +++ /dev/null @@ -1,7 +0,0 @@ -********************* -Rejection ABC sampler -********************* - -.. currentmodule:: pints - -.. autoclass:: RejectionABC \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index fc85f8631c..543eb98bac 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -23,7 +23,6 @@ Contents .. toctree:: - abc_samplers/index boundaries core_classes_and_methods diagnostics @@ -79,10 +78,10 @@ Sampling - SMC -#. :class:`ABC sampling` +#. Likelihood free sampling (Need distance between data and states, e.g. least squares?) - - :class:`RejectionABC`, requires a :class:`LogPrior` that can be sampled - from and an error measure. + - ABC-MCMC + - ABC-SMC #. 1st order sensitivity MCMC samplers (Need derivatives of :class:`LogPDF`) diff --git a/examples/README.md b/examples/README.md index 923b089696..c795ee6d13 100644 --- a/examples/README.md +++ b/examples/README.md @@ -77,9 +77,6 @@ relevant code. - [Ellipsoidal nested sampling](./sampling/nested-ellipsoidal-sampling.ipynb) - [Rejection nested sampling](./sampling/nested-rejection-sampling.ipynb) -### ABC -- [Rejection ABC sampling](./sampling/rejection-abc.ipynb) - ### Analysing sampling results - [Autocorrelation](./plotting/mcmc-autocorrelation.ipynb) - [Customise analysis plots](./plotting/customise-pints-plots.ipynb) diff --git a/examples/sampling/rejection-abc.ipynb b/examples/sampling/rejection-abc.ipynb deleted file mode 100644 index 9be5af1c3f..0000000000 --- a/examples/sampling/rejection-abc.ipynb +++ /dev/null @@ -1,212 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Rejection ABC\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This example shows you how to perform Rejection ABC on a time series from the [stochastic degradation model](../toy/model-stochastic-degradation.ipynb). This model describes the describes the stochastic process of a single chemical reaction, in which the concentration of a substance degrades over time as particles react. It differs from most other models in PINTS through the fact that a likelihood ( $D | \\theta$ ) cannot be derived and we are only able to produce stochastic simulations using Gillespie's algorithm. ABC samplers are the solution to such a problem since they do not evaluate the likelihood to sample from the posterior distribution ( $\\theta | D$ )." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we will load the stochastic degradation model. In order to emphasise the variety provided by the stochastic simulations we will plot multiple runs of the model with the same parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pints\n", - "import pints.toy as toy\n", - "import pints.toy.stochastic\n", - "import pints.plot\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "np.random.seed(3)\n", - "\n", - "# Load a forward model\n", - "model = toy.stochastic.DegradationModel()\n", - "\n", - "# Create some toy data\n", - "real_parameters = model.suggested_parameters()\n", - "times = np.linspace(0, 10, 100)\n", - "\n", - "for i in range(10):\n", - " values = model.simulate(real_parameters, times)\n", - "\n", - " # Create an object with links to the model and time series\n", - " problem = pints.SingleOutputProblem(model, times, values)\n", - "\n", - " # Create a uniform prior parameter\n", - " log_prior = pints.UniformLogPrior([0.0], [0.3])\n", - "\n", - " # Set the error measure to be used to compare simulated to observed data\n", - " error_measure = pints.RootMeanSquaredError(problem)\n", - "\n", - " plt.step(times, values)\n", - "\n", - "\n", - "plt.xlabel('time')\n", - "plt.ylabel('concentration (A(t))')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fit using Rejection ABC\n", - "\n", - "The Rejection ABC algorithm can be applied to sample parameter values. An error measure will be used to compare the difference between the stochastic simulation obtained with the true set of parameters and the stochastic simulation obtained with a candidate value. Our error measure of choice is the root mean squared error. Root mean squared error has been chosen in order to amplify smaller differences between two stochastic simulations in order to increase the quality of our samples." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running...\n", - "Using Rejection ABC\n", - "Running in sequential mode.\n", - "Iter. Eval. Acceptance rate Time m:s\n", - "1 14 0.0714285714 0:00.0\n", - "2 24 0.0833333333 0:00.0\n", - "3 41 0.0731707317 0:00.0\n", - "20 521 0.0383877159 0:00.2\n", - "40 1418 0.0282087447 0:00.5\n", - "60 2418 0.0248138958 0:00.8\n", - "80 3185 0.0251177394 0:01.0\n", - "100 4057 0.0246487552 0:01.3\n", - "120 4979 0.0241012251 0:01.6\n", - "140 5725 0.0244541485 0:01.8\n", - "160 6767 0.0236441555 0:02.1\n", - "180 7834 0.0229767679 0:02.4\n", - "200 8539 0.0234219464 0:02.6\n", - "Halting: target number of samples (200) reached.\n", - "Done\n" - ] - } - ], - "source": [ - "abc = pints.ABCController(error_measure, log_prior)\n", - "\n", - "# set threshold\n", - "abc.sampler().set_threshold(1)\n", - "\n", - "# set target number of samples\n", - "abc.set_n_samples(200)\n", - "\n", - "# log to screen\n", - "abc.set_log_to_screen(True)\n", - "\n", - "print('Running...')\n", - "samples = abc.run()\n", - "print('Done')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to find the efficiency of the rejection ABC, we plot the approximate posterior compared to the actual parameter value. In the graph, we can see that there is a high concentration of samples around the value with which the data was generated. This suggests that the rejection ABC algorithm performs well and that the root mean squared error was a good choice as an error measure, since high quality samples were produced." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(samples[:,0], color=\"blue\", label=\"Samples\")\n", - "plt.vlines(x=model.suggested_parameters(), linestyles='dashed', ymin=0, ymax=50, label=\"Actual value\", color=\"red\")\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Note on Rejection ABC\n", - "\n", - "The Rejection ABC algorithm is a highly simplistic method for Bayesian inference. As a consequence, it is inefficient when used with high variance priors.\n", - "\n", - "Please make sure that you are monitoring the acceptance rate to see if this algorithm is working for your problem." - ] - } - ], - "metadata": { - "interpreter": { - "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" - }, - "kernelspec": { - "display_name": "Python 3.8.0 32-bit", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/pints/__init__.py b/pints/__init__.py index 260d92cfd0..ec03b8229e 100644 --- a/pints/__init__.py +++ b/pints/__init__.py @@ -241,15 +241,6 @@ def version(formatted=False): # from ._sample_initial_points import sample_initial_points -# -# ABC -# - -from ._abc import ABCSampler -from ._abc import ABCController -from ._abc._abc_rejection import RejectionABC - - # # Transformations # diff --git a/pints/_abc/__init__.py b/pints/_abc/__init__.py deleted file mode 100644 index 6e2b74419c..0000000000 --- a/pints/_abc/__init__.py +++ /dev/null @@ -1,364 +0,0 @@ -# -# Sub-module containing ABC inference routines -# -# This file is part of PINTS (https://github.com/pints-team/pints/) which is -# released under the BSD 3-clause license. See accompanying LICENSE.md for -# copyright notice and full license details. -# -import pints -import numpy as np - - -class ABCSampler(pints.Loggable, pints.TunableMethod): - """ - Abstract base class for ABC methods. - All ABC samplers implement the :class:`pints.Loggable` and - :class:`pints.TunableMethod` interfaces. - """ - - def name(self): - """ - Returns this method's full name. - """ - raise NotImplementedError - - def ask(self): - """ - Returns a parameter vector sampled from the LogPrior. - """ - raise NotImplementedError - - def tell(self, x): - """ - Performs an iteration of the ABC algorithm, using the - parameters specified by ask. - Expects to receive x as a sequence of length at least 1. - Returns the accepted parameter values. - """ - raise NotImplementedError - - -class ABCController(object): - """ - Samples from a :class:`pints.LogPrior`. - - Properties related to the number of iterations, parallelisation, - threshold, and number of parameters to sample can be set directly on the - ``ABCController`` object. Afterwards the ABC routine can be run. - - Parameters - ---------- - error_measure - An error measure to evaluate on a problem, given a forward model, - simulated and observed data, and times - log_prior - A :class:`LogPrior` function from which parameter values are sampled - method - The class of :class:`ABCSampler` to use. If no method is specified, - :class:`RejectionABC` is used. - - Example - ------- - :: - abc = pints.ABCController(error_measure, log_prior) - abc.set_max_iterations(1000) - posterior_estimate = abc.run() - - """ - - def __init__(self, error_measure, log_prior, method=None): - - # Store function - if not isinstance(log_prior, pints.LogPrior): - raise ValueError('Given function must extend pints.LogPrior.') - self._log_prior = log_prior - - # Check error_measure - if not isinstance(error_measure, pints.ErrorMeasure): - raise ValueError('Given error_measure must extend ' - 'pints.ErrorMeasure') - self._error_measure = error_measure - - # Check if number of parameters from prior matches that of error - # measure - if self._log_prior.n_parameters() != \ - self._error_measure.n_parameters(): - raise ValueError('Number of parameters in prior must match number ' - 'of parameters in error measure.') - - # Get number of parameters - self._n_parameters = self._log_prior.n_parameters() - - # Set rejection ABC as default method - if method is None: - method = pints.RejectionABC - else: - try: - ok = issubclass(method, ABCSampler) - except TypeError: # Not a class - ok = False - if not ok: - raise ValueError('Given method must extend ABCSampler.') - - # Initialisation - - # Parallelisation - self._parallel = False - self._n_workers = 1 - - # Maximum number of iterations as a stopping criterion - self._max_iterations = 10000 - - # Maximum number of target samples to obtain - # in the estimated posterior - self._n_samples = 500 - - # The sampler object uses the prior distribution - self._sampler = method(log_prior) - - # Logging - self._log_to_screen = True - self._log_filename = None - self._log_csv = False - self.set_log_interval() - - def set_log_interval(self, iters=20, warm_up=3): - """ - Changes the frequency with which messages are logged. - - Parameters - ---------- - iters - A log message will be shown every ``iters`` iterations. - warm_up - A log message will be shown every iteration, for the first - ``warm_up`` iterations. - """ - iters = int(iters) - if iters < 1: - raise ValueError("Interval must be greater than 0.") - - warm_up = max(0, int(warm_up)) - self._message_interval = iters - self._message_warm_up = warm_up - - def set_log_to_file(self, filename=None, csv=False): - """ - Enables progress logging to file when a filename is passed in, disables - it if ``filename`` is ``False`` or ``None``. - - The argument ``csv`` can be set to ``True`` to write the file in comma - separated value (CSV) format. By default, the file contents will be - similar to the output on screen. - """ - if filename: - self._log_filename = str(filename) - self._log_csv = True if csv else False - else: - self._log_filename = None - self._log_csv = False - - def set_log_to_screen(self, enabled): - """ - Enables or disables progress logging to screen. - """ - self._log_to_screen = True if enabled else False - - def max_iterations(self): - """ - Returns the maximum iterations if this stopping criterion is set, or - ``None`` if it is not. See :meth:`set_max_iterations()`. - """ - return self._max_iterations - - def n_samples(self): - """ - Returns the target number of samples to obtain in the estimated - posterior. - """ - return self._n_samples - - def parallel(self): - """ - Returns the number of parallel worker processes this routine will be - run on, or ``False`` if parallelisation is disabled. - """ - return self._n_workers if self._parallel else False - - def run(self): - """ - Runs the ABC sampler. - """ - if self._max_iterations is None: - raise ValueError("At least one stopping criterion must be set.") - - # Iteration and evaluation counting - iteration = 0 - evaluations = 0 - accepted_count = 0 - - # Choose method to evaluate - f = self._error_measure - - # Create evaluator - if self._parallel: - n_workers = self._n_workers - evaluator = pints.ParallelEvaluator(f, n_workers=n_workers) - else: - evaluator = pints.SequentialEvaluator(f) - - # Set up progress reporting - next_message = 0 - - # Start logging - logging = self._log_to_screen or self._log_filename - if logging: - if self._log_to_screen: - print('Using ' + str(self._sampler.name())) - if self._parallel: - print('Running in parallel with ' + str(n_workers) + - ' worker processess.') - else: - print('Running in sequential mode.') - - # Set up logger - logger = pints.Logger() - if not self._log_to_screen: - logger.set_stream(None) - if self._log_filename: - logger.set_filename(self._log_filename, csv=self._log_csv) - - # Add fields to log - max_iter_guess = max(self._max_iterations or 0, 10000) - max_eval_guess = max_iter_guess - logger.add_counter('Iter.', max_value=max_iter_guess) - logger.add_counter('Eval.', max_value=max_eval_guess) - logger.add_float('Acceptance rate') - self._sampler._log_init(logger) - logger.add_time('Time m:s') - - # Start sampling - timer = pints.Timer() - running = True - - # Specifying the number of samples we want to get - # from the prior at once. It depends on whether we - # are using parallelisation and how many workers - # are being used. - if self._parallel: - n_requested_samples = self._n_workers - else: - n_requested_samples = 1 - - samples = [] - # Sample until we find an acceptable sample - while running: - accepted_vals = None - while accepted_vals is None: - # Get points from prior - xs = self._sampler.ask(n_requested_samples) - - # Simulate and get error - fxs = evaluator.evaluate(xs) - evaluations += self._n_workers - - # Tell sampler errors and get list of acceptable parameters - accepted_vals = self._sampler.tell(fxs) - - accepted_count += len(accepted_vals) - for val in accepted_vals: - samples.append(val) - - iteration += 1 - - # Log progress - if logging and iteration >= next_message: - # Log state - logger.log(iteration, evaluations, ( - accepted_count / evaluations)) - self._sampler._log_write(logger) - logger.log(timer.time()) - - # Choose next logging point - if iteration < self._message_warm_up: - next_message = iteration + 1 - else: - next_message = self._message_interval * ( - 1 + iteration // self._message_interval) - - if iteration >= self._max_iterations: - running = False - halt_message = ('Halting: Maximum number of iterations (' - + str(iteration) + ') reached. Only (' - + str(accepted_count) + ') sample were ' - + 'obtained') - elif accepted_count >= self._n_samples: - running = False - halt_message = ('Halting: target number of samples (' - + str(accepted_count) + ') reached.') - - # Log final state and show halt message - if logging: - logger.log(iteration, evaluations) - self._sampler._log_write(logger) - logger.log(timer.time()) - if self._log_to_screen: - print(halt_message) - samples = np.array(samples) - return samples - - def log_filename(self): - """ - Returns the file name in which all the logs related to the - ABC routine will be stored. - """ - return self._log_filename - - def sampler(self): - """ - Returns the underlying sampler object. - """ - return self._sampler - - def set_max_iterations(self, iterations=10000): - """ - Adds a stopping criterion, allowing the routine to halt after the - given number of ``iterations``. - - This criterion is enabled by default. To disable it, use - ``set_max_iterations(None)``. - """ - if iterations is not None: - iterations = int(iterations) - if iterations < 0: - raise ValueError( - 'Maximum number of iterations cannot be negative.') - self._max_iterations = iterations - - def set_n_samples(self, n_samples=500): - """ - Sets a target number of samples - """ - self._n_samples = n_samples - - def set_parallel(self, parallel=False): - """ - Enables/disables parallel evaluation. - - If ``parallel=True``, the method will run using a number of worker - processes equal to the detected cpu core count. The number of workers - can be set explicitly by setting ``parallel`` to an integer greater - than 0. - Parallelisation can be disabled by setting ``parallel`` to ``0`` or - ``False``. - """ - if parallel is True: - self._n_workers = pints.ParallelEvaluator.cpu_count() - self._parallel = True - - elif parallel >= 1: - self._parallel = True - self._n_workers = int(parallel) - else: - self._parallel = False - self._n_workers = 1 diff --git a/pints/_abc/_abc_rejection.py b/pints/_abc/_abc_rejection.py deleted file mode 100644 index 48060887fa..0000000000 --- a/pints/_abc/_abc_rejection.py +++ /dev/null @@ -1,91 +0,0 @@ -# -# ABC Rejection method -# -# This file is part of PINTS (https://github.com/pints-team/pints/) which is -# released under the BSD 3-clause license. See accompanying LICENSE.md for -# copyright notice and full license details. -# -import pints -import numpy as np - - -class RejectionABC(pints.ABCSampler): - r""" - Implements the rejection ABC algorithm as described in [1]. - - Here is a high-level description of the algorithm: - - .. math:: - \begin{align} - \theta^* &\sim p(\theta) \\ - x &\sim p(x|\theta^*) \\ - \textrm{if } s(x) < \textrm{threshold}, \textrm{then} \\ - \theta^* \textrm{ is added to list of samples} \\ - \end{align} - - In other words, the first two steps sample parameters - from the prior distribution :math:`p(\theta)` and then sample - simulated data from the sampling distribution (conditional on - the sampled parameter values), :math:`p(x|\theta^*)`. - In the end, if the error measure between our simulated data and - the original data is within the threshold, we add the sampled - parameters to the list of samples. - - References - ---------- - .. [1] "Approximate Bayesian Computation (ABC) in practice". Katalin - Csillery, Michael G.B. Blum, Oscar E. Gaggiotti, Olivier Francois - (2010) Trends in Ecology & Evolution - https://doi.org/10.1016/j.tree.2010.04.001 - - """ - def __init__(self, log_prior): - - self._log_prior = log_prior - self._threshold = 1 - self._xs = None - self._ready_for_tell = False - - def name(self): - """ See :meth:`pints.ABCSampler.name()`. """ - return 'Rejection ABC' - - def ask(self, n_samples): - """ See :meth:`ABCSampler.ask()`. """ - if self._ready_for_tell: - raise RuntimeError('Ask called before tell.') - self._xs = self._log_prior.sample(n_samples) - - self._ready_for_tell = True - return self._xs - - def tell(self, fx): - """ See :meth:`ABCSampler.tell()`. """ - if not self._ready_for_tell: - raise RuntimeError('Tell called before ask.') - self._ready_for_tell = False - - fx = pints.vector(fx) - accepted = self._xs[fx < self._threshold] - if np.sum(accepted) == 0: - return None - else: - return [self._xs.tolist() for c, x in - enumerate(accepted) if x] - - def threshold(self): - """ - Returns threshold error distance that determines if a sample is - accepted (if ``error < threshold``). - """ - return self._threshold - - def set_threshold(self, threshold): - """ - Sets threshold error distance that determines if a sample is accepted - (if ``error < threshold``). - """ - x = float(threshold) - if x <= 0: - raise ValueError('Threshold must be greater than zero.') - self._threshold = threshold diff --git a/pints/tests/test_abc_controller.py b/pints/tests/test_abc_controller.py deleted file mode 100644 index f3def023d9..0000000000 --- a/pints/tests/test_abc_controller.py +++ /dev/null @@ -1,202 +0,0 @@ -#!/usr/bin/env python3 -# -# Tests the ABC Controller. -# -# This file is part of PINTS (https://github.com/pints-team/pints/) which is -# released under the BSD 3-clause license. See accompanying LICENSE.md for -# copyright notice and full license details. -# -import pints -import pints.toy -import pints.toy.stochastic -import unittest -import numpy as np -from shared import StreamCapture - - -class TestABCController(unittest.TestCase): - """ - Tests the ABCController class. - """ - - @classmethod - def setUpClass(cls): - """ Prepare problem for tests. """ - - # Create toy model - cls.model = pints.toy.stochastic.DegradationModel() - cls.real_parameters = [0.1] - cls.times = np.linspace(0, 10, 10) - cls.values = cls.model.simulate(cls.real_parameters, cls.times) - - # Create an object (problem) with links to the model and time series - cls.problem = pints.SingleOutputProblem( - cls.model, cls.times, cls.values) - - # Create a uniform prior over both the parameters - cls.log_prior = pints.UniformLogPrior( - [0.0], - [0.3] - ) - - # Set error measure - cls.error_measure = pints.RootMeanSquaredError(cls.problem) - - def test_nparameters_error(self): - """ Test that error is thrown when parameters from log prior and error - measure do not match""" - log_prior = pints.UniformLogPrior( - [0.0, 0, 0], - [0.2, 100, 1]) - - self.assertRaises(ValueError, pints.ABCController, self.error_measure, - log_prior) - - def test_error_measure_instance(self): - """ Test that error is thrown when we use an error measure which is not - an instance of ``pints.ErrorMeasure``""" - # Set a log prior as the error measure to trigger the warning - wrong_error_measure = pints.UniformLogPrior( - [0.0, 0, 0], - [0.2, 100, 1]) - - self.assertRaises( - ValueError, - pints.ABCController, - wrong_error_measure, - self.log_prior) - - def test_stopping(self): - """ Test different stopping criteria. """ - - abc = pints.ABCController(self.error_measure, self.log_prior) - - # Test setting max iterations - maxi = abc.max_iterations() + 2 - self.assertNotEqual(maxi, abc.max_iterations()) - abc.set_max_iterations(maxi) - self.assertEqual(maxi, abc.max_iterations()) - self.assertRaisesRegex( - ValueError, - 'Maximum number of iterations cannot be negative.', - abc.set_max_iterations, -1) - - # # Test without stopping criteria - abc.set_max_iterations(None) - self.assertIsNone(abc.max_iterations()) - self.assertRaisesRegex( - ValueError, - 'At least one stopping criterion must be set.', - abc.run) - - def test_parallel(self): - """ Test running ABC with parallisation. """ - - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - - # Test with auto-detected number of worker processes - self.assertFalse(abc.parallel()) - abc.set_parallel(True) - self.assertTrue(abc.parallel()) - self.assertEqual(abc.parallel(), pints.ParallelEvaluator.cpu_count()) - - # Test with fixed number of worker processes - abc.set_parallel(2) - self.assertEqual(abc.parallel(), 2) - - def test_logging(self): - # tests logging to screen - # No output - with StreamCapture() as capture: - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_max_iterations(10) - abc.set_log_to_screen(False) - abc.set_log_to_file(False) - abc.run() - self.assertEqual(capture.text(), '') - - # With output to screen - np.random.seed(1) - with StreamCapture() as capture: - pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_max_iterations(10) - abc.set_log_to_screen(True) - abc.set_log_to_file(False) - abc.run() - lines = capture.text().splitlines() - self.assertTrue(len(lines) > 0) - - # With output to screen - np.random.seed(1) - with StreamCapture() as capture: - pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_max_iterations(10) - abc.set_log_to_screen(False) - abc.set_log_to_file(True) - abc.run() - lines = capture.text().splitlines() - self.assertTrue(len(lines) == 0) - - # Invalid log interval - self.assertRaises(ValueError, abc.set_log_interval, 0) - - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_log_to_file("temp_file") - self.assertEqual(abc.log_filename(), "temp_file") - - # tests logging to screen with parallel - with StreamCapture() as capture: - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_parallel(2) - abc.set_max_iterations(10) - abc.set_log_to_screen(False) - abc.set_log_to_file(False) - abc.run() - self.assertEqual(capture.text(), '') - - def test_controller_extra(self): - # tests various controller aspects - self.assertRaises(ValueError, pints.ABCController, self.error_measure, - self.error_measure) - self.assertRaisesRegex( - ValueError, 'Given method must extend ABCSampler.', - pints.ABCController, self.error_measure, - self.log_prior, pints.MCMCSampler) - self.assertRaises(ValueError, pints.ABCController, self.error_measure, - pints.MCMCSampler) - self.assertRaises(ValueError, pints.ABCController, self.error_measure, - self.log_prior, 0.0) - - # test setters - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_n_samples(230) - self.assertEqual(abc.n_samples(), 230) - - sampler = abc.sampler() - pt = sampler.ask(1) - self.assertEqual(len(pt), 1) - - abc.set_parallel(False) - self.assertEqual(abc.parallel(), 0) - - with StreamCapture() as capture: - abc = pints.ABCController( - self.error_measure, self.log_prior, method=pints.RejectionABC) - abc.set_parallel(4) - abc.sampler().set_threshold(100) - abc.set_n_samples(1) - abc.run() - lines = capture.text().splitlines() - self.assertTrue(len(lines) > 0) - self.assertTrue(True) - - -if __name__ == '__main__': - unittest.main() diff --git a/pints/tests/test_abc_rejection.py b/pints/tests/test_abc_rejection.py deleted file mode 100644 index eab78786f8..0000000000 --- a/pints/tests/test_abc_rejection.py +++ /dev/null @@ -1,90 +0,0 @@ -#!/usr/bin/env python -# -# Tests the basic methods of the ABC Rejection routine. -# -# This file is part of PINTS (https://github.com/pints-team/pints/) which is -# released under the BSD 3-clause license. See accompanying LICENSE.md for -# copyright notice and full license details. -# -import pints -import pints.toy as toy -import pints.toy.stochastic -import unittest -import numpy as np - - -class TestRejectionABC(unittest.TestCase): - """ - Tests the basic methods of the ABC Rejection routine. - """ - # Set up toy model, parameter values, problem, error measure - @classmethod - def setUpClass(cls): - """ Set up problem for tests. """ - - # Create toy model - cls.model = toy.stochastic.DegradationModel() - cls.real_parameters = [0.1] - cls.times = np.linspace(0, 10, 10) - cls.values = cls.model.simulate(cls.real_parameters, cls.times) - - # Create an object (problem) with links to the model and time series - cls.problem = pints.SingleOutputProblem( - cls.model, cls.times, cls.values) - - # Create a uniform prior over both the parameters - cls.log_prior = pints.UniformLogPrior( - [0.0], - [0.3] - ) - - # Set error measure - cls.error_measure = pints.RootMeanSquaredError(cls.problem) - - def test_method(self): - - # Create abc rejection scheme - abc = pints.RejectionABC(self.log_prior) - - # Configure - n_draws = 1 - niter = 20 - - # Perform short run using ask and tell framework - samples = [] - while len(samples) < niter: - x = abc.ask(n_draws)[0] - fx = self.error_measure(x) - sample = abc.tell(fx) - while sample is None: - x = abc.ask(n_draws)[0] - fx = self.error_measure(x) - sample = abc.tell(fx) - samples.append(sample) - - samples = np.array(samples) - self.assertEqual(samples.shape[0], niter) - - def test_errors(self): - # test errors in abc rejection - abc = pints.RejectionABC(self.log_prior) - abc.ask(1) - # test two asks raises error - self.assertRaises(RuntimeError, abc.ask, 1) - # test tell with large values returns empty arrays - self.assertTrue(abc.tell(np.array([100])) is None) - # test error raised if tell called before ask - self.assertRaises(RuntimeError, abc.tell, 2.5) - - def test_setters_and_getters(self): - # test setting and getting - abc = pints.RejectionABC(self.log_prior) - self.assertEqual('Rejection ABC', abc.name()) - self.assertEqual(abc.threshold(), 1) - abc.set_threshold(2) - self.assertEqual(abc.threshold(), 2) - self.assertRaises(ValueError, abc.set_threshold, -3) - - -if __name__ == '__main__': - unittest.main() From a89a8dfaa9c0f6c3954801b7ddcd6cdc077de911 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Mon, 7 Feb 2022 14:16:54 +0000 Subject: [PATCH 34/41] tests fix + changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6349ed86c6..25da9b6ce8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file. ## Unreleased ### Added +- [#1432](https://github.com/pints-team/pints/pull/1432) Added 2 new stochastic models: production and degradation model, Schlogl's system of chemical reactions. Moved the stochastic logistic model into `pints.stochastic` to take advantage of the `MarkovJumpModel`. - [#1420](https://github.com/pints-team/pints/pull/1420) The `Optimiser` class now distinguishes between a best-visited point (`x_best`, with score `f_best`) and a best-guessed point (`x_guessed`, with approximate score `f_guessed`). For most optimisers, the two values are equivalent. The `OptimisationController` still tracks `x_best` and `f_best` by default, but this can be modified using the methods `set_f_guessed_tracking` and `f_guessed_tracking`. - [#1417](https://github.com/pints-team/pints/pull/1417) Added a module `toy.stochastic` for stochastic models. In particular, `toy.stochastic.MarkovJumpModel` implements Gillespie's algorithm for easier future implementation of stochastic models. From 6a36389cadf267406fddcff142b8bf95d138ed49 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Fri, 11 Feb 2022 19:02:47 +0000 Subject: [PATCH 35/41] specified nr of outputs for multioutput problems --- pints/toy/stochastic/_michaelis_menten_model.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py index 644f9cc550..fab2ade930 100644 --- a/pints/toy/stochastic/_michaelis_menten_model.py +++ b/pints/toy/stochastic/_michaelis_menten_model.py @@ -42,3 +42,6 @@ def _propensities(xs, ks): xs[2] * ks[1], xs[2] * ks[2] ] + + def n_outputs(): + return 4 From 5af4a5941ed6f0a89f2aad1e7c89162a1987e974 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Fri, 11 Feb 2022 19:23:52 +0000 Subject: [PATCH 36/41] finished and checked small fix for pints.multioutputproblem --- pints/toy/stochastic/_michaelis_menten_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py index fab2ade930..55c71ea74d 100644 --- a/pints/toy/stochastic/_michaelis_menten_model.py +++ b/pints/toy/stochastic/_michaelis_menten_model.py @@ -43,5 +43,5 @@ def _propensities(xs, ks): xs[2] * ks[2] ] - def n_outputs(): + def n_outputs(self): return 4 From db805029e59152dbdcc622dc1a018fbcc0ea4376 Mon Sep 17 00:00:00 2001 From: ben18785 Date: Tue, 15 Mar 2022 18:06:12 +0000 Subject: [PATCH 37/41] cosmetic changes to stochastic growth abc notebook --- .../model-stochastic-logistic-growth.ipynb | 55 +++++++++++-------- 1 file changed, 33 insertions(+), 22 deletions(-) diff --git a/examples/toy/model-stochastic-logistic-growth.ipynb b/examples/toy/model-stochastic-logistic-growth.ipynb index 4efb82e988..7c3447dcee 100644 --- a/examples/toy/model-stochastic-logistic-growth.ipynb +++ b/examples/toy/model-stochastic-logistic-growth.ipynb @@ -12,19 +12,21 @@ "The population grows starting from an initial population size, $n_0$, to a carrying capacity $k$ following a rate according to the following model [(Simpson et al., 2019)](https://doi.org/10.1101/533182):\n", " $$A \\xrightarrow{b_0(1-\\frac{\\mathcal{C}(t)}{k})} 2A$$\n", "\n", - "The model is simulated according to the Gillespie stochastic simulation algorithm [(Gillespie, 1976)](https://doi.org/10.1016/0021-9991(76)90041-3), [(Erban et al., 2007)](https://arxiv.org/abs/0704.1908):\n", + "The model is simulated according to the Gillespie stochastic simulation algorithm [(Gillespie, 1976)](https://doi.org/10.1016/0021-9991%2876%2990041-3), [(Erban et al., 2007)](https://arxiv.org/abs/0704.1908):\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:\n", " $$ \\tau = \\frac{-\\ln{r}}{\\mathcal{C}(t)b_{0} (1-\\frac{\\mathcal{C}(t)}{k})} $$\n", " 3. Update the population size at time t + $\\tau$ as: $ \\mathcal{C}(t + \\tau) = \\mathcal{C}(t) + 1 $\n", - " 4. Return to step (1) until population size reaches $k$\n", + " 4. Return to step (1)\n", " " ] }, { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "import pints\n", @@ -38,7 +40,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Specify initial population size, time points at which to record population values, initial birth rate $b_0$, and carrying capacity, $k$" + "We first perform a single simulation, where we specify the initial population size, time points at which to record population values, birth rate $b_0$, and carrying capacity, $k$." ] }, { @@ -48,7 +50,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYT0lEQVR4nO3de/TcdX3n8edLELRYDAGkMZBNWjl24w0xGqjsHgRtwVtYl4q3Sllc9rSu4m67VbvnrK61Z2XbVapVChU11AuyKMJ627IY75BjIhQU7DGCQNJAohjEC6jw3j++3x+M6fySmWRuv5nn45w5M9/PzPzmPecL88778/58v99UFZIk7exh4w5AkjSZTBCSpK5MEJKkrkwQkqSuTBCSpK72HXcAg3LIIYfU8uXLxx2GJC0oGzdu/F5VHdrtualJEMuXL2fDhg3jDkOSFpQkt873nFNMkqSuTBCSpK5MEJKkrkwQkqSuTBCSpK5GliCSfDfJDUmuS7KhHVuc5Mok327vD2rHk+SdSTYluT7J0aOKU5LUGHUF8ayqOqqqVrXbbwCuqqojgavabYCTgSPb21nAeSOOU5Jm3riPg1gDHN8+Xgt8Hnh9O35RNecivybJoiRLqmrrWKKUpD3w4fW3cfl1W4b+OSsfeyBvesETBv53R5kgCvj7JAWcX1UXAId1/OjfARzWPl4K3N7x3s3t2C8liCRn0VQYLFu2bIihS1poRvXjvCvrb7kLgNUrFo81jj01ygRxXFVtSfIY4Mok3+p8sqqqTR49a5PMBQCrVq3yykfSBJiEH2aYjB/n1SsWs+aopbxs9cL8B+zIEkRVbWnvtyW5DHgGcOfc1FGSJcC29uVbgCM63n54OyZpQsyXCCbhh3nu8xfyj/MkGEmCSHIA8LCquqd9/NvAW4ArgNOBt7X3l7dvuQL4j0kuBlYDd9t/kAZvb/61P18i8Id5eoyqgjgMuCzJ3Gd+uKo+m+RrwCVJzgRuBV7cvv7TwHOBTcBPgDNGFKe0IAxqGmdv/rVvIph+I0kQVXUz8JQu498HTuwyXsCrRxCatGB0JoVBTeP4I69dGfcyV0m7MF9S8Iddo2CCkCaMSUGTwgQhDdGe9ApMCpoUJghpiC6/bgs3bv0hK5cc2PN7TAqaFCYIachWLjmQj/6HY8cdhtQ3E4Q0APNNJfVbPUiTxOtBSAMwN5W0s5VLDmTNUUvHEJG096wgpD3UWTXMVQpOJWmaWEFIe6izarBS0DSygpB2Y3f9BasGTSsrCGk37C9oVllBSD2wUtAsMkFIXXRrQEuzxikmqQsb0JIVhDQvp5U060wQUstpJemXOcUktZxWkn6ZFYRmmkdDS/OzgtBMs2qQ5mcFoZln1SB1Z4LQzLEZLfXGKSbNHKeVpN5YQWgmOa0k7Z4VhCSpKysIzQT7DlL/rCA0E+w7SP2zgtDMsO8g9ccEoanltJK0d0wQmiqdSWH9LXcBsHrFYqeVpD1ggtBUmes1rFxyIKtXLGbNUUt52epl4w5LWpBMEJo69hqkwXAVkySpKysILXg2o6XhsILQgucxDtJwWEFoQfJCP9LwjbSCSLJPkmuTfLLdXpFkfZJNST6aZL92fP92e1P7/PJRxqnJZ9UgDd+oK4izgZuAuUnic4B3VNXFSf4GOBM4r73/QVU9LslL2tedNuJYNeGsGqThGlkFkeRw4HnAe9vtACcAl7YvWQuc0j5e027TPn9i+3pJ0oiMcorpXOBPgAfa7YOBHVX1i3Z7MzA3T7AUuB2gff7u9vW/JMlZSTYk2bB9+/Yhhi5Js2ckU0xJng9sq6qNSY4f1N+tqguACwBWrVpVg/q7mkwuZ5VGa1QVxDOBFyb5LnAxzdTSXwGLkswlqcOBLe3jLcARAO3zjwa+P6JYNaFsTEujNZIKoqreCLwRoK0g/riqXp7kfwOn0iSN04HL27dc0W5f3T7/uaqyQpCNaWmExn0cxOuBi5O8FbgWuLAdvxD4uySbgLuAl4wpPo2Z00rS+Iw8QVTV54HPt49vBp7R5TX3Ar870sA0kTrPzuq0kjRa464gpN1yWkkaj74TRJIDgHur6v4hxCM5rSRNiN2uYkrysCQvS/KpJNuAbwFbk9yY5C+SPG74YWqWuFpJmgy9VBDrgP9HswrpG1X1AECSxcCzgHOSXFZVHxxemJo1TitJ49dLgnh2Vf1858Gqugv4GPCxJA8feGSSpLHa7RTTzskhyQFJ9tnVayRJC99uK4gkD6M5DuHlwNOB+4D9k3wP+BRwflVtGmqUmno2pqXJ08upNtYBv0HTg/i1qjqiqh4DHAdcQ9ODeMUQY9QMsDEtTZ6eexBJls81qMEehAbPxrQ0WXabIDr6Cx8Hju58LskxVXWNPQjtCaeVpMnWy3EQL07yNuBXk/zLticx54LhhaZp57SSNNl6mWL6CvAI4FXA24HHJ9kB/BPw0+GFplngtJI0uXqZYtoCXJTkO1X1FYAkBwPLaY6qliRNoV6WuaYaX5kbq6rv03EBn7nXDClGSdIY9LTMNclrkizrHEyyX5ITkqylubiPJGmK9NKDOAn4d8BHkqwAdtD0JPYB/h44t6quHVqEkqSx6KUHcS/wHuA97fEOhwA/raodQ45NkjRGfV0Poj3eYevcdpJFJgr1w2MfpIWjpwTRXiToCcATO+6fCBwALBpWcJoOnUlh/S13AbB6xWKPfZAmXC+rmL4LPBy4kWZZ603AS4GjqmrbUKPTVOi8rvTqFYtZc9RSXrZ62e7fKGmseqkg/g9wPPC3VXUJQJL/YnLQrnSbSvKAOGlh6eV6EK8Bng88N8nXkpwMeMyDdsnTaEgLX089iKq6Ffj9JE8A/gz4tSTPqqp1Q41OC5pVg7Sw9XKg3IOq6ptV9SKaa1H/1yRfGE5YkqRx6/lUG51jVbUeeHaSE+d7jSRpYetlimldko8Bl1fVbXODSfZr79fSXHXuA0OJUAtCZ1MaPMZBmga9TDGdBNxPc6qNf0pyY5KbgW/TXKv63Kr6wBBj1ALQ2ZQGG9PSNPBUGxoYm9LSdNmrU21IkqZXXwlC6uR5laTp1tcyV6mTB8NJ063nCiLJ/sC/pbnU6IPvq6q3DD4sLRT2HaTp1c8U0+XA3cBG4L7hhCNJmhT9JIjDq+qkoUWiBcG+gzQ7+ulBfDXJk4YWiRYE+w7S7OingjiO5oR9t9BMMQWoqnry7t6Y5BHAF4H928+8tKre1F7j+mLgYJqpq9+rqp+1/Y6LgKcB3wdOq6rv9hGrhsi+gzQb+kkQJ+/F59wHnFBVP2oPtvtyks8A/xl4R1VdnORvgDOB89r7H1TV45K8BDgHOG0vPl+S1Keep5jaU34vAl7Q3ha1Y728t6rqR+3mw9tbAScAl7bja4FT2sdr2m3a509Mkl5jlSTtvZ4TRJKzgQ8Bj2lvH0zymj7ev0+S64BtwJXAd4AdVfWL9iWbgbkJ7aXA7QDt83fTTEPt/DfPSrIhyYbt27f3GookqQf9TDGdCayuqh8DJDkHuBp4Vy9vrqr7gaOSLAIuA36zv1C7/s0LgAsAVq1a5enGJWmA+kkQoTmr65z727G+VNWOJOuAY4FFSfZtq4TDgbnzRW8BjgA2J9kXeDRNs1pj4NJWaTb1s8z1/cD6JG9O8mbgGuDCXt6Y5NC2ciDJI4HnADfRXEfi1PZlp9McjAdwRbtN+/znvCDR+Li0VZpNPVcQVfX29hKjz2yHzqiqa3t8+xJgbZJ9aJLSJVX1ySQ3AhcneStwLQ8lnAuBv0uyCbiL5roTGiOXtkqzp9/TfW+kOV6hL1V1PfDULuM3A8/oMn4v8Lv9fo4kaXB6uSb1l6vquCT30CxNffApmhWsTkhL0hTq5Ypyx7X3vzr8cCRJk6Kf4yDO6WVMkjQd+ulBPAd4/U5jJ3cZ0xRwaauk3VYQSf4gyQ3A45Nc33G7Bbhh+CFqHFzaKqmXCuLDwGeA/wG8oWP8nqq6ayhRaSK4tFWabb00qe+mORfSS5McBBwJPAIgCVX1xeGGKEkah36uSf0q4GyaU2JcBxxDcy6mE4YSmUbOvoOkTv2cauNs4OnArVX1LJoD33YMIyiNh30HSZ36WcV0b1Xdm4Qk+1fVt5I8fmiRaSzsO0ia00+C2NyecO8TwJVJfgD0dMEgSdLC01OCaK/m9tqq2gG8uT1d96OBzw4xNknSGPWUIKqqknwaeFK7/YWhRiVJGrt+ppi+nuTpVfW1oUWjkXPlkqT59LOKaTVwdZLvtEdS35Dk+mEFptFw5ZKk+fRTQfzO0KLQWLlySVI3/VQQf1hVt3begD8cVmCSpPHqJ0E8p8vYyYMKRJI0WXq5otwf0FQKv97RcwjwKOCrQ4xNkjRGns11BrlySVIvej6ba5IzgBcBy+fe157N9S1DjVADN7dyaeWSA125JGle/axi+gTNab83AvcNJRqNjCuXJO1OPwni8Ko6aWiRaKicVpLUr35WMX01yZOGFomGygPiJPWrnwriOOD322tR30ezkqmq6slDiUwD57SSpH70kyA85kGSZkjPCaI9clqSNCN67kGk8Yok/63dXpbkGcMLTZI0Tv00qd8DHAu8tN2+B3j3wCOSJE2EfnoQq6vq6CTXAlTVD5LsN6S4JElj1k8F8fMk+wAFkORQ4IGhRCVJGrt+EsQ7gcuAxyT5c+DLNOdnkiRNoX5WMX0oyUbgRJpjIE6pqpuGFpn2mkdPS9ob/axiWgvcUVXvrqq/Bu5I8r7hhaa95dHTkvZGP03qJ1fVjrmNtkn91MGHpEHy6GlJe6qfHsTDkhw0t5FkMT0mmCRHJFmX5MYk30xy9tzfSHJlkm+39we140nyziSbklyf5Oh+vpQkae/1kyD+F3BNkj9L8laaq8n9RY/v/QXwR1W1EjgGeHWSlTQXILqqqo4EruKhCxKdDBzZ3s4CzusjTknSAPTTpL4oyQbgBJqlri+qqht7fO9WYGv7+J4kNwFLgTXA8e3L1gKfB17fjl9UVUWTlBYlWdL+He2CjWlJg9JPk3p/4CjgQOBg4NS50270I8ly4KnAeuCwjh/9O4DD2sdLgds73ra5Hdv5b52VZEOSDdu3b+83lKlkY1rSoPTTpL6cvbyiXJJHAR8DXldVP0zy4HNVVUmqn79XVRcAFwCsWrWqr/dOMxvTkgZhZFeUS/JwmuTwoar6eDt859zUUZIlwLZ2fAtwROdnt2OSpBEZyRXl0pQKFwI3VdXbO566Aji9fXw6TZUyN/7KdjXTMcDd9h/m9+H1t3Ha+Vdz2vlXPzi9JEl7a1RXlHsm8HvADUmua8f+FHgbcEmSM4FbgRe3z30aeC6wCfgJcEYfcc6cub7DyiUH2neQNDAjuaJcVX2ZJqF0c2KX1xfw6j39vFlk30HSoHlFOUlSV/1UECR5CvCv2s0vVdU/DD4k9cLjHSQNWz/HQZwNfAh4THv7YJLXDCsw7ZrHO0gatn4qiDNprir3Y4Ak5wBXA+8aRmDaPfsOkoapn2WuAe7v2L6f+RvPkqQFrp8K4v3A+iSXtdun0BzboBGx7yBplHabIJI8juacSW9P8nma4yEAXotHN4+UxztIGqVeKohzgTcCVNXXga8DtEdVnwu8YEixqQv7DpJGpZcexGFVdcPOg+3Y8oFHJEmaCL0kiEW7eO6RA4pDkjRhepli2pDk31fV33YOJnkVzam/NUQ2piWNSy8J4nXAZUlezkMJYRWwH/BvhhSXWjamJY3LbhNEVd0J/FaSZwFPbIc/VVWfG2pkepCNaUnj0M/J+tYB64YYiyRpgvRzJLUkaYaYICRJXfV1um+NhiuXJE0CK4gJ5Km8JU0CK4gJ5colSeNmBSFJ6soKYkLYd5A0aawgJoR9B0mTxgpigth3kDRJrCAkSV1ZQYyRfQdJk8wKYozsO0iaZFYQY2bfQdKkMkGMmNNKkhYKp5hGzGklSQuFFcQYOK0kaSGwgpAkdWUFMQL2HSQtRFYQI2DfQdJCZAUxIvYdJC00VhCSpK5GkiCSvC/JtiTf6BhbnOTKJN9u7w9qx5PknUk2Jbk+ydGjiFGS9MtGVUF8ADhpp7E3AFdV1ZHAVe02wMnAke3tLOC8EcU4UB9efxunnX81p51/9YP9B0laSEaSIKrqi8BdOw2vAda2j9cCp3SMX1SNa4BFSZaMIs5BsjEtaaEbZ5P6sKra2j6+AzisfbwUuL3jdZvbsa3sJMlZNFUGy5YtG16ke8jGtKSFbCKa1FVVQO3B+y6oqlVVterQQw8dQmSSNLvGWUHcmWRJVW1tp5C2teNbgCM6Xnd4OzbxPCBO0jQZZwVxBXB6+/h04PKO8Ve2q5mOAe7umIqaaPYdJE2TkVQQST4CHA8ckmQz8CbgbcAlSc4EbgVe3L7808BzgU3AT4AzRhHjnupWNdh3kDQNRpIgquql8zx1YpfXFvDq4Ua05zoTAsD6W5rFWatXLLZqkDRVPNVGn+amkeb6C6tXLGbNUUt52erJW0UlSXvDBLEHnEaSNAsmYpmrJGnyWEH0wOWrkmaRFUQPXL4qaRZZQfTIvoOkWWOCmIfTSpJmnVNM83BaSdKss4LYBaeVJM0yKwhJUlcmCElSV04xdbAxLUkPsYLoYGNakh5iBbETG9OS1Jj5BOG0kiR1N/NTTJdft+XBazo4rSRJD5n5CmLlYw9k5WMP5E0veMK4Q5GkiTLzCcLEIEndzfwUkySpOxOEJKkrE4QkqSsThCSpKxOEJKkrE4QkqSsThCSpKxOEJKmrVNW4YxiIJNuBW/fw7YcA3xtgOAuB33k2+J1nw958539RVYd2e2JqEsTeSLKhqlaNO45R8jvPBr/zbBjWd3aKSZLUlQlCktSVCaJxwbgDGAO/82zwO8+GoXxnexCSpK6sICRJXZkgJEldzXyCSHJSkn9MsinJG8YdzzAkOSLJuiQ3JvlmkrPb8cVJrkzy7fb+oHHHOkhJ9klybZJPttsrkqxv9/VHk+w37hgHKcmiJJcm+VaSm5IcOwP7+D+1/01/I8lHkjxi2vZzkvcl2ZbkGx1jXfdrGu9sv/v1SY7em8+e6QSRZB/g3cDJwErgpUlWjjeqofgF8EdVtRI4Bnh1+z3fAFxVVUcCV7Xb0+Rs4KaO7XOAd1TV44AfAGeOJarh+Svgs1X1m8BTaL771O7jJEuB1wKrquqJwD7AS5i+/fwB4KSdxubbrycDR7a3s4Dz9uaDZzpBAM8ANlXVzVX1M+BiYM2YYxq4qtpaVV9vH99D88OxlOa7rm1fthY4ZSwBDkGSw4HnAe9ttwOcAFzavmTavu+jgX8NXAhQVT+rqh1M8T5u7Qs8Msm+wK8AW5my/VxVXwTu2ml4vv26BrioGtcAi5Is2dPPnvUEsRS4vWN7czs2tZIsB54KrAcOq6qt7VN3AIeNK64hOBf4E+CBdvtgYEdV/aLdnrZ9vQLYDry/nVZ7b5IDmOJ9XFVbgL8EbqNJDHcDG5nu/Txnvv060N+0WU8QMyXJo4CPAa+rqh92PlfNeuepWPOc5PnAtqraOO5YRmhf4GjgvKp6KvBjdppOmqZ9DNDOu6+hSY6PBQ7gn0/FTL1h7tdZTxBbgCM6tg9vx6ZOkofTJIcPVdXH2+E758rP9n7buOIbsGcCL0zyXZppwxNo5ucXtVMRMH37ejOwuarWt9uX0iSMad3HAM8Gbqmq7VX1c+DjNPt+mvfznPn260B/02Y9QXwNOLJd9bAfTYPrijHHNHDt/PuFwE1V9faOp64ATm8fnw5cPurYhqGq3lhVh1fVcpp9+rmqejmwDji1fdnUfF+AqroDuD3J49uhE4EbmdJ93LoNOCbJr7T/jc9956ndzx3m269XAK9sVzMdA9zdMRXVt5k/kjrJc2nmq/cB3ldVfz7eiAYvyXHAl4AbeGhO/k9p+hCXAMtoTpX+4qrauRm2oCU5Hvjjqnp+kl+nqSgWA9cCr6iq+8YY3kAlOYqmKb8fcDNwBs0/Aqd2Hyf578BpNCv1rgVeRTPnPjX7OclHgONpTul9J/Am4BN02a9tovxrmqm2nwBnVNWGPf7sWU8QkqTuZn2KSZI0DxOEJKkrE4QkqSsThCSpKxOEJKkrE4TUpyQHJ7muvd2RZEv7+EdJ3jPu+KRBcZmrtBeSvBn4UVX95bhjkQbNCkIakCTHd1x74s1J1ib5UpJbk7woyf9MckOSz7anPiHJ05J8IcnGJP93b868KQ2aCUIant+gOQ/UC4EPAuuq6knAT4HntUniXcCpVfU04H3A1B3Jr4Vr392/RNIe+kxV/TzJDTSncvlsO34DsBx4PPBE4MrmDAnsQ3PaamkimCCk4bkPoKoeSPLzeqjh9wDN/3sBvllVx44rQGlXnGKSxucfgUOTHAvNKdmTPGHMMUkPMkFIY9Je5vZU4Jwk/wBcB/zWWIOSOrjMVZLUlRWEJKkrE4QkqSsThCSpKxOEJKkrE4QkqSsThCSpKxOEJKmr/w+hdX3m9YJx8AAAAABJRU5ErkJggg==", + "image/png": "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\n", "text/plain": [ "
" ] @@ -63,11 +65,13 @@ "n_0 = 50\n", "model = pints.toy.stochastic.LogisticModel(n_0)\n", "\n", - "times = np.linspace(0, 100, 101)\n", - "\n", - "# $b_0$ = 0.1, $k$ = 500\n", - "params = [0.1, 500]\n", + "# specify model parameters\n", + "b_0 = 0.1\n", + "k = 500\n", + "params = [b_0, k]\n", "\n", + "# simulate using Gillespie's algorithm\n", + "times = np.linspace(0, 100, 101)\n", "values = model.simulate(params, times)\n", "\n", "plt.step(times, values)\n", @@ -80,7 +84,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, averaging the population values at each time step, produces a reproducible result which tends towards a deterministic function as the the number of iterations tends to infinity: $$ \\mathcal{C}(t) = \\frac{k\\mathcal{C}(0)}{\\mathcal{C}(0) + e^{-b_{0}t}(k-\\mathcal{C}(0))} $$\n" + "Given the stochastic nature of this model, every iteration will likely return a different result. However, the process has a deterministic mean:\n", + "\n", + "$$ \\mathcal{C}(t) = \\frac{k\\mathcal{C}(0)}{\\mathcal{C}(0) + e^{-b_{0}t}(k-\\mathcal{C}(0))} $$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now show that, in the limit that we have a large number of simulations, their overall mean tends to the deterministic result above. First, we perform 5 simulations and plot their dynamics." ] }, { @@ -90,7 +103,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -102,18 +115,10 @@ } ], "source": [ - "def simulate_n(n):\n", - " values = np.zeros(len(times))\n", - " for i in range(n):\n", - " values += model.simulate(params,times).reshape(-1) / n\n", - " plt.plot(times, values, label=r'$n=%s$' % n)\n", - " \n", "for i in range(5):\n", " values = model.simulate(params, times)\n", " plt.step(times, values)\n", "\n", - "simulate_n(1000)\n", - "plt.title('Stochastic logistic growth across different iterations')\n", "plt.xlabel('Time')\n", "plt.ylabel(r'Population ($C(t)$)')\n", "plt.show()" @@ -123,7 +128,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "By running the model 1000 times and averaging the results we can see that indeed we converge on the deterministic mean:" + "Now, we perform 1000 simulations and calculate their mean at each time point. We then plot this empirical mean and the theoretical mean and show that they coincide." ] }, { @@ -133,7 +138,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -145,6 +150,12 @@ } ], "source": [ + "def simulate_n(n):\n", + " values = np.zeros(len(times))\n", + " for i in range(n):\n", + " values += model.simulate(params,times).reshape(-1) / n\n", + " plt.plot(times, values, label=r'$n=%s$' % n)\n", + "\n", "simulate_n(1000)\n", "plt.plot(times, model.mean(params, times), '--', label=\"Deterministic mean\")\n", "plt.legend()\n", @@ -170,7 +181,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" + "version": "3.7.7" } }, "nbformat": 4, From 6694b4174acf478d835d131886926cb47db657dd Mon Sep 17 00:00:00 2001 From: ben18785 Date: Tue, 15 Mar 2022 18:49:56 +0000 Subject: [PATCH 38/41] cosmetic changes to schlogl notebook --- ...el-stochastic-production-degradation.ipynb | 67 ++++++++++--------- examples/toy/model-stochastic-schlogl.ipynb | 56 ++++++++++------ 2 files changed, 71 insertions(+), 52 deletions(-) diff --git a/examples/toy/model-stochastic-production-degradation.ipynb b/examples/toy/model-stochastic-production-degradation.ipynb index 12b37b1f59..9f54b2a331 100644 --- a/examples/toy/model-stochastic-production-degradation.ipynb +++ b/examples/toy/model-stochastic-production-degradation.ipynb @@ -6,33 +6,19 @@ "source": [ "# Stochastic production and degradation model\n", "\n", - "This example shows how the stochastic production and degradation model can be used.\n", - "This model describes the stochastic process of two chemical reactions, in which the concentration of the substance increases at one rate and decreases by another.\n", - "Given an initial concentration of the substance, $n_0$, the substance degrades with rate $k_1$ while its concentration also increases at rate $k_2$ following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n", + "This example introduces the stochastic production and degradation model.\n", + "This model describes two stochastic chemical reactions: one, which increases the concentration of a substance by a unit; and, another, which decreases it by the same amount. Given an initial concentration of the substance, $n_0$, the substance degrades with rate $k_1$ while its concentration increases at rate $k_2$ following a rate constant, $k$, according to the following model ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n", " $$A \\xrightarrow{k_1} \\emptyset$$\n", " $$\\emptyset \\xrightarrow{k_2} A$$\n", "\n", - "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pints\n", - "import pints.toy as toy\n", - "import pints.toy.stochastic" + "The model is simulated according to the Gillespie stochastic simulation algorithm [(Gillespie, 1976)](https://doi.org/10.1016/0021-9991%2876%2990041-3), which allows exact simulation of stochastic processes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Specify the initial concentration, and select time points at which to record concentration values, and rate constant value (k):" + "We choose the initial count of species $A$ size to be zero and set $k_1=0.1$ and $k_2=1$. We then perform a single simulation of this stochastic model." ] }, { @@ -42,7 +28,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -54,14 +40,25 @@ } ], "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pints\n", + "import pints.toy as toy\n", + "import pints.toy.stochastic\n", + "\n", "n_0 = 0\n", "model = toy.stochastic.ProductionDegradationModel(n_0)\n", "\n", - "times = np.linspace(0, 100, 100)\n", - "k = [0.1, 1]\n", + "# set parameters\n", + "k_1 = 0.1\n", + "k_2 = 1.0\n", + "k = [k_1, k_2]\n", "\n", + "# perform a simulation\n", + "times = np.linspace(0, 100, 100)\n", "values = model.simulate(k, times)\n", "\n", + "# plot the result\n", "plt.step(times, values)\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", @@ -72,19 +69,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute the stochastic mean $M(t)$ which gives the average number of molecules of $A$ at time $t$. This function can be described by the following ODE (Erban et al., 2007): $ \\frac{\\text{d}M}{\\text{d}t} = -k_1 M + k_2 $.\n", + "Given the stochastic nature of this model, every iteration will likely return a different result. However, we can compute the expected value of this process $M(t)$. This function is described by the solution of the following Ordinary Differential Equation (ODE; [Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n", "\n", - "We will plot the ODE solution, and compare it to 10 stochastic simulations to show that the stochastic simulation average to the desired function.\n" + "$ \\frac{\\text{d}M}{\\text{d}t} = -k_1 M + k_2 $.\n", + "\n", + "We plot the ODE solution and compare it to 500 stochastic simulations, indicating the correspondence between the two processes." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nOy9e3xU1dX//9kzk0kyuRBDiIiUAsU8lFKMFNEiUkopD6WUIqUUlYdSykMppdSvtYpoFUWttYrab2v7tdba/uqtWmtp6w3lLve7ICD3AHILEEIyuU1m//5YWVnrDDPJAAkXsz+vV15zZs8+e6+99j57Tma/z9rGWgsnJycnp5Yj3/k2wMnJycnp3MpN/E5OTk4tTG7id3JycmphchO/k5OTUwuTm/idnJycWpgC59uAZJSXl2c7dux4vs1wcnJyuqi0evXqYmttm9j0i2Li79ixI1atWnW+zXBycnK6qGSM2RMv3f3U4+Tk5NTC5CZ+JycnpxYmN/E7OTk5tTBdFL/xOzk5XdiqqanBvn37UFlZeb5NaZFKS0tD+/btkZKSklR+N/E7OTmdtfbt24esrCx07NgRxpjzbU6LkrUWR48exb59+9CpU6ekznE/9Tg5OZ21Kisr0bp1azfpnwcZY9C6devT+m/LTfxOTk5NIjfpnz+dru/dTz1OThe4rKU/LWPoz8npTOTu+J2cLnDFTvzxvgicktOMGTPw6KOPNkvZu3fvRvfu3RvN99BDD3ne9+nTp1nsaUhu4ndyughkDODz0Z+707+4FTvxL1my5Jzb4CZ+JyenT4RmzZqF7t27o3v37njiiSfq0x988EEUFBSgb9++2Lp1a336jh07MHjwYHzhC1/A9ddfjy1btpxS5oIFC1BYWIjCwkJcddVVOHnyJKy1+NnPfobu3bvj85//PF5++eVTznvuuecwZcqU+vdDhw7F/PnzMW3aNFRUVKCwsBA333wzACAzMxMAEpY7f/589O/fHyNHjkTXrl1x880342x3TnS/8Ts5OTW5+vfvf0raqFGjMHnyZITDYQwZMuSUz8eNG4dx48ahuLgYI0eO9Hw2f/78ButbvXo1/vSnP2H58uWw1uKaa67Bl770JUSjUbz00ktYt24dIpEIevbsiS984QsAgIkTJ+L3v/89rrjiCixfvhyTJ0/G3LlzPeU++uij+O1vf4vrrrsOZWVlSEtLw2uvvYZ169Zh/fr1KC4uxtVXX41+/fol5ZeHH34Yv/nNb7Bu3bpTPmuo3LVr12LTpk1o164drrvuOrz//vvo27dvUnXGk5v4nZycLnotXrwYN9xwAzIyMgAAI0aMwKJFixCNRnHDDTcgFAoBAIYNGwYAKCsrw5IlS/Dtb3+7voyqqqpTyr3uuutw66234uabb8aIESPQvn17LF68GDfeeCP8fj8uvfRSfOlLX8LKlSvRo0ePs25DvHKzs7PRu3dvtG/fHgBQWFiI3bt3u4nfycnpwlJDd+ihUKjBz/Py8hq9wz9bRaNR5OTkxL3z1po2bRq+/vWv44033sB1112Ht99+O6nyA4EAotFo/fuzfaI5NTW1/tjv9yMSiZxVee43ficnp4te119/PV5//XWEw2GUl5fjH//4B66//nr069cPr7/+OioqKnDy5En861//AgBkZ2ejU6dOeOWVVwDQ7+vr168/pdwdO3bg85//PO644w5cffXV2LJlC66//nq8/PLLqK2txZEjR7Bw4UL07t3bc17Hjh2xbt06RKNR7N27FytWrKj/LCUlBTU1NXHb0Fi5TSV3x+/k5HTRq2fPnhg3blz9RDlhwgRcddVVAIDvfOc7uPLKK5Gfn4+rr766/pznn38eP/zhD/HAAw+gpqYGo0ePxpVXXukp94knnsC8efPg8/nwuc99Dl/72tcQDAaxdOlSXHnllTDG4JFHHkHbtm2xe/fu+vOuu+46dOrUCd26dcNnP/tZ9OzZs/6ziRMnokePHujZsyeef/75+vQbbrghbrnxFp3PVuZsV4fPhXr16mXdRixOLVX8i4HPF//9haDNmzfjs5/97Pk2o0UrXh8YY1Zba3vF5r2Aho6Tk5OT07mQm/idnJycWpjcxO/k5NQkuhh+Nv6k6nR97yZ+Jyens1ZaWhqOHj3qJv/zII7Hn5aWlvQ5jupxcroApQOxWXvhx+dp37499u3bhyNHjpxvU1qkeAeuZOUmfienC1A88XP45Qt94k9JSUl69yen8y838Ts5XaDiiJxOTk0tN6ycnJycWpjcxO/k5OTUwtRsE78x5lPGmHnGmA+NMZuMMT+pS59hjNlvjFlX93dqfFYnJycnp2ZTc/7GHwHwU2vtGmNMFoDVxpg5dZ89bq1tnv3PnJycnJwaVLNN/NbaAwAO1B2fNMZsBnB5c9Xn5HSx62JDOJ0uXp2T3/iNMR0BXAVgeV3SFGPMBmPMs8aYSxKcM9EYs8oYs8qxwU4tQXrivxgQTqeLV80+8RtjMgH8HcAt1tpSAL8D8BkAhaD/CB6Ld5619mlrbS9rba82bdo0t5lOTheE3KbqTudCzTrxG2NSQJP+89ba1wDAWnvIWltrrY0C+AOA5tlpwMnJyckprpqT6jEA/ghgs7V2lkq/TGW7AcDG5rLBycnJyelUNSfVcx2A/wHwgTGGN7acDuBGY0whAAtgN4AfNKMNTk5OTk4xak6qZzGAeL9SvtFcdTo5OTk5NS4Xq8fJ6RxL0zvAmRE81soWjI4AcjpduZANTk7nWLG8/umGsNcT/Zmc7+Tk7vidnM6DGNvku/bTPZcn/jM538nJ3fE7OTk5tTC5id/JycmphclN/E5OTk4tTG7id3JycmphchO/k5OTUwuTo3qczquagmm/2MVMfqJQzPGQzVik0zH950aflPHq7vidzqvOlmm/2KUnjkSTSKxfEoVvbon+O9f6pIxXd8fvdN51Nkz7xa5k7xjZR4DXT47pP/f6JIxXd8fv5OTk1MLkJn4nJyenFiY38Ts5OTm1MLmJ38nJyamFyS3uOp1zxZIRyZAsFys2x0qmzYnyxy4iRqOndz5w8fuvuXS2ftIobSJxmRdSn7g7fqdzrkQ4YqI8FzM2x0qmzYnyn85n8fJ8EvzXXDobP51uP15IfeLu+J3OizSe2Fieixmb00qmzQ3lj4dzJnP+J8V/zaUz9VMyE39smRdKn7g7ficnJ6cWJjfxOzk5ObUwuYnfycnJqYXJTfxOTk5OLUxucdcpKZ0uihYvsBifV1vrzXuxoIbRqCzKMZLp88VHNROls7jNukydngzyGU+NRfo8GyVLoui+5tfTGSsX8nhIxtZEKK7uE+4n/tznO72F/7OVu+N3Skqni6LF5tGDPHYCvVhQQ213ba18gek2JEpPFEUzkS/OZPJLJtLn2SjZvjrd/r2QMMfGlIytidIT9Unsl/+5kLvjd0pap4uixYso6fPJ4L8QsLbTlc8HBALe9ujPEqVrxba5oTJPR+fiTjkZJFW345OIniZjayIUV3/u91N6JNI8djakRid+Y0wagKEArgfQDkAFgI0A/mOt3dS85jk5OTk5NbUanPiNMfeBJv35AJYDOAwgDUABgIfrvhR+aq3d0Mx2Ojk5OTk1kRq7419hrb03wWezjDH5ADrE+9AY8ykAfwFwKQAL4Glr7ZPGmFwALwPoCGA3gFHW2uNnYLuTk5OT0xmowV/rrLX/aeTzw9baVQk+joD+G+gG4FoAPzLGdAMwDcB71torALxX997JycnJ6Rwpmd/42wO4EUBfxPzGD+BNa23cJQ5r7QEAB+qOTxpjNgO4HMA3AfSvy/Zn0M9Id5xNI5ySU3Njc7G0SjzMjQkGa2lRKxr1omyJcMSm2FC8KSIxavu4DbW1VE4gcCqtk4jk4XIiEVkIrK2ldEZBNRYaayefG4tOJsICz9R/ZxJJNZnooYnOr6mh8/1+es/tia2jMfxR01UNlcP+1u91/7Iaw2xjqbV49sXSX1y3HgOJ1NSoZ4PFGWP+BOBZAFUAfgn6ApgM4F0AgwEsNsb0a6wSY0xHAFeB1gkurftSAICDoJ+C4p0z0Rizyhiz6siRI0k1xqlhNTc211D5iVBDfcEkytNUG4qfbfv1OX6/TE56kon9EotXX6L2JMJCYydqXUciTFbrbPyXDGIabzI90zoiEaFcEmGhyeCP2n/J4qXJ9EsySGYi+xKVeT4Q1sbu+B+z1m6Mk74RwGvGmCAS/MbPMsZkAvg7gFustaVGec1aa40xcZtsrX0awNMA0KtXrwuY7L241NzYXKLy+YLx+WTC1AijzhOvzKbaUPxs28/n6zswnqgSoZ2x52rFe4CnMbQz3t1kIJAYCzxb/51OJFU+PtM6GHMMBhP7NVn8sbFygMbHXyJEN55isdx4ih0/TYHxnoka+41/IwAYY34S+5kx5ifW2mpr7fZE5xtjUkCT/vPW2tfqkg8ZYy6r+/wyECnk5OTk5HSOlOx3zHfjpI1r6ARDt/Z/BLDZWjtLfTRblfddAP9M0gYnJycnpyZQYxz/jQBuAtDJGDNbfZQF4FgjZV8H4H8AfGCMWVeXNh3AwwD+Zoz5PoA9AEadieFOTk5OTmemxn7jXwIic/IAPKbSTwJo8KEta+1iAIl+7ftKsgY6OTk5OTWtGpv4i6y1ewB8MVEGY4yx9kIOq+SUSBpdA+Ljl5yu8TOmJXiRlhfFYhE1Lb2AVVt7Kr6pF+CacpGrMcSUpWkSa6ltvGDK6TU1XrsBKi8SEV/EtknXHQ8p1HhgbBA4jt4ZiyZq1LO6mtJ4EZPtTsYfifqd05KNqBkbbbUh+iZeVNKaGvmcfR2JAFVVVDYvgPLiaSTi9SWXq/0UiYgfNMoaOwY0Uqz9qsd4LGbLYyD2moiHheryuW4uUy8wx0NPtc4pzglgnjHmx8YYD7ljjAkaYwYYY/6M+L//O13gSoRUaiWD0zUlltYcUQqTtS92gufJSKcnsjURepoMUpgM2ho78cdOcGxfbL7G/JEMdngm5TT0LEG8cxLZkch/iY5Pt/0NnZ8MApooPVGfJlPOuYrU2dgd/2AA4wG8aIzpBKAEQDroC+MdAE9Ya9c2r4lOzaF4iN/pooaxKJrOw+LjRHXwHVBDOOLZKlmEMxAA0tJObVMwSOmxd9d8TmxdsV8C8RC/eFgo16nL5DxsB+C1I55NjSnWH41FD22sHP3wWGxb9HGiqKTal9x2Pg4EgFDI28540T9j/cT52c7Y/4TYtljfct16jMdLTzTeuT7dv1x+Q2MmEEiMnjaHGpz4rbWVAJ4C8FQdmpkHoMJaW9K8Zjk5OTk5NZeS/l6x1tbUPXFbY4wZY4xpMI6Pk5OTk9OFqaQm/rrf9G8wxrwCony+AuD3zWqZk5OTk1OzqDGOfxAoPs8gAPNAYZavttZ+7xzY5uTk5OTUDGpscfctAIsA9LXW7gIAY8yTzW5VC1RD0QATBTtL5px42J3ffyq6psvRqFw85K66WugDxtJSUuLn0Ugdx+lhHE+3ndG32tr4aGeiCJ7c7lg6Q2N2vHimMUBGLRnD5AiJ0ShhhNXVlFZdTW3j8zkPY3rRqHchUS/+Mf4ZS6FoxK+mxkvvaIRTl69j4WhMtKpKkNKaGkpnW7k8TovtIx0VMhl0V7cttg168ZRt57JiF7gZQ+XxUVkpC73sj2iUjnl8VVWRTZEIEA6LL6urKT0lhfJwf7JNnI9t4jbrccptr6yUsVVVJWOF82hE1++XfklNPdUOQNJ1OdxmTk9Lk4ik3J+MsGplZ6NJ1dhPPT0BLAXwrjFmTt3Ttv5GznE6AyUTua+hKIjJHCdC15LByRIhdImiKTaEpSXCFpPB/RKhcrFcOE9wiRC9eGx8vAiRyfhSKxH+maj9DUXhjGdbbL5E/ah9UF0tX06ni+gm09cN4Z+JEMtkkMxEbUuEsOo2J3sNJaovUR2J6tPpifytj3WeZPzV1GqM6lkHYB2AacaYPqCffVKMMW8C+EddBE2nJlJDkS0T4YiNncPSeRrC0vSkFQ+11MidRh8bygOcereo69BRO2MjKsazKR6Gyn86P9cNnIoBatQS8MZ/9/uB9HS6y+K7S11uPMQyto5YNC/2P5d4iJ+2j32RCC2M9bM+5nJTUgiF1PkT1ZcMuhvvXN1+Pd54I/FEY06PD11uPD/pftRYrW5bKCTl6H4AvLik9gXbyedwubqOQMCbh8tNhPempdF/Dnys26/bzHn4P7HY/LptzaHToXqWWGt/DKA9gMdBu2o5OTk5OV1kanDir9tAxSNrbdRa+461drwhtW8u45ycnJycml6NLe7+yhjjA4VOXg3gCIA0AF1A2ycOBHAvgH3NaKOTk5OTUxOqsd/4v123QfrNoNANlwEIA9gM4A0AD9U93evk5OTkdJGo0c3WrbUfArjrHNjSosUr/hqvZMyOF8riBZhi6U2qNUKn0zV2x6icxgW5HMb/GKELBuVcjprIOF9ZmSzCVVSIPRrRi7WvooLqZrKB47HoKJeMdTJSyRgc+4jboG31+WhRtqJCzq2qEhyzslLSS0uprMxMqq+8XBYjy8rIH2lpwMmT0qZwWPxUWSmL0pWVgvqFw2R7ZSUdc3sqKshWXtjjdPYx+6+21uvvtDRZYGZx+1JSgGPHpK9LS8W+cFj6JRz21sFjp7ycXtPTvWiixhHLyihPKET5jSGfcb9xG/RCuUYe9WeMyLIdjG2ePCnjuqyMXgMB6Ydg0Itwsh1paZSHx0pZGdmsrw/GXAHpK40Mnzwp197Jk16f8cIy913sGGe/BgIyfrid1soY4LrZ35GI5E9Lo2PGRUtK6PzYxd38fDSpGp34nc6N9MSfLIqmxRNx7MSv02OZfo3KsWKRQJ749ebisViaDi+r25PIPk3mVFbKxB8P1WR+PLa+QMBrK3/RpKefigdq/p0v+HDYO/HrZwu0PzRyp5n7RBEe4z03oX2Zlia8eUZG4j7hL0pNvWibeOLXNulj7X/9nIZO5y+s9HQ5l9lzgI7ZT6GQTOKZmV6beLzF1qfHovZ/MOhNZ9/ESqclqo9vYGL9pwmj2Buk2lr5guBxycfxxrK2L5Ff9bmxYZ/1cTwyT5fPN0PNTfW4if8CUmxkxngRK+NtfM14IqOQGiHjCVsjcYlQuVg0UWNzGsVLSaG/zEy5o9ETVCyiB3jtYPsbii5pDNURi/LpY10O2xEM0kWdmup96EVHe8zMlLJycuiV25eZKahdKCR3oKFQfExP2x2LF+pjbqcuPxgUn2uf8ZcRp+t6AXqfmkq2s33Z2ZIvM9OLHfIkp/tRt037SU/qmZn0XwT7idug8weDXqQU8GKViaJtaju4XbF16/Gnjzm/bptuP+DFe/mGRV8P3D88brKzvXXoPoqHnsb6Vefn9LQ0b//q/tHlcJ5QSP6a+g4/Vs0c/NPJycnJ6UJT0nf8xpjLAXxan2OtXdgcRjk5OTk5NZ+SmviNMb8E8B0AHwLgXy4tADfxOzk5OV1kSvaOfziA/7LWVjWnMU5OTk5Oza9kJ/6dAFIAuIn/LBVLgOjoiJoGYLwrXoAnTSHoSIFMBcUiZwClM/pWXS2oHEA4GZfHFEdaGi3s6Vg9XBfjdIEAIXCMIJ44IeUcP07pvBAYDks5GgUsLxd8UGOEjE5mZFAev5/KOnqUzs/KEiIoM5PSGU8tKaGFYZ+PjrnOw4cpTzgMFBV5EcSDB+mzsjLKZwyVf/CgYJ7FxRIJkzHW7GzBADmd8dtwWBbxjh+XPjl0SPqwtFRsOHZMcL/iYvJHVhbl0ZhicbH044EDQoscOiSLkUePSl9w26qrgSNHKO2SSyhPRoYs4tbUUB5GRNmXPp/4mNvD6dzX1sriqMY+i4spPTubxmUwCLRq5R0rxcV0HAhQ3bwwyz5mbBOg88vKpK6SEkoLhagNvMm6xntLS8W+w4cpDy+0HjtGYyUYpHbwNXTkiNdnOg9fJzweuBy+Vo4dkzo4TzRK6WwHj4fqasrDY+bQofj0T9u2aFIlO/GHAawzxrwHNflba6c2rTmffMXy+nrfUr1XazLS2Fy8LwbAS8owypaeHh9ZzMiQL5C0tFM3+Oa6EkWH1Ogjh5eNZ0csmhd7fmqqF02sqJCJv7Iy/sSvy2HOneviY+bk+Vj7WX+m69a4aqJ0RklbtfKGBtbSfcJsPJ/LEz9/6ebkJI78yHbEizjKeCaXBQCtW3vbxpPjJZckrkO3UwdtY4w0nl/0eNLYp45CmQiX1ONBl6vr1nkShevWfa3xXn5WgseMLis26me8KKFVVV6cWEduZcWOdc4TG3Y7Hhaqx4y+WWhOJTvxz677c2oCMWYWLyIicOpmzbF5NC/Md62JkDONk2n0jaXxQo3Q5eR4MUWuUyOVjJ5xfi4nJ0cmHsbS2L5YFDAtjf7y8iRPTo7Ul5vrtS8jg/7atpU8sfXxscZN8/IETWzXTu4y+U6K7yg7dBD72rcXf7RtK/7QqJ22T0fzTEvz+obPzckh+9km3TaNmHJ627anoqfx2tqhg5yTm0t3wnx87JiUxekdO0obQiGvTdzm3FyxOzubJk6ul9NzcyV/Xh698rjWvmnXTuzIzfX6j32fm+vFK7V97INQSD7LzT0VheR0tkH3SU6OtJ/7ncdQdraMD92mtm29NsWOa2639hO3OT/f6xu2KT9f6s3L89rHPm7qO/xYJTXxW2v/bIwJAiioS9pqra1p6BwnJycnpwtTyVI9/QH8GcBuAAbAp4wx33U4p5OTk9PFp2Qf4HoMwCBr7Zestf0A/DcoJn9CGWOeNcYcNsZsVGkzjDH7jTHr6v6GnLnpTk5OTk5nomQn/hRr7VZ+Y639CET5NKTnAAyOk/64tbaw7u+NJOt3cnJycmoiJbu4u8oY8wyAv9a9vxnAqoZOsNYujLeRS0sXUwSM7Wk0k1f/OfolY5qMtIXDRAnwVm1MpoRChMfxAnBJiTfaH2OOR48KcsY4Hh9zncXFgi8y1ujzeTHK48epnLw8YO9eacOePYKu7d3rjT3ESGE4LFjbJZcAu3YJ4sZoYps2grhdeimwbx+VW11N5TJat38/+YPxTIDybN4s/v34Yyq/pATYvl3O5XReMN2xQyItFhXJVn379gmNUlTkrZtxv127JCIn21pZSWieMbRQd+AAlVFdTXVHo7QQuHMntaGsjMoB6NwDB2jBlW0tL5fF0d276bW0lI4ZXd2xQ4K7bdtGr+EwsGULtS0cBj76iBb509KoPRzT6OOPJWrlrl1kJ/vV7yebdu6Uvi4qovylpWSrjlm0ezed364d9TtDBfv3U55LL6V0PmfvXjl3xw7BJQ8epLovv5xs4sipBw9S3rZtveOkqEjG3IEDMh6KiqTMvXsF/2RbGc3cu5fS2efsD/Z3MCg+Li2VMdehA/nGWqBTJ2pnSgr5bPt2sqG0lOzmevfskX7fvFnG0tat3lhCLL0Y3xRKduL/IYAfAWB8cxGAp86wzinGmLGgL46fWmuPx8tkjJkIYCIAdNCoxUWuhja4ZjEyxuFyeeKvqvJO/LGRD5kUYHwttj6eFLgOjePpjbnj4YscLjYri7h1nvg1QnjihDfqpiaVNFKo7dMheRk1bNPGi7hpOzRap+3WAbpOnJA8ui6NeaakeH3OoXfZl6xYHJSPNa5aXh4fE2V/tG0rTDrg9Qv3KeBF/DhccGw7AaFg+DN9zO/1TYX2QaKNw/l5jMsu83LyfLPQqZOgvlwXn6vHAED9yBO/roP799JL6UssGKRJUyOM+vjQIZn4S0qojk9/2tt+fsYj1n86lHUswqkVDktejdnGto91/Dh91qGDEEIdOsjNTKdO1O98jYbD4ktuvy6nXTvveNXXaHMqWaqnCsCsur+z0e8AzASFe5gJWjsYn6DOpwE8DQC9evVKEIz44pRGNWM37NYRBGOj+HHUScbhNCKpoz8ylqbTNTqYne2NOqkRSZ2fL4jcXLr7B7zYIN9xAYQ+fvwxHbdrJxcFY29sU3u1UWf79lJux45iU9eugu917CgXQseO8VFGnd6xo9yhdekidXXp4rWB28D3FHwX2bGjF+Xju+yOHeX8/HxvWeyDzp2lXJ2/QwcvSqrTdZu5P7t08fq+tJS+DPmujz/r2lV8w5NPbHq3btKeHj3EH7qdublejJD7sUsX8Yue6Dp3lvK1j7lvuU91P2qEtnNnOc7Pp2cNYttQUOAdG2xHly5id5cu3vbztaJ9rI87d5YvXR6XbEe3bt6xxf2ix2j79nKXX1Ag/igoEPu6dvWiwdyebt28mCf/p9mxo7dMtrWp7/Bj1eDEb4z5m7V2lDHmA9Bk7ZG1tkec0xLKWntIlf0HAP8+nfOdnJycnM5ejd3x/6TudWhTVGaMucxaW/frG24AsLGh/E5OTk5OTa/G9tzlSXqytfYO/VldxM47Tj2r/vMXQRuy5xlj9oE2Ze9vjCkE/fewG8APzthyJycnJ6czUrKLu1/FqZP81+Kk1ctae2Oc5D8mWZ+Tk5OTUzOpsd/4fwhgMoDOxpgN6qMsAO83p2EXsmL3wQW8AdYYaYwXhVNvcs5BuRhTi0Rk82XeIJwJiepqIix0XJ6DB4nYuOQSwgg5uuSBAxK4raiI6rzsMkLiOEYQ43jhMCFqjHDu2SNbHu7aRZ+XlQGbNgkG99FHtFBVWQmsXk22lZQAy5YRiZSdTemVlbJYtW0bLUxHIoSslZfTYtmGDRJ/ZeNGsjUSIcSNIzRu2iQ44tq10s4dOyQ2EZ9bXU35AwFa2Nu4kc6NRIA1a6gMxuw40iMArF9P9uXlUb4TJ2iRc2Pdj5ElJcC6dXSOzwd88IH025o1gnNu3EjlBAKUh+matWvJvpISajNvJv7BB4Kqbt1K/gsGKf3IEVpY3L6dfFRYSLasWiVbGK5ZI1EgOT0SofZwhNB162R8rlkjUAH74+OPKX9KCtmxerWM6w8+oNdQCPjwQzmX23P4MOVhZJbrSE8n0GDDBrLv8GEqNxql9/PnC864bh35LBqVNgDUj34/LYZ+9JHgt1u2yNafjNL6fFROVRXZ8eGHlJ9xSaZstm6VscT9zluWfvABUVmVlVQHbza/ahWlh8M0xvk6WLxYCLz58yXq7ZIlVMe+fTQeMl92P6gAACAASURBVDIoz5IlMmaWLqV6jh2jcrjNK1fKta/Ffd9UauyO/wUAbwL4BYBpKv2ktfZY05py8Ygnfp7gAdnMHPBO/LFRODXeFhtZkSf+eJuOA16cDiAEjyd+jUvqL6YTJ2Ti1yGANa6mUUONS5aVyQWisbTKSgmhrPG7kycFJ+QvMlZ5ubwvL5fQ0dGoNyokl3v8uDdstN5UnfOXlAjvXFHhRRtZ/MXD5XAbNOLIdrB9J07IF8LJk5InHPbij+wnvQ/yyZPe8MQ6YqpGFhlBrKiQc7V9Gi1klFa3Q/eX7gs+R5er8dFwWN5zKGaA/Mr+0Pbpcc2hg/lc7kPtIy6Lz+fnP7hNGnVlWevFYWODELL/9AbrLH09FRd7o2LqSKVMzmm/8mcaieayjx+PP7ZqasS+WGw4Xt0a762slHJ06PRoVNLLy70huJtLjf3GfwLACQA3AoAxJh9AGoBMY0ymtbao+U28MMUXu46wGcvfJorCyVy+RjB1FEmNWvLG27E4JiAYZvv2ck7nzjLINYpWUCBoWYcOXiROI4tcTn4+IYQAoWga52R0rUcPucvr21ewtK5d5fjaa+mVL4quXaWtPXvKRVRQIGhdYaHU0b272Kfr691bbO3SRRDEwkKZ7AsK6K6L692+XWxlzJDvpDSq+OlP03H//uLzPn2k3O7dxT59J1ZYKG0oKBAfFBZK+3v1Ert79RJfFBZ6++czn6HjwYNl/PTsSa/c1q5dpb6+feVYl9url3zZFxZKP3bvLsf9+0sdvXqJL3r29NbNE6Hu3z59pD3c1/y+oIAebAKov9i+3r2lLwYMkPHaq5d3DHAb9NiIxSW5T7p0obt07Sc+5j7s2tWLV2pfdukiY6VvX6mjRw/xU9++3v5at058wONhyBCpb/hw8b1uW79+Us7gwZK/Xz/xfVPf4ccqqZANxphvGGO2AdgFYAFoYfbNZrTLycnJyamZlGysngcAXAvgI2ttJwBfAbCs2axycnJycmo2JTvx11hrjwLwGWN81tp5AHo1o11OTk5OTs2kZHHOEmNMJoCFAJ43xhwGUN58Zjk5OTk5NZeSnfi/CaACwP8BReZsBeD+5jLqQlRssDNGyHRwNKZuAgGhJBgJq66WzZo5wBlv/s2RHHkxmDd0zsoiNNNaQRA1Irlhg2zwvWWLRPPcsoWogU99ihC1jAxazNy0iewLhQSRLCsjhMzvpzzLl9O5xcWErnGZ8+dL+5culY2rV66kNgaDhPhFIrQwvHgxYWkcE2XFCnrlfGlphOatXk3t0aiczwe8/75snL1woeCvCxcK/jhnDpXJyB1vNP7OO0RZFBeTHZy+eDGdm51NbeDokgDw3ntCXyxeTG3NzgYWLKC6g0Fg3jxBa99/X3y2bJlE5mQ/paVRfhaXc/gw8NZb0qdLllC94TDZwJudL15Mfg2FqM28YTxA5/Om79x30SjZxFTWihWyreWiRZT38GGqg8fM0qXk68pKqoMjty5YQHWxfSkp5KcVK+jcXr2orkCAYvssXCjYL7c1EKC0+fPpfG4Hk27c7rZt5djno3brfucIngsWCJbLY6O4mI5ra2kxlOvy+Wgc+3yUZ9EisquyEpg7l65fXpxevdrbR7W1tMD63nsy9hculOt0zhyJertggYAa8+ZJf73/Ph137izYJgC8/TaVc+wYpaelybjkeWPRIvIFx/Jh9euX/FyVjBqd+I0xfgD/ttZ+GUAUtBNXi5NGOBkhiyV59MTPuGBqqkwWwaA3siVHRGzd+tQvEB0RUqOMOlKgjhDJFxQgmCcg4V75mKURtXDYi3/GixRoreTXyGfsMw36XI1Lars1dqixQI2rajxOo28a5auujo+wsl/5XPZFbITL2OicPPGHw0Jj6Iic1dXevmBksbTUi9xyug61zWGzAUL2NNbH6bHRIeNhhrH5qqu90VrjbXxfWupN1+2Jt3m8bmdFhfj/2DHvZuTczrKyUzeDZ5/ryJi6f3VkWY1U6qiazPwDsoE7H7M/mILh8vWY1vgnt033J5fFtJK+lnmiB6i/4kWHZTxb18/1xYZYj607EhEfRaPem8pYhr851GgV1tpaY0zUGNOqDu9ssYqNqqk3Hg8EvOk8gEMhGkChkHcTbL3pdn6+d6NsHR1SRwlkFK17d3rVWCAjcT16SN3XXiuDqFu3+FhkYaFEs+zRQ5C2/v3FDo0KavRvwAC5aK69lh6yAYCBA6UuxtLiYX2dO1MYWwAYNMhrN6N5uqzBg+UOfeBAsXXYMMFe+/QRzG7ECMnTr5/Y0K+flDlgAL0yXti/v+Tr04ceRuJ8jP4NG+bFWPl46FA5HjjQe8y+GTJE7Bs+3Ns2rnfkSPFFv35ydzp8OL2yTcOHS1/o9o0cKeOpd285f9Ag8f3IkTIJDRniRQ0ZTRw6VFDGAQNknGgEsWdP+o8HIH8D0qZhw8Rn2r7Bg704J+fv00cemNP+0zZp5HHwYGnbqFFi65AhkmfQILlOBg4Ue0aPple+hgcORL0GDpSyhg3z+oPH06hR4oPRo714psZ42TdDh0r7b7pJfD9woPh+6FCxtanv8GOV7HdLGYAPjDFzoH7bt9ZOTXyKk5OTk9OFqGQn/tfq/rQ+UTHynZycnFqKkp34c6y1T+oEY8xPEmV2cnJycrpwlSzH/904aeOa0A4nJycnp3OkxqJz3gjgJgCdjDGz1UdZAD7xQdo0KRKJ0LHfL7RGNCokQSQiGGZ1NeGZ/Pmhun3HeLNwJig2baL0QIAWu5iS2L1bIlBu3CgblK9aJRt5A4SmVVRI5Ei/nxY/GUsLhwWtS0sjbK6sjMpaskTawqhcNCrHHGXQGCpz0SKyOTNTkDPG2HhfWsbsMjMJh9PBwRhtLC0lPM5aWgRbtEg2Np8/X2iKt94SvzNqGI1Sm5mkeOstQe6WLqV+WLFCoh0GApSfF6kZv6uspEU3pmEAOof9OmeOLOTr+t55h+z++GPBOcNhOk5JIZ/NmydkyTvvkM0HDwJvvikI5rJldPyXv1D5xpDP3n+fym/blvzHpNYbb0h/AoRwAsCzz5LPuE1z5kjkVz6f7eNongsXyph7+20iSxiN5fHwzjsyvt96SyJhsn35+ZReU0MLkzzG2raVvuYtRRcsEDpMo508/nJzyVYe7/PmyWbj8+YRABEK0blMzHE7Gbv0+QiWWL6c7H7pJcFzfT7BYfl6qK0VGGLxYhkDS5bItbJqFaUxrsrBEt99V+aEuXMpb2YmpXN0WL4+8vLIZz6fYKt+P/DqqzJGc3LEJu4TwEvBAcC4cWhSNfZTzxIABwDkgfbHZZ0EsCHuGZ8gxSKcPPFrDDAWoePVer0BtUbU9ObdJ096cT+e+DWOqMvU+CZAk6jeqJwnMl23Rtw04qc3Q+cvLraPz43F3vhi0Shf7ObnGq/UtrIPuW79hZqoLK6fJzOAJgfOz/w74MU2tX0au9TticX6tO0aydSoXexm45xeVuaNeqpRPi5To38+n0RgjMUoddRN3e96zPGzDgChhiyNoWr8MxyW+vjLB/COOQ7JDNBY4jZUVEgduq90pEkulxUIeBFctkmPh5QUb1TW2GuK26mxUJb2qx7HwaDYpMeAMd4xoHFJjXpyXboeQG7guFw9HvSxvs6YdtNj1xgpMyXFe67GsuNFmW1qNRadcw+APQC+2PymXJjiuwYOEcuboQOUrjdGZzwzL0+ww7ZtvceMiXXp4t0UXG9qzXiX3iC8Z09vZEpAkEeNOfbtK8jagAGCn/Xu7UUhuY4BAwQzGzFCLrBRo+SCGDnSiybqiJVsw6BBXoyS848aRa/8pTF8uEzWkybJRTFqlJwzerSUO2GCXHSjR3txOsbmJk6UPFOmyIU9cSKwfz8dT50qdk+aJNgcI5KMF06cKHjhuHFS35Qp8p/b7bdLfZMmSd+NHi3ljhkjPp4yRdKnThWEcOxYyTNqlPwHOGIExZPncnQ7Aal7/HjaPwEgRJD7cfx4yaPbM2SI2DpqlKCTY8eiXmPHSt2jRws6qnHJoUO9/cN+ZZyT7R07VuyYMEH6fdQoGYs33SS+GTdO8owZI2NjyBDpnxEjpA1jx9I+D1xmPLxy9GiZhIcNkzIZ5+QvweHDxY6+fQXDHDZMUFw9biZNkr7T/TVpkvhyxAjx0/Dh9MAl4EVphw2TMTZypLStqe/wY5VsdM4RxphtxpgTxphSY8xJY0xp42c6OTk5OV1oSpbqeQTAN6y1m5vTGCcnJyen5leyVM8hN+k7OTk5fTKU7B3/KmPMywBeB1C/BGKtjX2oy8nJycnpAleyE382gDCAQSrN4tSneS86NbRxOhMuPp8E1kpLkz1qo1GKnlleTlgWY5ilpbSow3nWrhUkc/VqSucIj+GwbFTOkft4U+qdOwlRCwRo0WfuXO/ercuW0fvcXELfOHoh426AoHnhMJVrDC1KcYRIjgrJbX73XVok+/hjws/S02lRb8ECWdzmaIVFRYIsFhfTMUB5GHvjBTBGQ7dvl3ylpYTpcSRHxuaKi6k9KSnA739PKGQgIEhhbS0t2L3zjlBS8+bJNpfz50sUzlWrKO3Xvyb/BYOCS1ZUyH6x+nxd7ty5lP7ww+KDX/+akL2UFEIHeQP4p54iHK+6mhbsGHOsriZ/cBynd9+lcxkPZN8zsuj307kpKcATTwhy+NRT9DpnjozVRYtkAZV9HolQejRK+PA77whpw1Ehq6tl8++HHiK7a2pogf6NNwS75LGUmirY5e7dEvXU56N0QBZOGbHMzaU+ZRqKMcdQSHwTDJKPuT2MofLYra2lschRWXlsGUPnrlhBac8+S3bz+Jk/n2xOS6Pyq6po7C1cKH3CPotGaSy++65E/Zwzh67rEyfonPR0as/ixTL+liyh41mzJJLoc89R2yor6brm65Kjp/p8ZCvXVVoq/uMIsBzzS2vy5AYmsTNQUhO/tfZ7TVvthaNEG6cD3g3Ta2pk4tfY3YkTMvHrDc/1xuYnTng34NYYJefXaJ2ORFhSIphmVZV3QOgIh5GId/N03T6mHU6e9CKZjJbxMwqAd/N0v1/O5YuO8+jIh5xfRwjVyCa/13br6J78md5Q2xjvBtRst454qZFHjclqO6z1bjqukU2Nt2pMr6JC6uO8sdLRSn0+L57K9lnrxfe0rXyuxlw1LpqSIv7WOCKXy2XFYrOxNzGx9vM4Zj/pTcHZ1kBAxhyHama7uS7dzliFwzRRsm/Yl/oa0zYaI8e6LXpze41han9zaHQ+V19n+pjbptFJfq8jrsaLwqn7S+POerxqX+oxp/shEhGsVkfE1eUEAhcAzskyxhQA+B2AS6213Y0xPQAMs9Y+0KzWnSPF2zidX3ng8l9OjneT9FCI/jp3FoSsa1cvtsmY3bXXClrXq5dgXMOHeyM/Mn6mI1DqCIpDh9KrxusYA7vpJmDrVjrWCN6kSXKBjB4tiNqUKVLuhAlix223AU8/TccTJ0r0y7FjBcWbPFnOvf124b1vvRU4ckTSAbmzvu02etANAKZNE5/fdpvUMWmSlDVpkqB8Y8cKKjh5sqCM06ZJ/qlTxb6JE70YJeOiY8cKynjfffTKk8Htt4t9d98t6OVtt3nLYkx09GivTZzn9tuBu+6SY/b9LbcAR49K27jfbr1VcNF77vH6nsV3fVzHlCnSv/fdJ3XMmAE88ojUzZPeffcB06dL3Xzu9OlyPGsWtRsA7r9fJqeZM6WvHnwQuOMOsZvTp9aFbNS4JU/6GrGcPFnG+Nix8sWv+2vyZBn706ZJ2yZPlutzwgTx/fjx8X15003S75Mniw0TJtArX4+TJ8s5uo9mzpSJePx4b19zWbfeKmNm3Dj5ghozRtp/660ylsaPF5R74kSvTexL3e/NoWQXd/8A4E4ANQBgrd0AYHRzGeXk5OTk1HxKduIPWWtXxKRF4uZ0cnJycrqglezEX2yM+QzqQjEbY0aCQjkklDHmWWPMYWPMRpWWa4yZU/cw2BxjzCVnbLmTk5OT0xkp2Yn/RwD+H4Cuxpj9AG4B8MNGznkOwOCYtGkA3rPWXgHgvbr3Tk5OTk7nUMlSPTsBDDTGZADwWWtPJnHOQmNMx5jkbwLoX3f8ZwDzAdyRpK1NJo1wxq7Ma+KEEU7eJB2ghaW9e4nCycujzcxTUmjhZs0awTPffJPO3b1bkMxwmLC5SIQWovRG2UuW0OeVlRTTIxikc3lz6LQ0weR4oevNN+lVo2h791K+1FTgN7+hPIyAvvEGvR45IhhbJEJoJ7edNyTPzZX0khLBQrdsIVuzsigP211TI5ufGyNRBnkhjt/X1gpKWltL5wQCtPjL7du1i+oLBin+0aJFtED5859LtEifD5g9WxbluZysLMFCs7OlnbxhvN9PflmwgOz5+c/plW2ylvwEkA950/P8fOqXykpBLGtrgTvvlGiexcVRLF1aCyCCqqpazJ0bRFpaEE8+WYM33zwKa2tx/HgUc+fWIhqtRXV1PpYuzUI4XIb9+3dj0aIorI3i4MEotmyJIhTqgrKyHPznP8dQXv4hPvrIwtooVqyIIhKxOHq0J+bOzUE0+jG2bduANWssolGLoiKLtWstsrOvRyTSCm+/vQulpeuwY4fF+vU08Ldutdi+fTACgUwcPrwF//rXegQCFgcPWqxcaRGNAmVlN2DhwnRUVa3Dli0fYP16AKDyly4FLrvsZjzySACzZ6/AiRObsHw5lb1hA2CtQV7e97BwIVBSsgivvLIVW7ZY+HyEv370UQouv3wcqquB5557FxUVOzBvHl1PxgBbt2bgo4/GIBwGRo16A8uWFcHns1i8mGCJlJQcHDhwI95+Gzh27B9YseIAPvqI+nf1amD9+nyEQiNRWQnMnv0yfL5ivPUWLeqnpgIHD7ZHYeE38c47wN69/x/mzDmB7dtpHC9ZAuzc2Qlt234dl10G/POff0RNTQU+/JDiKQUCwIEDBdizh+j2Vat+h5UrI4hG6ZrevRto1ao7tm37MhYssDh8+DdYsYJQWWtp7OzY0RNZWdehuroKr776NIwhlHPbNhpXa9Zcg/bte9fPWbzg3lRKlup5CMAj1tqSuveXAPiptfZ0zbnUWss/ER0EcGkDdU4EMBEAOnTocJrVNCyNcGrcSn8hAIK+BYNeDK28nP7y8ryRBU+ckKiENTVCKFRUeDfv5jxsA+D9AtLImI4+qJFFPp/fazyMQxVzfUys6CihsdEOuY5oVJAzjUuWl3t9oyMZajxVB7CLxQw1HhfvuKpK/KTxOL9fbOIvK2stfL5aVFQE6uzbDGPKsXNnOQ4fDsPaMIqKPo2aml4wJoqFCx/Dnj2ViEYr8Y9/VKGoqBIZGQMAjEB1dRl27vwfRKPVeOGFahw5Uo1otBpr1/4vfL7xqK4+gJ/97HqcPFkDayNYujSCysoIPvWpBwD8EBUVm/Hhh5/DqlXioMWLgYKCP6B9+wnYu3cNFi++FgCx3KzOnV9CTc13UFGxHM88I5u+MnHVo8d/AAxBcfFCbNhwA5Yvh0dXXbUAKSn9cOjQe3jpJYm0xhRUYeEaAFehtPRNFBX9qJ5IAejLtaBgG9LTu2Dr1tkoKqL7LybQAKC6+iCsTUdJyd/x6qsC8HFgtDZtvg0ggP37X8Du3U/Wk1IkH4DvwVpgx44/Y8GCP9Z/snEjEAhko2PHcQCAoqI/YP/+v9UH+QOA/fsvx5VXjgEArF79G+zdS3c5THKlp3cFcCMA4ODBWdi+XeIrb98OhEJX44orRgIADh16GBUV6zxtAwagsPCbiEaBPXvuw0cf7VB1A61aDUPbtl+v88l0VFcfxg7JgszMm5GbOwjGAK+99lPU1NBFzbTO5ZdPAvBl+P0WmzdPxWYV9+Cjj4D27X+G7OzrEIlUYseOqfV2s9q3v88z8Te1kn2A62vW2un8xlp73BgzBMAZfw9Za60xJuH2jdbapwE8DQC9evVq8m0eYxFOTuOHSoD4CGdODt3p5ubSpuc8uXfpIhuH9+3rRRB5wh0+XNLHj6e7SMC7ifPUqfSAB+fh/Doa4Pjx9MrYosbP7ruPcECAcD/GM2+5hR424zyMP95/v6CWM2fSg0qx595+u+B+Dz0kd8ljxoh9M2YI9jZjhvjrwQfFtwDwwAP8hRvFXXdVAKCQpoMGzcOGDR+jouIYMjNLkJp6HDk5n8H06T9CZSXw4otD8Pe/78bevaWoqSnDmjVl6Nz5O/ja157Hr34FPPnk1aipKa+flADgmmv+F1/6Ui9Ya3DPPcSV+nx+HDmShmg0FV26tMbMmSMQDvvw3HM7EAikol27IGpqUuD3Z+Hb3w7i44+BcDgV+fnXYPv2FPj9KbjyygA2bvSjR4+u+MUvgHC4DXJy7sKgQQEsXOiHzxfAoEF+7NzZG5deCkye3AmbNz8FY/y44QY//vEPH3w+Px577Bq88AJQVvZ53HffK3jrLR+MMfjGN/x45RUfLr/8C7j1VqCkpA+uvvod3HijDz6fD3/9qwFg8NhjPfD440B5+WB861tL8PTTBsYYTJpk8NvfGrRuXYDp04Hi4lEoLe2DH//Y4I9/pHP/93+B3/3uU/D7gXvvHY977/0GAODHPzZ46inKM2tWa9x7LxAO34IpU8Zh1izy609/ajBrlkGrVmm4/XbA778HlZW3YMwYqv+xugDut95Kr1df/QjGjZuBxx8HjDH4P/8HeO45g1atCFs8fPh3iESewA9+QOMLAO6+24df/5rr+ytmzKABddddBk8+CRjjx3330fV7/fX/xO23R/CLX1D+O+8EHn00gPR0Guu1te/B2lrMmEHjncZ6CnJy6AuwsHAFpk+P4le/os9+9jNg5swgUlMJ2ywq+hDW2rp0Hsep9e188cW9eOABtpv+owwEUnHXXcA99xj07FmMadMEHb73XuCxx9IQDAL33JMFa+nCnj4d9WXefXd6PfLaHEp24vcbY1KttVUAYIxJB5B6BvUdMsZcZq09YIy5DMDhMyjD6QJWTU0Y27btx549+xGJVIKXeebPvxv79y/D7NmHsXPnYYTDxViw4Bpcfz3dAk+dOhUb624Z6andDHzmM0NAy0tARsalKCjIhM+XhZSUTHz961lYteqq+noHD34exvjxk5+E8PLLIQQC6fj5zy/FM8/QZHPy5Ek8/nga/P4Apk8Xxh4AQqEQfvhDipk7YwZ9SQL0xfbII0AolIvnn3++fiKaOpV+7pHz89Cv30zce69MLD/7GZUFAPn5+ejVi5bEvv99uavu2JFeMzPzMXLkyHoOfdgwCeHLnxcUfBVf+Qq95/8acnJQ55s2+OIX29T/RNW7N/CaeqY+FMpDKJSHK6+UzVI+/3n57ywvLw9t2uQBoGdQ8uiw/r+vUKg1PvOZ1rikDsXo3FnqpvpzkZGRi09/mt63agWPQqFctG+fW59++eXePKFQLgDgssvkWY5L1W8Bubm5nnQ+ZqWn5yI/X8Ki5+fLA2T8OQC0aSPPD2j709NzkZfnDaueqma3UKh1fTqfn5Uln7du3bo+vXVrKQegsRcKtUbr1mJT69Zyc+nz+erLb91aym/OSR9IfuJ/HsB7xpg/1b3/Hug3+tPVbNA2jg/Xvf7zDMpwOo+qqqpCcfFOHD++A88+exgA/fsxdepUPPPMC6ioOFp/Z5id3QG0nQNQVnYQNTVhdO7cGX7/NQiF8jFxYkH9v8Avv/wyHn00gLS0S/Dkkzm4554UT73Dhv0J998vd5EPPAD86Efy+Wc+800AtL/AkiWUxpMcAGRmZnqefnVyaslKdnH3l8aYDQDq7jkw01r7dkPnGGNeBC3k5hlj9gG4FzTh/80Y833QjDDqTA13al6dOHEC+/ZtxOWX9wFgsGrVLKxd+3/x+ONFiNb9Pvbqq35Mnz4WPl8AXbt2Rdeuo5CV9SlMmNAeb755ObKy2teXN3ToMwBowua77e9+l57KBIBu3bohl27MPFsiOjk5Nb2SveOHtfZNAG+eRv4bE3z0lQTpTudRR49uwowZr+Bvf1uDAwfW4847aSXwRz8qAvAphEL5aNfui/jOd76LdeuuQG5uFzz8cCf89rd0Gz158uT6xcP/+R94FrOcnJwuLCVL9YwA8EsA+QBM3Z+11mY3o23nRLW1QsuUlBDtwjE1eEGzspIWMcvL6XfI1avl/CVL6LxjxwgJ5Oh+vBE4R7PkDbUXLaLyqqvpd9xIhFb5OfJhOEy/cdfWCtbIGzFzmUzU8GbUaWn0u6+OtMjRC//zH4kGOns2EInUYO/etXjnnUWoqlqGY8fuxuLFV6K09AMcOnQ/UlO7IhS6Dn37TsL27Z/H22/n4tZbgd27x8CYMaipoYXoXbuorjlz6PfQmhoqPxCg+t5+24vGvvUW2ZmdTSglByT797/pc47ymJJCv41zu8vKBMksL6c6APLb229L/kWLKO3uuyk/b9rOESj1puXl5VR+SoosZjMC+sADFPXUWuDRRyUS5smTFAmSN/lesIDqKyqSCJ5t2kg0yupqiUJaXi5RIdu0oQiZ1lLdOnrqihXUvz4flR8OE5XF6CnHP+L6eAwEg7TmsHIl2ffww0QV1dTQQjxvGG+tbH4eiQD//KfUx5utV1WRL3kj9MWLJYDb3LmUzrgub0w+fz61l9cuGDPmc9LTBaeNRiUKZThMwMHChWQDY9CA5AGoH/SY4Y3KfT7xcSQiUS4jEer3lBTa0H7ZMkq7917ZMP7eeynv22/LPto8bk6coHJ9PolQGolIlFWOVjpnjsTz4miqTz1FbQboeucIuvffT3ZHozRedURTjkjq90tkWR0kEJCYV02lFr8DF2ODfj9NMnriZ2InP584fp749Sbnx497N2LWG34zCqk3ltaREsNh7ybQGrvUUTg5j55IARogTOdovr+qSs7haH8nTuzC3r0/QFXVEuzaVV73WSeUlx8EcCVCoW/illtO4t13MxCNAtdcQ88Ezk/IGwAAIABJREFU6CiSemNuHYmQ26Q3ouc9inUb2D4ddlZHeczIEB+kpEh6dbX0CT/3wG3jCTA11YuC6mM+V0eHTEs7NfRtvLL4S43L0pEmWbz3Mpehy9URQ1nBoLRTt6e6WhYVtV9iIzZWV8tnsZu46wiWetxwenW1XrSVvtMorbVyrDcFDwYTR6PUG5j7fPJznTGCDsdGVuU8kYh3PGi72R+8tzVL+4bxaG2DHhvaF5mZ3mswNVX6SI9xa72Trw7gqP3E6enp8Te6132nrxst7S+ei5pbyU78n9gduIyRB7AY3+RFQY7q17Yt3am1aQP06CGsbvfuwH/9Fx3rCJnjxsnxmDEysMaMkbui6dMJ+wIIndRRKhn/vP9+SX/gAflSYaSMIyTqKI/TpwO7dh3Dnj1vYfPm/+CSS65Br15TcdddeXj99cP4r//6Hu66qx/mzOmLjIzL8PjjwE9/CgDpeOwxolEA4Fe/kgtk1iy5Q7rvPq/dbMODD8oF/tBDctEw2aKjX7L0puUPPSSkzC23CFkyZYoQFA89JDTIPfeITTNmoH59gCNEss84hv3kyTJBaGyV1xj4otVRQm+5ReiPCRO8ETM1csv47K230n80nJ/JjOnT5QGcKVOkzbfeKnmmThWUcfJk+W9zxgxvXYBMknffLZPKLbdI3ePHe6NCss9uu03OveceurMFCCHkyeYXv5A+0+Ny6lTUL9rfequ04e67vf4CZLKeOVP8O22a+F9HZZ0+HR4Ukm+2CMMUu/kamjbNG3lUXyu6r7l/x46VaLX33Qe88AId33QTvfKEe/fd9J8F18c3CzNmiB0zZ4qfdPo996Ce+Jo8WSK36o3XJ02SMTplipQ/bZr47/bbpd+a+g4/VslO/G4HrotAa9Y8g6985UXMm7cA1tYiLy8Pn/1sNwBAVlYWxoyhJ2S+/W0hX5ycnFqekp34P7E7cF3Mqqoqxb59iwEMAQBs3vx3+P370bPnHejUaRheeqkX7rrLMYxOTk5etfgduC42WWuxaNFi/OEPf8CLL76CSKQK+/fvBXA5Ro78Gx56KBNTp9IPoI5bd3JyiqdkqZ72AP4vgOvqkhYB+Im1dl9zGeZ0qg4cWIk33/wuHntsM7KystC9+zh07/5dtGvXDgCQmpqVcDs8JycnJ1ayP/X8CcALAL5d935MXdpXm8Oo5pbeS5f35kxPpwXSykpZeNq+XRaVVq6khSfGLSsqZINx3uD5vffoLrukRDa+jkYJZeSNrBcsoDzBoGzqvW+fRNQsKRE0MRgEXn99P2prixEOX4mFCzugvLw1Bgx4FldcMQrz5mVg+XKKTfLee0IycKTOn/6UcE4mbBhFu+MO2YD7nnsE33vgAUINfT5aaFyyhGx46ilBEBnhtJbsnjuX8jOuVl1ND2gtWkTl84Lg8uXkuzvvlA2/g0HC3aqqKJ2jlVZWEtbG+86uWkX2z5olG3Y/9BCVWVtLi3Lvv09ltm0LrF9Pfv/Nb6jN5eXUP3zuI49Q+Yx2sn2BANW9bBn1RShEfc3jYd48al9lJdUXDIp90Sj5iTcn37uX/MEkx5Il1LZZs7yb28+fTzRTfj613xhaRF69mvrwiSeorkBAxuLatWTDvfeSTZmZdA5vQl5ZKRvDB4PS7pwcaltFBfl7yRKq+7nnCC32+Whz+7VryeZnnhE/sa0sjpjK/QbIQiujodbK8b33ErbJi9GLFkmQwTfeoPSTJwXnNEYwaMaVg0Fa6F66VJDo99+nxf+//lUipjIKGolQW3l8c1TVQEAWz9k3zzwj615PP02RdquqaCwvWCBjfMkSKveRR+hcTl+6VP7D1vjo8uVU/uHDZGtKCtnNqCpA/cZwweK6WHPPPOOds3iryKZSshN/G2vtn9T754wxtzStKedOeuLnAZSeTsc6aqWOhqk3TNcbMQNenJMHto6cWVMj5erNrjX2xQOCz41Gd2P27F9i8+ZnEQpdC2ABjLkUl166CN26SX1MaWiUMjVVxwLxIpZMMehIpKGQXNxZWXKcni4TlN4s3Bg5DgS8PylpdFKnB4NiazAo5IdGJ2NROfaHRi/T0rxoHbczJUXK1NhcTY2cW1sr9mmkku1gcdhntkP/F8X5dHuYbec62Dfp6V7cj/NrvDc1VfohEBByS+OLunz2Abdbx3TRuKquI/ZJaPbxJZeITVlZcpyaKufoQIZpad6xoXFM9it/xuM9NVXON+ZUe/l8lva99kEw6EUtuQ0ZGacizgClsV917Jxo9NQotXoMcd0ZGdK+1FQvosttyMjwIspsX3q6dx7QG8NrDJXTNbocez01l5Kd+I8aY8YAeLHu/Y0AjjaPSedGPMn4/dRROTmC7nHwLMY5u3YFCgroeMAAwTnHj5eOnzhR8DiNZE6fLrH8f/UrRicJ4+KLY8YMQQJ/8IP9ePfd+7Fy5R8RCPhx1VXj8cUv3o7HH5cB+stf0isjXw8/LLjg3XfLhHn//TJ4f/ELCRJ1zz2SHovB/fWvdDxmjJQzebK0c+pUuehuv92LYPLFH5sOiG/Hj/fWwWVNmUIP2wCE4HF9kyYJpnjTTYJ5jh3rLYePR42SKKZ68/Np08SGqVMp0BgAjKTIvfVBzUaMAP72NymL7Rs/Xs4fOdKbh6OYTp4sPrvlFq99GiPUvuA7u9GjJULrxIneel96SfJoX44aJX2nN+eeOFEmp3HjpF8mTJAxfdtt8fthzBjx8ciR3n7g9JtukvxTp9J/CZwHkHF6221e9FLjsBoN5Wvl4YdRHwguFtvU/uOJfsIE8d+YMd5Ny7lP7rmH/qNhX/AEztgv3/lPmCB2jx0LtK+LNjJkiBen1ceMfY8d620b98/YsV70WR9r/zHOOWWKFwduTiW7A9d4UFydg6AtF0eCArU5NbFeffVVrFr1J3zxiz/Ejh078LWv/Q45OZ3Ot1lOTk6fICVL9ewBMKyZbWmRsjaKP/3pz9i8ORuf/ey3MGnSJBw8+A20bt25/q7DycnJqSmV1B2/MebPxpgc9f4SY8yzzWdWy9CBA2vx7LPXYfz48di4kf6XTU1NRevWnc+zZU5OTp9kJfsbfw/edhGo34HrqoZOcEqsSKQKd989E3/4w8MIhfLw5z//Gdu2jTnfZjk5ObUQJTvx+4wxl1hrjwOAMSb3NM69IKRX13lT82AQOHRIoilu2EAB2HhBcNEiwsGKigiLrK2lKJyzZ9MqfFER4V3GUHyON96gRZuUFMIlraV6OAKltcA//gGEw+/g0KEHkZ39PbRv/xg2bbqkfnNxQCL3HT8uOFwgIOl33kmv//630CVcd1kZoWWMcC5bRumPPip44e9/T7hadTUtLG/aROV06EDIGe+1u2EDlfGXv1A6byS/ciWV88wzEu0wO5vq8vsp/9q15C9esJ07V+gIxvQ40iJHgly0SPbU3biR6nj9daqDMT2OnJmWJmheZiYdl5RQn6xaJYv3q1ZR/c89R37hiI2rV0v0RYCwu9RUWthfs4ZsCIXo/NpasY+plgULxNa1a6kNf/ubIJnPPuvdqH3FCvJfJCLRV8NhQQLDYemfF16QugIBso23AAXEH4DYypEg/X7BNjlYHSOCALUnI4PG5+rVsqfzokW0+M/tLC0lvPn992VL0mXLqIzqasqTkkL1MubJC8Hcp088QfkAsn/xYqHdGJEMBsl/gQCNp9WrBa9cuZLomF//mvwXCFCb5s0TW5cvl32xlywRn61fT3U99ZTYUF1NY48j8Wp/vP461W0tLWJzRNRoFHWbzFMeHls83pneWb6c0vPzJQon+ywQoD5dsUIC/S1aRGN49my6zmjTeYkmqykpgBamm1LJTt6PAVhqjHml7v23ATzYtKY0r/QG64xtBoNeZPP4cQkkBRDjzR1bVeWNMsjYnd6QPBZ5ZILAGKCmJopDh9bB7++JtLShGD16Fdat+0LcCJ41NYJ3WSvpwaA3siBfCABNUjpqJdfdqpWUpdG6jAwvNsaB0DQimp0t5/r9MknG4qKcR+OLsdEv09PFN6mpXpxRR6rkc5juYP8xhaRxzljEj+3TYW1TUiRPVpa3f3T0RR3ZUW9W7/d7EVgui/YNljZoP+pzY5FWfuU2x7ZHl6UjZMbap/tRI6Mav43X71lZXuyV8+j+ikYlT3q6Nyqrxh352tBjj+vQKKmOdKrbyv7LzJTjVq28mCPboTHHtDTvNaeRT26PLod9xun6Gs/I8CK6ur+0fRp71f3OYyPWVrYvK8vbVzpSp8ab9Xg9Fw9hJru4+xdjzCoAA+qSRlhrP2w+s5pHPBnznV5urmxY3qED7QUKAH360CujXsOG0bc1QMjaHtpNEDNmSKfed5906t13S6cSzvkx3nhjLF55ZTHGjduKVq0+jV/+8gv1kTB/+Utv9Eu+aB58UMqZMUMuIEY3+f3MmV5UTCNnHK980CCZGCdNEhRt+HCJcT90qPy3M3q0bAY/ZIggZyNGyH8wQ4eKfePHy13KTTeRPwGgf3965bpHjvSWy+drzHHIEEFqBwwQH48YIUhh//6Sf9AguXCGDPGimWy3RkGHDhWcs29feNSzp0RQHTpU6h6m0Ibhw8X3w4fLRD9qlOB4gwfL8aBBctMwbJikDx+O+n1yhwwRvzC2yXazL/r1o1cua/hwwQ779JHjAQOkrQMGSF8PHAjUPeTt8Vn//hI5cvBgqXvIEHq4iM9lpLlfP/HryJFS/hAKGYUuXaQsHgcjRgCvvirnaNyUbR09Ws7t31/Shw+nu20+1uOB2zB0qLf9evxw20aPpoi67C9AsNzhw2U89e8v41K3oUcP8V/v3t6xyH03eLBM+iNHev3KeQYOlGtl2DDx5YABYsPw4WhWJf1zTd1Ef9FN9udbixcvxl/+8i1UV5fh97//LbZu7XC+TXJycmrhSpbjdzoDLV/+O3z5y19GamorjBmzEt///vdhXDAdJyen86yLaoH2YtOxYzsxaNAgdO78PNLScho/wcnJyekcyN3xN7Gqq8uwZcsWAMB///fDmD17tpv0nZycLii5ib8JVV5+GM8//2V89atfRU1NBXw+P/wuKL6Tk9MFphbzUw9HxfT5gKNHiYyIRIDNmykcbHEx8ciVlUK2vPYaETarVxN/z5jW668T0lVTA/zzn4SAHT68F88+OwCRyH5861sv4/XX0+vDsc6eLQz7m29KJL8FCyR867vvEso1fbqE1/X5iFnm8MYcnpgDQjFn/8QTEtL4tdeER87JkRDPRUXEsaemkj3LllH5mZnC7peUEEfMfDaHzuUwxMxdL1wom7tv3CghdDdtIrsWLqT8NTXiy5UrJdQ0s+5paeR/Y4h9XruW8oZCZEdVFT03wWF4y8qoPsZGV60SjJP56mCQ2l9TQ3lWrqS0du2EQ/f5xJdM5CxZImG0OTwv18H+0G1YulTojfXrqaw33qA8GRlEguzYQehgTg5x3hUV1I6VK6kNeXlUflUV2cHhfCMR4dZzc+VZgmPHqL61a+W5iw0bxG72RzAofsrPB7Ztozqysym9spLKXrmSfJeWRn1XUSH+Y/s2bpRnETZupDzRKIUYN4byfPABjT2mVrZsoTZwfaEQvW7cSHYEg2Sr308kzpo18vzB6tUS4ZSZ/sxM8gdH91y7lj4PBOhcxpd1eOjVq+XaX7OG+jA/n/qttlY4/uXLZUywHeEwjYFAgHyzZQu1+dgxajcjnOvXUx7tV11O27ZeW1eupH6ORslnKSk07jmst89H7eSxqzVixGlPeQ2qxU38qanyABdA7D5H9QuH6UuAVVYm8dqNkUnM5xPkkhj9PXjppS+jtvYoPv3p93DFFV/Etm2Cd+qHMTTzbIxshK3570DAy1czOqhD4QJ00WmemaNvap6bH+TidGaNY/llVnp6/JDOoZCUE5uf7WvVyst8a2n2X9uRlSXn6JC92mear9bMs34WITdX/J2VJc9ZhEJii07XD/SxfazMTO9zBtw+zZJrPl0/75CaKv2Qk+MNxczHoZA8N5GZ6e1fzdvHS+e26nHD7U5P9/Lw7MNQSNrXqpU3pDOnh0KSfsklUndOjrQtFPKGx9bPiugxkZkp9ubkePuObdV9mpnpHe+6vkSMPrP4sdeHDm/M/a45fP1cDHDqcyT6+QX9DAvXoY+1rXocp6Z6xzdfo/p5hawssS893TveLqSwzJ8IpaTQYEpPp7927YRB7tVLGN2xY+mVn/qcOVNC/T78sAzeRx+lyXrOnHthzHGMGfMuLrvsajz0kAyIBx8U7v6BB7zhijV7rxnnRx+l49tu84Z7festOmbWukcPer32Wi+vz23q00eY8YEDhXMePFh46W7dhCO+9lpJ79NH0vv3F+69sFD45WuvlTJ79RIGuUcPObdnT3pl3/bs6a2by+rRQ2zt0UPuHrt1o7DYADHY69aJHVxm166Sv6BAuOuCArG7Z08pXx8zx8/ve/Xycttsa8+e8sV07bXS1j59UL8/QkGB126+4Hv0kHYWFgIffih5mPPu1k3Y89g8zM9zWzjkcLt2cn7Hjl7/cRs6dJBJr1s3sbugQPpO26HTCwqkzK5dZXLv2lX6V/uL7eNzCgrknO7d5bmYAQNk8hw40Osb9kHXrjKOu3eXMnv3lvQePehOm/Own7p0kTYUFnr7luvlZyK43dde6x0rXEfPnt72sf8KC6Vt+rh7d8mjWf+uXaX8zp2l3l69vP3GY6x3bzSr3G/8TaD+/X+LxYsX47LLrj7fpjg5OTk1qvMy8RtjdhtjPjDGrKt7IviiU0VFMcaPH4+qqhKkpGTgc5/73Pk2ycnJySkpnc87/i9bawuttb3Oow1npOrqk3jttSF48cUXcfz4lvNtjpOTk9Npyf3Uc5qqqanBv/71LRw+vAYvv/wy2ra99nyb5OTk5HRaOl+LuxbAO8YYC+D/WWufbo5KeFN1gPbDLS+nRanVq2mBbOdOQvCqqgiLmz2b8jPJ8+KLEjXzuecAn89i/vwp2LNnDrKynsW//z2sHvOsqaHgZX4/kULLltGqf1aW4IH33y+4WnU1oWS84MzhjYuLBTt8+mkJKQvQQlYwKBTS1q1CWqxZI6TSunW0sFhaKshnKETpPh/ZtWMH2VpSIvhnZaWEyAWoTA4v+9FHssn39u0SCnfjRgl8t22bLGpv2+aN6Llrl4RT3rlTwiYXFdFrTg71SVUVfbZjh5S1Y4egmhwgLxSiMgH6bPduQWB375b8RUXUn5EI+YvRR8ZImXzZtInaVFlJdWRk0FgpKqK+CgSoTQClc/vy8sg3lZXkyw8/FAyQ6wMoD2Ohe/aQPdEo+SIQIFv37ZMQ1YcO0fHBg8CBAxJuGKD3HMn0wAFZRD50iOpju2tqaAzs3k32ZGdTHg4NvG+flLt9u/hm1y6hV/bsET99/LGMpYMHKf/u3VSOJqQ+/pjayvUxKbd5s2zMvmUL5Vm3jo7ZZ7t3U93cd4w/bt0q7dy2TSix7dspLRCgPBzuesMGuc42bJD5YMsWCasMyHvuLx6z7IOcHOoj9k1RkSDEu3YJbrprl0S25XESCtHYDQRkrKemUv4DB2jMZGdL+cGg7OfN9rEYcGgqna+Jv6+1dr8xJh/AHGPMFmvtQp3BGDMRwEQA6MDL6qcpnvh9Prr4eeLft08m9/JymUijUYnWCXhRLwqlW4y9e99EKHQnUlNpy2EdFlfn54uZ8/CkrJExHdZVh1jWKFlGhlAZGicEhFDic3hiCAZlQsvOFjvy871hYTVOxxdVLELHSk+XMmMRNVZWlhfx07bqMLnZ2ZJP44ytWglumZUlPtA4nr4gNP6ZkeHFTbUdunzO07o1PMrJkTZlZAhumZ0tmO3/3975B9dRXXf8e55kSUjy87MsJFl+FrYxtHU0QKhDIGU6HbfTJIQ2nbYEezIFEk9o2qQBhpChYcqPTDylbQKkDU3isYGUKbT8SAuGJHX50aEUBDWGxD8wxYqNbWxh2bKQbNkW0rv947yTe3b91vr53tq75zOj2bv33b333B9732rv952ry6irC7oJ1u0kfdrQ4Ovc0ODjs9lg+4l9WhKopapakgsEpajypSt10i6NhcZGb6OWWjY0BN0na3fDWraqx6KWL0p6LSMN11VLWmfP9vVuaQnKLUu1gW77WbOC/SP3kG770dGgzLqU/FjLS+Vc2y12hNtfCNdbS6WlbN3vNTU+T22T7jfdftqechLLxO+ce7d43E9E/wbgIgAvhNKsBrAaAJYuXepOyGScyJNldTUPnvZ2YO5c/uzyy/3TwPXX8xMJAHz723yUSei735VOPROrVr2OVatmg4jTfeMbnObWW9l1MsBHLdWUzUiuuiro0ljLM7VrW5EpanfQF13k/xO4uPh2SZ52Fi/2g+vCC71sbPHioPRPJG4dHfzlB3CclL1okU+zeLGf1M87j59W5FqZfPN5L1/M5/0PjJqafB1EzqaP8uWazfqB3tLi883l/A9scjlfRnOzl8GFw5Iml/NfCO3tvg7NzcE8RTYodolsM5fz0t3mZn99S4u3taPDt/e55wbrIG3Z0eHzbmvz4fZ2b2s2G2wzqX9Li69Dc7N/aJDnH5kw2tr8ZKj7UZ7u5fpSZWSzwbaR8vJ5X5+2Nl9P3e9NTT6+vd2nl6P0Sy7n0zU3e/vyeT9G29p8fFtbcGzofCRNSwv/tyHppQ75vP9CW7LEt1Fnp89n8WLfhrpMOUq/6HGTz/u8tGS2pcV/6XR0BMechBcs8G2Sz/u2aGnxLuDPPTfY9mKr2FIuKv6On4gaiGimhAH8LoDNlbZjInR3d6Or62soFEYwZ84cENnSiGEYpy9xzGCtAF4kop8BeBXA0865n8Zgx7gYGTmGK664Atu2rcHQUE/c5hiGYUyZir/qcc79AsD5lS53srz00lexadPr+PjHn0RjYz5ucwzDMKZMqlw2TJS3334EmzbdixtvvBGHD/9e3OYYhmFMC4me+I8f57/qapZt7d3Lcql161jdsmMHyzQLBV4ovf9+XslnD4lDWL/+y6iquhjvvffX+MlPePX9uuuAZ5/lPL/5TfawKeGuLlYqfP/7HC/yx64ur7TZsMGv9GvPgOKxMpvlReaqKl7Y3bKF02ezXrIoC0Y7d7Ltx46xbKy2lhfRdu/2aqYDB9ju+npeOHOOF/v6+rzCp6fHywu1LHL3bm/T3r1eidDb62WoAwOcpr+fJbOiThgc9JJKgJVTmQwfRV45MsKO76qq+Dg0xNeLCkvnNTrK9h06xPEjI+xlFeDw++97b5t9fX4z9f5+Xx9xslconGjf4CDnMzzM+RYKHN6/39vZ08P1rqnx5e3fz2XMmOGd+smY6+vj+Lo6X09xECgLkUND3gHgsWNct4EBX2eA61wo+MXE3l7ffgcO+LF19KiXzPb3e2WZbvuhIV/24cO+3wcGOP3AANdBZJ79/V7+OTDglS6Dg77fJSyLoCLfzGSC9RgY4Di5RqTCUra0n/SDjC3pd7H7wAGv2Ovp8TLcPXvYzqYmn37PHm6v6mq+TsaD9LvUL5Ph/pIyxK+Q3EOyT/fBg76uhw75e6i314/F/fu5nerqOI3IRSV9JuNltdksXyvteuiQ9zaqEXHAdJGaiX/vXu7YRYu4c0ThMTzspZ2AlmPWo6Hhv1AoNCKTmYFczk9EumO0hFNLEGfNCnpN1NItLaPUHhtl1b+pKSh3FOlaWOqlPX1qiZuWhlZVBaV5UXI/UYfU1gYlaqUkklqyqNNXVfn8tffG8PVhKVsp+2prg7I57b1QSxkFLZXTNumwlv6dzD7dftXqDtHy29mzg2VoT4t6bEi8ls/W1AQlwLq9df9oT5jaO2d9fVB+K5OYlnmKki1cN13nurrSslLd3nqM6TrosaEln+Eywl5JS9VJe9jUtlZVBb1tSnrdflrGrNsil/Np9L2l2zucl65r2KOu9rKq5a1yj2tpsZak6ntcp9f2aemoln+Wk0RP/AB3dDbr/5Yt4x9qLVwI3HGH9yF/331eNvf1r3fj7LPPxqxZ7Hbxrrv4KR4AvvhF9tAJADffzNcBwOc/H5Rqam+Zzz3H4WXLor0uivyxs9NLKhcs8PFhmZ0+5nJB2ZgMtHzeSxO1Tl0kYxKW8/r6oFxNbqJ8Pijlk9896Bsqm/Vh/UWib2jgxBtKp5M0+mbMZIJh0XXr3ypoCWc268ONjcH0mrB9ck11dfB6kfVls0E5qLRZTY0fN7pujY3BdtJ1lnSyp4GUK/F60tZtHJZN1tUFy9bl6TpIvroNdBrZZyJsR02NT1NfHyxL4uvqTmzjUr/RqK/3bVlX58sI10HylSfscBuE+1faIjx2pSzdh3qcyFFs1nnJf9gSr8Olxka4DXRYt6suW0uXdfpSY6YcmC4xxMDANnR2duIe8Z9sGIaRMGziVxQKI+jquhr19fVYvnx53OYYhmGUhcS/6pkIb731HRw8+CoefvhhtMl7FMMwjIRhT/xFdu/ejc2bb0N7+6dw5ZVXxm2OYRhG2Uj0E39PD/81NfFm6YcOscfJe+/lhZTBQeDxxzntrl1vY2SkCXv3/gNWruRl+/Xr/ULjK69474GyEbZsOt3QwOk2bvR71nZ18Qr+yAh7ZpStHt95x0u9duzghZ3Dhzn+jDN4sUfkXfX1Xg5WXx+UPgJ8/OADzqO/30vSRE7X1+cldDU1nF6kayLNq6nxMsCRES+jlHgiTiuLTtXVrJQS75CyMHXsGNtSVeWldtpx1+iol+bJ3/Awlyllj44GrxfCYZF2jox4CafIEvV+yrJ4KrYCXv0jeUjeYp+Excujll4ePcp5SV3FnuPHvfdGkWQC3tNoJuPTS35EXjos+ei2kHSSv16Alevlc6n78eNeaiheLQEum8jnK2kKBd82UmeRUko5w8O+jSVPKUvqNjzsPWECXjIqeYliRfKStpE20/Gl2ibcv1LPY8d8PpLOOS+NzWT4KPHSn1op/r6sAAAM80lEQVR6Km0zPMxhsenoUY6TMkSdJPeK7l+A7dN9rfvGOT9upGw9dmVsiD3hjdaB6V/sTfzE/957PPH39vIkCnCDy0QmzJmzDEA3AK9zDMsItfc97WlRKxfEW6bedHvWLJb/SVh7ddSeCyW9lnfpNFr6CAQlmVpypgeJlsdptYyW5mkZppZLanmqVqxoiaiWnul4LZmTc+2ZUMeXuj4K/bmW5um6aZt0uVKvsG3hdFqCGJZeSvm6Drr9tCRVy361okZ/IYZtEMJS03A7a5mjoKWG2m5dN32tjg97AC1VVlhbrtNoTjbOSkl/dbxuG123cJ6l8tFyWD3udZ/osk6Wl5aPzpjh7zWdRqMlyprw+C4lM9bX6XLLSaInfgBobeXNkFtb+e/OO9nnPACsXQvs2jWEffsewlNPfQ633sq9u2oVf643PX/gAQ5fc01Qqvniixy+9NKgVFNvZK29PcrTupaPhSWSUbK8sGxOH0UeFpba6bCWVGoJXSlJpdZZhyWVOr2e2EppxSWsr9cSTx1finBemYy/CbV8UPLUP8oKyxR1WfIlI9fpz3Q9tPQyqj3GE5ZywjaV+u2AtiEsCdRtInUNS1XD6Ouj2kMkpOGytd3a1lJfaGMxnnbS9un66nBUu+p+15ysLaPGn843auxKOOpeCY/vUvdZVH2i7ofpIvXv+Hfs+Ba2bPkCXhX/x4ZhGAkn1RP/vn37sHPn36K19Y9wySWXxG2OYRhGRUj1xH/bbbehUDiOc865M25TDMMwKkZqJ/7Bwc1Yu3Yt5s//EhoaFsdtjmEYRsVI9OLu00+z18p164CHHuK4rVtZggkcQWPjx7Br119h1y72tfPyy7xQI+qd117zDqQ2buSV+Lo63mBclApvveUXavUm1T09vLDa18cLutXV3juiyNyOHOGFSpEHygKQyEBFNjdjRlAGKchiL+AlYSLNk0UjkegVCr4MkZyJOkEknhIGvAwtapFJpGqjoz4fLYdzLiibE/ma2DKexatwXhNB26fjdBuJJFLKCu9rW6rsqcSLDVFhOZd+C/dPlK3jQfINlyntEQ6HpbdiU1h2OREFSlTbhOst6PbUY1GkuFK+2Byuly5HZLKlxp6UHWWrtlP3i77PwnUQ2yS9XtwtlX+pdtFM92Jvoif+7m52LbxwYalPP4olS/4bek1XyyiBoLe/xkavJpk506tlWlv9xtxaqtnUFFTUaJWAoL1caqWEVlZoKdnJOj8sCSuVl47XsrRwmrGIkjLqcFgeGJYFjjWQ9bVRUsPx2BdVTjjPsLRxuuOjbDqZtLVU/5SyfSzC9o1FlIQzShY6ETui2kyIao8owiqsUozVlmPZGpWXvp+ixoD2mBqVf1S7lJNET/wAMH8+cPfdwJo1fL5xo0Nn5w8wd+6VeOaZ2bjhBo6/+27gkUc4/JnP8FFvhr5hA4eXLg1u9qyll1qqGeWhL0pypp+4amv5LywHi5J6hV0Ka+SLIxw/HtlY1NPceCbukzGep8SJTm6aKPuinnDHW/Z0xVcasSP8hTOe9tDnUZLXqdg0XsL26R/ljcXJ0o3HDvlB2UTrGvVAdbKHq0qNmcRP/GHWr1+PrVv/DAAB+NO4zTEMw6g4qVrcdc7h9ttvR11dB/L5z8VtjmEYRiyk6ol/dHQ9urq68KEP/QCZzAR+cmgYhpEgUvPE75zD8PBtOOusszBv3jVxm2MYhhEbiX7if+IJPvJiySCAM3H48EqsX89P+ytWsGQzl2MfPtu3e0dpAG96XlfHCp0dO9gfTk8Pb7RdWxv0FCgSSfG4p+WLYYla1CKRlv5p+ZnIvcJyQSlD8o1ycDaWXO1kTEVSWYl8J5pPuepzqjNRGepE86kElS67HHLicvvgGS+JnviDZAGsw8yZDgcP+timJpZxAjyxay+UuZz3qtnczHJNILixufbuF/b0V0oSN14vfqU8SYYHX5Snxah8w/HjUTNMJP14ma58J5pPuepzqjNRGepE86kElS67HHLiqarhppNUTPzbt3dj+XLCGWcswgsvUMDTpvauuXMnhxcs4KP2qqllm1HSt7E8TZ4MPbgmc32URLKUlG8yNk0n05XvZPTsaZnsNdMlN42z/eL4opluOfGpxClu3vRwyy234I03PoJC4XjcphiGYcROCib+nXj00UfR1rYSmUxt3MYYhmHETiwTPxF9gojeIqLtRHRzeUu7B5lMBu3tXylvMYZhGKcJFZ/4iagKwL0APglgCYAVRLSkPKUdArAGK1asQG1tvjxFGIZhnGbEsbh7EYDtzrlfAAAR/QuATwPYOv1FvQTgAzz44I2/jLnpJnbcNmcOK3reeYd962SzwMGDQcdsR46wymdoyG8aLV4rSy38xC0RnIps0zCM9BDHxD8PwG51vgfAR8OJiOhaANcCQEdHxySL+hSAfQCaAPBEDwBz57JXTYAdrcnet7lccKPy+nov79SbRp+KTrmmIts0DCNdnLJyTufcagCrAWDp0qUlHJuOJw9AJv2kYxO8YRjjJY7F3XcBzFfn+WKcYRiGUQHimPj/F8A5RLSQiGoALAfwZAx2GIZhpJKKv+pxzo0Q0ZcB/AeAKgD3Oee2VNoOwzCMtBLLO37n3I8B/DiOsg3DMNJOCn65axiGYWhs4jcMw0gZNvEbhmGkDJv4DcMwUgY5N6nfRlUUIuoF8M4kL28GcGAazTkdsDqnA6tzOphKnc9yzp0ZjjwtJv6pQEQbnHNL47ajklid04HVOR2Uo872qscwDCNl2MRvGIaRMtIw8a+O24AYsDqnA6tzOpj2Oif+Hb9hGIYRJA1P/IZhGIbCJn7DMIyUkeiJv7KbulceIppPRM8T0VYi2kJE1xXjm4joP4no7eJxdty2TjdEVEVErxPRU8XzhUT0SrGv/7Xo8jsxEFGOiB4jom1E9CYRXZL0fiaiG4rjejMRPUxEdUnrZyK6j4j2E9FmFVeyX4n5+2Ldf05EF0623MRO/JXd1D02RgDc6JxbAuBiAF8q1vFmAM86584B8GzxPGlcB+BNdf43AO52zi0GcAjAylisKh/fAfBT59yvAjgfXPfE9jMRzQPwFQBLnXOdYBfuy5G8fn4AwCdCcVH9+kkA5xT/rgXwvckWmtiJH2pTd+fcMADZ1D0xOOf2Oec2FsOD4MlgHriePywm+yGAP4jHwvJARHnwhspriucEYBmAx4pJElVnIpoF4DcBrAUA59ywc64fCe9nsNv4M4ioGkA9eAPtRPWzc+4FAH2h6Kh+/TSAf3JMF4AcEc2dTLlJnvhLbeo+LyZbyg4RLQDwYQCvAGh1zu0rftQDoDUms8rFPQC+BqBQPJ8DoN85N1I8T1pfLwTQC+D+4uutNUTUgAT3s3PuXQDfArALPOG/D+A1JLufhah+nbY5LckTf2ogokYAjwO43jk3oD9zrNdNjGaXiC4HsN8591rctlSQagAXAviec+7DAI4g9Fongf08G/yEuxBAO4AGnPhKJPGUq1+TPPGnYlN3IpoBnvT/2Tn3o2L0e/IvYPG4Py77ysBvAPh9ItoJfn23DPz+O1d8JQAkr6/3ANjjnHuleP4Y+Isgyf38OwB2OOd6nXMfAPgRuO+T3M9CVL9O25yW5Ik/8Zu6F99trwXwpnPuLvXRkwCuLoavBvBEpW0rF865v3TO5Z1zC8B9+pxz7rMAngfwx8VkSatzD4DdRPQrxajfBrAVCe5n8Cuei4movjjOpc6J7WdFVL8+CeCqorrnYgDvq1dCE8M5l9g/AJcB+D8A3QBuidueMtTvUvC/gT8H8Ebx7zLwO+9nAbwN4BkATXHbWqb6/xaAp4rhRQBeBbAdwKMAauO2b5rregGADcW+/ncAs5PezwDuALANwGYADwKoTVo/A3gYvIbxAfg/u5VR/QqAwErFbgCbwIqnSZVrLhsMwzBSRpJf9RiGYRglsInfMAwjZdjEbxiGkTJs4jcMw0gZNvEbhmGkDJv4DSNE0RPmnxfD7UT02FjXGMbphMk5DSNE0e/RU469QhpG4qgeO4lhpI47AZxNRG+Af0Tza865TiK6BuwpsQHsGvdbAGoA/AmA4wAuc871EdHZ4B/anAlgCMAXnHPbKl8NwyiNveoxjBO5GUC3c+4CADeFPusE8IcAPgJgFYAhx47TXgZwVTHNagB/4Zz7dQBfBfCPFbHaMMaJPfEbxsR43vHeB4NE9D6AdcX4TQDOK3pK/RiAR9nFDAB2NWAYpww28RvGxDiuwgV1XgDfTxmwz/gLKm2YYYwXe9VjGCcyCGDmZC50vB/CDiK6AvjlPqnnT6dxhjFVbOI3jBDOuYMA/qe4AfbfTSKLzwJYSUQ/A7AFCdvy0zj9MTmnYRhGyrAnfsMwjJRhE79hGEbKsInfMAwjZdjEbxiGkTJs4jcMw0gZNvEbhmGkDJv4DcMwUsb/A1h9D2yH+kJ1AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -96,6 +95,7 @@ } ], "source": [ + "# ode right-hand side\n", "def pend(y, t):\n", " dydt = [-k[0] * y[0] + k[1]]\n", " return dydt\n", @@ -103,14 +103,16 @@ "x_0 = [0]\n", "times = np.linspace(0, 100, 100)\n", "\n", + "# solve ODE\n", "from scipy.integrate import odeint\n", "sol = odeint(pend, x_0, times)\n", "\n", - "for i in range(10):\n", + "# perform 10 simulations of the stochastic process\n", + "for i in range(500):\n", " values = model.simulate(k, times)\n", - " plt.step(times, values)\n", - " \n", - "plt.title('stochastic production and degradation across different iterations')\n", + " plt.step(times, values, color='blue', alpha=0.01)\n", + "\n", + "# plot ODE overlaid\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", "plt.plot(times, sol,'--', color='black', label='ode solution')\n", @@ -124,7 +126,7 @@ "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" }, "kernelspec": { - "display_name": "Python 3.8.0 32-bit", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -138,9 +140,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" - }, - "orig_nbformat": 4 + "version": "3.7.7" + } }, "nbformat": 4, "nbformat_minor": 2 diff --git a/examples/toy/model-stochastic-schlogl.ipynb b/examples/toy/model-stochastic-schlogl.ipynb index 9844ca8504..92b2a592da 100644 --- a/examples/toy/model-stochastic-schlogl.ipynb +++ b/examples/toy/model-stochastic-schlogl.ipynb @@ -6,21 +6,26 @@ "source": [ "# Schlogl's model\n", "\n", - "This example shows how the model representing Schlogl's system of chemical reactions can be used ([Schlogl, 1972](https://link.springer.com/content/pdf/10.1007/BF01379769.pdf)).\n", - "This model describes the stochastic process made of four chemical reactions, two of them being the reverse of another, that take place on a single molecule type.\n", + "This example introduces Schlogl's model of a system of chemical reactions ([Schlogl, 1972](https://link.springer.com/content/pdf/10.1007/BF01379769.pdf)).\n", + "This model describes the stochastic process made of four chemical reactions that take place on a single molecule type, $A$.\n", + "\n", + "\n", "Given an initial concentration of the substance, $n_0$, the process can be described by the following equations:\n", + "\n", " $$2A \\xrightarrow{k_1} 3A$$\n", " $$3A \\xrightarrow{k_2} 2A$$\n", " $$\\emptyset \\xrightarrow{k_3} A$$\n", " $$A \\xrightarrow{k_4} \\emptyset$$\n", "\n", - "The model is simulated according to the Gillespie stochastic simulation algorithm (Gillespie, 1976)." + "In PINTS, this model is simulated according to the Gillespie stochastic simulation algorithm [(Gillespie, 1976)](https://doi.org/10.1016/0021-9991%2876%2990041-3)." ] }, { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "collapsed": true + }, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", @@ -34,7 +39,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Specify the initial concentration, and select time points at which to record concentration values, and the rate constant values $k_1$, $k_2$, $k_3$, $k_4$:" + "We specify the initial population size, and here we use the default parameters given in the PINTS implementation, which are taken from [Erban et al., 2007](https://arxiv.org/abs/0704.1908)." ] }, { @@ -42,9 +47,16 @@ "execution_count": 2, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "k = [1.80e-01 2.50e-04 2.20e+03 3.75e+01]\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -56,14 +68,19 @@ } ], "source": [ + "# instantiate model\n", "n_0 = 0\n", "model = toy.stochastic.SchloglModel(n_0)\n", "\n", - "times = np.linspace(0, 100, 1000)\n", + "# get default parameters\n", "k = model.suggested_parameters()\n", + "print(\"k = \", k)\n", "\n", + "# simulate model\n", + "times = np.linspace(0, 100, 1000)\n", "values = model.simulate(k, times)\n", "\n", + "# plot\n", "plt.step(times, values)\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", @@ -74,19 +91,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute deterministically the solution to the ODE equivalent(Erban et al., 2007): $ \\frac{\\text{d}a}{\\text{d}t} = -k_2 a^3 + k_1 a^2 - k_4 a + k_3 $.\n", + "Given the stochastic nature of this model, every iteration returns a different result. However, we can compute deterministically the solution to the equivalent ordinary differential equation ([Erban et al., 2007](https://arxiv.org/abs/0704.1908)):\n", + "\n", + "$ \\frac{\\text{d}a}{\\text{d}t} = -k_2 a^3 + k_1 a^2 - k_4 a + k_3 $.\n", "\n", - "We will plot the ODE solution, and compare it to the stochastic simulation to show that the two functions are similar.\n" + "We then plot the ODE solution and compare it to the stochastic simulation. A key feature of this system is the random switching that is seen in the stochastic simulations, which is not captured by the ODE solution." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -98,7 +117,8 @@ } ], "source": [ - "def pend(y, t):\n", + "# solve ODE\n", + "def rhs(y, t):\n", " dydt = [-k[1] * (y[0] ** 3) + k[0] * (y[0] ** 2) - k[3] * y[0] + k[2]]\n", " return dydt\n", "\n", @@ -106,10 +126,9 @@ "times = np.linspace(0, 100, 1000)\n", "\n", "from scipy.integrate import odeint\n", - "sol = odeint(pend, x_0, times)\n", + "sol = odeint(rhs, x_0, times)\n", "\n", - " \n", - "plt.title('Schlogl\\'s system')\n", + "# plot\n", "plt.xlabel('time')\n", "plt.ylabel('concentration (A(t))')\n", "plt.plot(times, values, label='stochastic simulation')\n", @@ -124,7 +143,7 @@ "hash": "62b8c3045b77e73a8aab814fbf01ae024ab075fc3f7014742f3a4c5a8ac43e7b" }, "kernelspec": { - "display_name": "Python 3.8.0 32-bit", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -138,9 +157,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" - }, - "orig_nbformat": 4 + "version": "3.7.7" + } }, "nbformat": 4, "nbformat_minor": 2 From 3f1544fcddda167c95a8e625d9ace52b4b557a30 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Tue, 15 Mar 2022 23:19:02 +0000 Subject: [PATCH 39/41] flake8 fix --- pints/toy/stochastic/_michaelis_menten_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pints/toy/stochastic/_michaelis_menten_model.py b/pints/toy/stochastic/_michaelis_menten_model.py index 55c71ea74d..bac2934f44 100644 --- a/pints/toy/stochastic/_michaelis_menten_model.py +++ b/pints/toy/stochastic/_michaelis_menten_model.py @@ -42,6 +42,6 @@ def _propensities(xs, ks): xs[2] * ks[1], xs[2] * ks[2] ] - + def n_outputs(self): return 4 From 93e273797331ad9d4dcde9f2579c503445e68b27 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Tue, 15 Mar 2022 23:36:08 +0000 Subject: [PATCH 40/41] markov jump models: random -> np.random --- pints/tests/test_toy_stochastic_logistic_model.py | 2 +- pints/toy/stochastic/_markov_jump_model.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/pints/tests/test_toy_stochastic_logistic_model.py b/pints/tests/test_toy_stochastic_logistic_model.py index 0eb1314d3d..8f1172358f 100755 --- a/pints/tests/test_toy_stochastic_logistic_model.py +++ b/pints/tests/test_toy_stochastic_logistic_model.py @@ -64,7 +64,7 @@ def test_simulate(self): # Test output of Gillespie algorithm raw_values = np.concatenate(raw_values) - self.assertTrue(np.all(raw_values == np.array(range(1, 51)))) + self.assertTrue(np.all(raw_values == np.array(range(1, 28)))) # Check simulate function returns expected values self.assertTrue(np.all(values[np.where(times < time[1])] == 1)) diff --git a/pints/toy/stochastic/_markov_jump_model.py b/pints/toy/stochastic/_markov_jump_model.py index a89bcf16d3..27098480bc 100644 --- a/pints/toy/stochastic/_markov_jump_model.py +++ b/pints/toy/stochastic/_markov_jump_model.py @@ -8,7 +8,6 @@ import numpy as np from scipy.interpolate import interp1d import pints -import random from .. import ToyModel @@ -112,7 +111,7 @@ def simulate_raw(self, rates, max_time): mol_count = [np.array(x)] time = [t] while prop_sum > 0 and t <= max_time: - r_1, r_2 = random.random(), random.random() + r_1, r_2 = np.random.uniform(0, 1), np.random.uniform(0, 1) t += -np.log(r_1) / (prop_sum) s = 0 r = 0 From 13e8eaecee5490a9259bbf359c4f0f88b45a9009 Mon Sep 17 00:00:00 2001 From: phumtutum Date: Tue, 15 Mar 2022 23:54:42 +0000 Subject: [PATCH 41/41] added test for n_outputs for michaelis menten for coverage --- pints/tests/test_toy_stochastic_michaelis_menten_model.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pints/tests/test_toy_stochastic_michaelis_menten_model.py b/pints/tests/test_toy_stochastic_michaelis_menten_model.py index 35a6e6493e..4b1453699d 100644 --- a/pints/tests/test_toy_stochastic_michaelis_menten_model.py +++ b/pints/tests/test_toy_stochastic_michaelis_menten_model.py @@ -37,6 +37,11 @@ def test_propensities(self): model._propensities(x_0, k), np.array([200.0, 4000.0, 4000.0]))) + def test_n_outputs(self): + x_0 = [1e4, 2e3, 2e4, 0] + model = MichaelisMentenModel(x_0) + self.assertEqual(model.n_outputs(), 4) + if __name__ == '__main__': unittest.main()