From 29131d756249a45505a7aa3f84306d3fa70f81c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Wed, 12 Feb 2020 14:55:07 +0100 Subject: [PATCH 01/14] ignore value error occurring for empty repo in history.git_hash; fixes #264 (#265) --- pyabc/storage/history.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyabc/storage/history.py b/pyabc/storage/history.py index 14ac8cc7d..288712181 100644 --- a/pyabc/storage/history.py +++ b/pyabc/storage/history.py @@ -55,7 +55,7 @@ def git_hash(): return "Install pyABC's optional git dependency for git support" try: git_hash = git.Repo(os.getcwd()).head.commit.hexsha - except (git.exc.NoSuchPathError, KeyError, + except (git.exc.NoSuchPathError, KeyError, ValueError, git.exc.InvalidGitRepositoryError) as e: git_hash = str(e) return git_hash From 38db341fa387c84b74ebf998837b391275c8e522 Mon Sep 17 00:00:00 2001 From: Emad Alamoudi Date: Mon, 17 Feb 2020 13:41:51 +0100 Subject: [PATCH 02/14] N procs (#263) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * closing #109 * fixing flake8 * change the message * fixing * finish logging of core numbers * tidy up Co-authored-by: Yannik Schälte <31767307+yannikschaelte@users.noreply.github.com> --- pyabc/sampler/multicorebase.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pyabc/sampler/multicorebase.py b/pyabc/sampler/multicorebase.py index 36646278e..93fffebb6 100644 --- a/pyabc/sampler/multicorebase.py +++ b/pyabc/sampler/multicorebase.py @@ -3,6 +3,9 @@ from multiprocessing import ProcessError, Process, Queue from queue import Empty from typing import List +import logging + +logger = logging.getLogger("Sampler") class MultiCoreSampler(Sampler): @@ -30,6 +33,9 @@ def __init__(self, self.daemon = daemon self.check_max_eval = check_max_eval + # inform user about number of cores used + logger.info(f"Parallelizing the sampling on {self.n_procs} cores.") + @property def n_procs(self): if self._n_procs is not None: From 3f717e81265616cc74524259f4d0afc8ce6b6262 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Mon, 17 Feb 2020 21:47:16 +0100 Subject: [PATCH 03/14] Fix tests on stopping the sampling (#267) * fix two regularly stochastically failing tests * add explanation * add scaled pdf norm * fix wrong branch * fix errors * fixup --- pyabc/acceptor/pdf_norm.py | 7 ++++--- test/test_stop_sampling.py | 19 +++++++++++++------ 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/pyabc/acceptor/pdf_norm.py b/pyabc/acceptor/pdf_norm.py index 678fa8b84..f0eba18cf 100644 --- a/pyabc/acceptor/pdf_norm.py +++ b/pyabc/acceptor/pdf_norm.py @@ -1,5 +1,6 @@ import numpy as np -from typing import Callable +from typing import Callable, Union +import pandas as pd def pdf_norm_from_kernel( @@ -13,8 +14,8 @@ def pdf_norm_from_kernel( def pdf_norm_max_found( - prev_pdf_norm: float, - get_weighted_distances: Callable, + prev_pdf_norm: Union[float, None], + get_weighted_distances: Callable[[], pd.DataFrame], **kwargs): """ Take as pdf_max the maximum over the values found so far in the history, diff --git a/test/test_stop_sampling.py b/test/test_stop_sampling.py index 9639b665e..047b4fb65 100644 --- a/test/test_stop_sampling.py +++ b/test/test_stop_sampling.py @@ -5,6 +5,7 @@ set_acc_rate = 0.2 +pop_size = 10 def model(x): @@ -16,24 +17,30 @@ def dist(x, y): def test_stop_acceptance_rate_too_low(db_path): - abc = ABCSMC(model, Distribution(par=st.uniform(0, 10)), dist, 10) + abc = ABCSMC(model, Distribution(par=st.uniform(0, 10)), dist, pop_size) abc.new(db_path, {"par": .5}) history = abc.run(-1, 8, min_acceptance_rate=set_acc_rate) df = history.get_all_populations() df["acceptance_rate"] = df["particles"] / df["samples"] assert df["acceptance_rate"].iloc[-1] < set_acc_rate - assert df["acceptance_rate"].iloc[-2] >= set_acc_rate + assert df["acceptance_rate"].iloc[-2] >= set_acc_rate \ + or df["t"].iloc[-2] == -1 # calibration iteration def test_stop_early(db_path): mc_sampler = MulticoreEvalParallelSampler(check_max_eval=True) sc_sampler = SingleCoreSampler(check_max_eval=True) for sampler in [mc_sampler, sc_sampler]: - abc = ABCSMC(model, Distribution(par=st.uniform(0, 10)), dist, 10, - sampler=sampler) + abc = ABCSMC(model, Distribution(par=st.uniform(0, 10)), dist, + pop_size, sampler=sampler) abc.new(db_path, {"par": .5}) history = abc.run( max_nr_populations=8, min_acceptance_rate=set_acc_rate) df = history.get_all_populations() - df["acceptance_rate"] = df["particles"] / df["samples"] - assert df["acceptance_rate"].iloc[-1] >= set_acc_rate + + # offset with n_procs as more processes can have run at termination + n_procs = sampler.n_procs if hasattr(sampler, 'n_procs') else 1 + df["corrected_acceptance_rate"] = \ + (df["particles"] - (n_procs-1)) / df["samples"] + + assert df["corrected_acceptance_rate"].iloc[-1] >= set_acc_rate From d9f56e379adfb3e5a357bef26a0fe8d310676e13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Mon, 17 Feb 2020 21:48:20 +0100 Subject: [PATCH 04/14] Add scaled pdf normalization method (#269) * add scaled pdf norm * add tests for scaled pdf norm * update __init__s --- pyabc/__init__.py | 4 ++- pyabc/acceptor/__init__.py | 2 ++ pyabc/acceptor/pdf_norm.py | 73 ++++++++++++++++++++++++++++++++++++++ test/test_acceptor.py | 58 ++++++++++++++++++++++++++++++ 4 files changed, 136 insertions(+), 1 deletion(-) diff --git a/pyabc/__init__.py b/pyabc/__init__.py index 4fa354a3e..41fc4c15b 100644 --- a/pyabc/__init__.py +++ b/pyabc/__init__.py @@ -75,7 +75,8 @@ UniformAcceptor, StochasticAcceptor, pdf_norm_from_kernel, - pdf_norm_max_found) + pdf_norm_max_found, + ScaledPDFNorm) from .model import ( Model, SimpleModel, @@ -174,6 +175,7 @@ "StochasticAcceptor", "pdf_norm_from_kernel", "pdf_norm_max_found", + "ScaledPDFNorm", # model "ModelResult", "Model", diff --git a/pyabc/acceptor/__init__.py b/pyabc/acceptor/__init__.py index 24e2f4adb..c6f5ef53a 100644 --- a/pyabc/acceptor/__init__.py +++ b/pyabc/acceptor/__init__.py @@ -17,6 +17,7 @@ from .pdf_norm import ( pdf_norm_from_kernel, pdf_norm_max_found, + ScaledPDFNorm, ) @@ -30,4 +31,5 @@ # pdf norm 'pdf_norm_from_kernel', 'pdf_norm_max_found', + 'ScaledPDFNorm', ] diff --git a/pyabc/acceptor/pdf_norm.py b/pyabc/acceptor/pdf_norm.py index f0eba18cf..c959ddffd 100644 --- a/pyabc/acceptor/pdf_norm.py +++ b/pyabc/acceptor/pdf_norm.py @@ -35,3 +35,76 @@ def pdf_norm_max_found( pdf_norm = max(prev_pdf_norm, *pdfs) return pdf_norm + + +class ScaledPDFNorm: + """ + Finds the previously found maximum density value, but then scales it + by a factor `factor**T` such that the probabiliy of particles getting + accepted is increased by y value of up to `factor`. + + Some additional rules are applied to make the scheme stable. The scaling + is in particular applied only after a minimum acceptance rate has been + violated. + + Parameters + ---------- + factor: + The factor by which to effectively rescale the acceptance step's + normalization constant. + alpha: + The ratio by which the subsequent temperature is assumed to be + reduced relative to the current one. This is only accurate if a + pyabc.ExponentialDecayFixedRatioScheme with corresponding ratio + is employed. + min_acceptance_rate: + The scaling is applied once the acceptance rates fall below this + value for the first time. + """ + + def __init__( + self, + factor: float = 10, + alpha: float = 0.5, + min_acceptance_rate: bool = 0.1): + self.factor = 10 + self.alpha = alpha + self.min_acceptance_rate = min_acceptance_rate + self._hit = False + + def __call__( + self, + prev_pdf_norm: Union[float, None], + get_weighted_distances: Callable[[], pd.DataFrame], + prev_temp: Union[float, None], + acceptance_rate: float, + **kwargs): + # base: the maximum found temperature + pdf_norm = pdf_norm_max_found( + prev_pdf_norm=prev_pdf_norm, + get_weighted_distances=get_weighted_distances) + + # log-scale + offset = np.log(self.factor) + + if acceptance_rate >= self.min_acceptance_rate and not self._hit: + # do not apply scaling yet since acceptance rates still feasible + return pdf_norm + + # from now on rescale + self._hit = True + + if prev_temp is None: + # can't take temperature into account, thus effectively assume T=1 + next_temp = 1 + else: + # note: this is only accurate if the temperature is based on a + # ExponentialDecayFixedRatioScheme with the given alpha value + next_temp = self.alpha * prev_temp + + # the offset is multiplied by the next temperature so that the + # effective resulting factor in the acceptance step is as intended + scaled_norm = pdf_norm - offset * next_temp + + # used_norm = max(prev_pdf_norm, used_norm) + return scaled_norm diff --git a/test/test_acceptor.py b/test/test_acceptor.py index bf229673e..ee8522551 100644 --- a/test/test_acceptor.py +++ b/test/test_acceptor.py @@ -1,4 +1,5 @@ import numpy as np +import pandas as pd import tempfile import pyabc @@ -6,6 +7,7 @@ def test_simple_function_acceptor(): + """Test the simple function acceptor.""" def distance(x, x_0): return sum(abs(x[key] - x_0[key]) for key in x_0) @@ -41,6 +43,7 @@ def model(par): def test_uniform_acceptor(): + """Test the uniform acceptor.""" def dist(x, x_0): return sum(abs(x[key] - x_0[key]) for key in x_0) @@ -67,6 +70,7 @@ def dist(x, x_0): def test_stochastic_acceptor(): + """Test the stochastic acceptor's features.""" # store pnorms pnorm_file = tempfile.mkstemp(suffix=".json")[1] acceptor = pyabc.StochasticAcceptor( @@ -99,3 +103,57 @@ def model(par): acceptor=acceptor, population_size=10) abc.new(pyabc.create_sqlite_db_id(), x_0) abc.run(max_nr_populations=3, minimum_epsilon=1.) + + +def test_pdf_norm_methods_integration(): + """Test integration of pdf normalization methods in ABCSMC.""" + def model(par): + return {'s0': par['p0'] + np.array([0.3, 0.7])} + + x_0 = {'s0': np.array([0.4, -0.6])} + + for pdf_norm in [pyabc.pdf_norm_max_found, + pyabc.pdf_norm_from_kernel, + pyabc.ScaledPDFNorm(), + ]: + # just run + acceptor = pyabc.StochasticAcceptor(pdf_norm_method=pdf_norm) + eps = pyabc.Temperature(enforce_exact_final_temperature=False) + distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) + prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) + + abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, + population_size=5) + abc.new(pyabc.create_sqlite_db_id(), x_0) + abc.run(max_nr_populations=2) + + +def test_pdf_norm_methods(): + """Test pdf normalization methods standalone.""" + # preparations + + def _get_weighted_distances(): + return pd.DataFrame({ + 'distance': [1, 2, 3, 4], + 'w': [2, 1, 1, 0]}) + + pdf_norm_args = dict( + kernel_val=42, + prev_pdf_norm=3.5, + get_weighted_distances=_get_weighted_distances, + prev_temp=10.3, + acceptance_rate=0.3 + ) + + # run functions + max_found = max(pdf_norm_args['get_weighted_distances']()['distance']) + assert pyabc.pdf_norm_max_found(**pdf_norm_args) == max_found + assert pyabc.pdf_norm_from_kernel(**pdf_norm_args) == 42 + assert pyabc.ScaledPDFNorm()(**pdf_norm_args) == max_found + + # test additional setups + pdf_norm_args['prev_pdf_norm'] = 4.5 + pdf_norm_args['acceptance_rate'] = 0.05 + assert pyabc.pdf_norm_max_found(**pdf_norm_args) == 4.5 + offsetted_pdf = 4.5 - np.log(10) * 0.5 * pdf_norm_args['prev_temp'] + assert pyabc.ScaledPDFNorm()(**pdf_norm_args) == offsetted_pdf From a40cfd11bec80d24138d1fbf5e1053928e8f98f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Tue, 18 Feb 2020 12:05:08 +0100 Subject: [PATCH 05/14] Support basic PEtab functionality (#268) * add first petab import draft * allow arbitrary prior distributions * extend gitignore, flake8 excludes * parameters: subclass dict directly instead of UserDict (possible in python 3, and to ensure compatibility with python 3.8 * add StochasticKernel to __init__ * add extras_require petab-amici * tidy up petab import; fix namings * add petab, amici to travis reqs * test * install amici dependencies * run petab notebook * adapt nb * add ScaledPDFNorm * create base PEtabImporter * cont * tidy up petab notebook * set "zero transition density" info to debug level * ignore amici_models * add tests for petab * fixup * fix minor errors * fix .travis.yml * update version and releasenotes for 0.10.0 * rerun petab notebook * add petab notebook to docs * address reviewer comments * fix typo * tidy up .gitignore * tidy up --- .gitignore | 2 + .travis.yml | 10 +- .travis_pip_reqs.txt | 2 + doc/examples.rst | 2 + doc/examples/petab.ipynb | 388 +++++++++++++++++++++++++++++++++++++ doc/releasenotes.rst | 15 ++ flake8_exclude.txt | 2 +- pyabc/__init__.py | 2 + pyabc/parameters.py | 5 +- pyabc/petab/__init__.py | 6 + pyabc/petab/amici.py | 138 +++++++++++++ pyabc/petab/base.py | 142 ++++++++++++++ pyabc/smc.py | 2 +- pyabc/version.py | 2 +- setup.py | 3 +- test/test_petab.py | 55 ++++++ test/test_stop_sampling.py | 2 +- 17 files changed, 767 insertions(+), 11 deletions(-) create mode 100644 doc/examples/petab.ipynb create mode 100644 pyabc/petab/__init__.py create mode 100644 pyabc/petab/amici.py create mode 100644 pyabc/petab/base.py create mode 100644 test/test_petab.py diff --git a/.gitignore b/.gitignore index e01ba7a9d..701abfe67 100644 --- a/.gitignore +++ b/.gitignore @@ -89,3 +89,5 @@ doc/*.log .pytest_cache dask-worker-space *.lock +*tmp* +*amici_models* diff --git a/.travis.yml b/.travis.yml index 0fcc40e29..5b377b11f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,6 +7,8 @@ os: dist: # take the latest supported LTS version - xenial +compiler: +- gcc # install dependencies @@ -16,14 +18,18 @@ before_install: - sudo add-apt-repository 'deb https://cran.rstudio.com/bin/linux/ubuntu xenial/' - sudo apt-get update - sudo apt-get install r-base r-base-dev r-base-core r-recommended -# from apt + addons: apt: update: true packages: - redis-server -# from pip + - libhdf5-serial-dev + - libatlas-base-dev + - swig3.0 + install: +- mkdir -p ~/bin/ && ln -s /usr/bin/swig3.0 ~/bin/swig && export PATH=~/bin/:$PATH - pip install --upgrade . - pip install --upgrade -r .travis_pip_reqs.txt - pip install --upgrade pytest diff --git a/.travis_pip_reqs.txt b/.travis_pip_reqs.txt index fcceff49f..28fa215bb 100644 --- a/.travis_pip_reqs.txt +++ b/.travis_pip_reqs.txt @@ -30,3 +30,5 @@ flake8 pytest codecov pytest-cov +git+https://github.com/icb-dcm/petab.git@develop +amici diff --git a/doc/examples.rst b/doc/examples.rst index a171e939d..28456eb13 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -22,6 +22,7 @@ The following examples should help to get a better idea of how to use pyABC. examples/external_simulators.ipynb examples/data_plots.ipynb examples/noise.ipynb + examples/petab.ipynb Download the examples as notebooks @@ -42,6 +43,7 @@ Download the examples as notebooks * :download:`External Simulators ` * :download:`Data plots ` * :download:`Measurement noise assessment ` +* :download:`PEtab import ` .. warning:: diff --git a/doc/examples/petab.ipynb b/doc/examples/petab.ipynb new file mode 100644 index 000000000..d37837da2 --- /dev/null +++ b/doc/examples/petab.ipynb @@ -0,0 +1,388 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PEtab import" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[PEtab](https://github.com/petab-dev/petab) is a format for specifying parameter estimation problems in systems biology. This notebook illustrates how the PEtab format can be used together with the ODE simulation toolbox [AMICI](https://github.com/icb-dcm/amici) to define ODE based parameter estimation problems for pyABC. Then, in pyABC we can perform exact sampling based on the algorithms introduced in [this preprint](https://www.biorxiv.org/content/10.1101/2020.01.30.927004v1.abstract).\n", + "\n", + "To use this functionality, you need to have (at least) PEtab and AMICI installed. You can obtain these by installing pyABC with\n", + "\n", + " pip install pyabc[amici-petab]\n", + " \n", + "or installing them manually via\n", + "\n", + " pip install petab amici\n", + "\n", + "See also the tools' installation guides for [amici](https://github.com/ICB-DCM/AMICI/blob/master/INSTALL.md) and [petab](https://github.com/PEtab-dev/PEtab/tree/8a4461c178c0799e58ff483fc9ce3f39de5fddbc#petab-python-library)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yannik/anaconda3/lib/python3.7/site-packages/rpy2/robjects/pandas2ri.py:14: FutureWarning: pandas.core.index is deprecated and will be removed in a future version. The public classes are available in the top-level namespace.\n", + " from pandas.core.index import Index as PandasIndex\n" + ] + } + ], + "source": [ + "import petab\n", + "import pyabc\n", + "import amici.petab_import\n", + "from pyabc.petab import AmiciPetabImporter\n", + "import numpy as np\n", + "import os\n", + "\n", + "os.environ[\"OMP_NUM_THREADS\"] = \"1\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We illustrate the usage of PEtab models using a model taken from the benchmark collection. Uncomment the following cell to clone the git repository." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'tmp/benchmark-models'...\n", + "remote: Enumerating objects: 3511, done.\u001b[K\n", + "remote: Counting objects: 100% (3511/3511), done.\u001b[K\n", + "remote: Compressing objects: 100% (922/922), done.\u001b[K\n", + "remote: Total 3511 (delta 2695), reused 3170 (delta 2564), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (3511/3511), 201.90 MiB | 20.18 MiB/s, done.\n", + "Resolving deltas: 100% (2695/2695), done.\n", + "Checking out files: 100% (3411/3411), done.\n" + ] + } + ], + "source": [ + "!git clone --depth 1 https://github.com/LeonardSchmiester/Benchmark-Models.git \\\n", + " tmp/benchmark-models || (cd tmp/benchmark-models && git pull)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can import a problem, here using the \"Boehm_JProteomer2014\" example, to AMICI and PEtab:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# read the petab problem from yaml\n", + "petab_problem = petab.Problem.from_yaml(\n", + " \"tmp/benchmark-models/hackathon_contributions_new_data_format/\"\n", + " \"Boehm_JProteomeRes2014/Boehm_JProteomeRes2014.yaml\")\n", + "\n", + "# compile the petab problem to an AMICI ODE model\n", + "model = amici.petab_import.import_petab_problem(petab_problem)\n", + "\n", + "# the solver to numerically solve the ODE\n", + "solver = model.getSolver()\n", + "\n", + "# import everything to pyABC\n", + "importer = AmiciPetabImporter(petab_problem, model, solver)\n", + "\n", + "# extract what we need from the importer\n", + "prior = importer.create_prior()\n", + "model = importer.create_model()\n", + "kernel = importer.create_kernel()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once everything has been compiled and imported, we can simply call the model:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'llh': -138.22199570334107}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model(petab_problem.x_nominal_free_scaled)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, this only returns the log likelihood value. If also simulated data are to be returned (and stored in the pyABC datastore), pass `store_simulations=True` to the importer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's all. Now we can run an analysis using pyABC's exact sequential sampler under the assumption of measurement noise. Note that the following cell takes, depending on the resources, minutes to hours to run through. Also, the resulting database is not provides here." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Sampler:Parallelizing the sampling on 20 cores.\n", + "INFO:History:Start \n", + "INFO:ABC:Calibration sample before t=0.\n", + "INFO:ABC:t: 0, eps: 49386005.386943504.\n", + "INFO:ABC:Acceptance rate: 1000 / 3348 = 2.9869e-01, ESS=1.0000e+03.\n", + "INFO:ABC:t: 1, eps: 3707.524037573809.\n", + "INFO:ABC:Acceptance rate: 1000 / 3582 = 2.7917e-01, ESS=3.0162e+02.\n", + "INFO:ABC:t: 2, eps: 189.0069260595768.\n", + "INFO:ABC:Acceptance rate: 1000 / 3753 = 2.6645e-01, ESS=2.9065e+02.\n", + "INFO:ABC:t: 3, eps: 94.5034630297884.\n", + "INFO:ABC:Acceptance rate: 1000 / 6376 = 1.5684e-01, ESS=3.2931e+02.\n", + "INFO:ABC:t: 4, eps: 47.2517315148942.\n", + "INFO:ABC:Acceptance rate: 1000 / 16933 = 5.9056e-02, ESS=2.7417e+02.\n", + "INFO:ABC:t: 5, eps: 23.6258657574471.\n", + "INFO:ABC:Acceptance rate: 1000 / 6990 = 1.4306e-01, ESS=3.6511e+02.\n", + "INFO:ABC:t: 6, eps: 11.81293287872355.\n", + "INFO:ABC:Acceptance rate: 1000 / 50479 = 1.9810e-02, ESS=2.3205e+02.\n", + "INFO:ABC:t: 7, eps: 5.906466439361775.\n", + "INFO:ABC:Acceptance rate: 1000 / 141531 = 7.0656e-03, ESS=3.0510e+01.\n", + "INFO:ABC:t: 8, eps: 2.9532332196808877.\n", + "INFO:ABC:Acceptance rate: 1000 / 54532 = 1.8338e-02, ESS=2.7007e+01.\n", + "INFO:ABC:t: 9, eps: 1.4766166098404439.\n", + "INFO:ABC:Acceptance rate: 1000 / 21583 = 4.6333e-02, ESS=3.9807e+00.\n", + "INFO:ABC:t: 10, eps: 1.0.\n", + "INFO:ABC:Acceptance rate: 1000 / 12382 = 8.0762e-02, ESS=1.3817e+01.\n", + "INFO:ABC:Stopping: minimum epsilon.\n", + "INFO:History:Done \n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# this takes some time\n", + "\n", + "sampler = pyabc.MulticoreEvalParallelSampler(n_procs=20)\n", + "\n", + "temperature = pyabc.Temperature()\n", + "acceptor = pyabc.StochasticAcceptor(\n", + " pdf_norm_method = pyabc.ScaledPDFNorm())\n", + "\n", + "abc = pyabc.ABCSMC(model, prior, kernel, \n", + " eps=temperature,\n", + " acceptor=acceptor,\n", + " sampler=sampler,\n", + " population_size=1000)\n", + "abc.new(\"sqlite:///tmp/petab_amici_boehm.db\", {})\n", + "abc.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use pyABC's standard analysis and visualization routines to analyze the obtained posterior sample. In particular, we can extract boundaries and literature parameter values from the PEtab problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEHCAYAAACk6V2yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAfzklEQVR4nO3df5zUdbn38de1s7M7g6IioKQgpHk4GaYVZWgdOYq3aKkdtQQPlJrRD72Tx612q5lmecpusaMe9RyxY6h4wkI6iSnpWlge0QDD1AwrUhFFARVTZnZnZ677j/mxv2Z3B5jPd3Z33s/Hgwcz3x/zvZgHXPvh+l7fz8fcHRERGXoaah2AiIiEoQQvIjJEKcGLiAxRSvAiIkOUEryIyBDVWOsAOhs1apRPmDCh1mGIiAwaq1ev3uzuo8vtG1AJfsKECaxatarWYYhU3fr16wEYN25cjSORocbMXuht34BK8CJD1ezZswFYvnx5bQORuqIELxKBSy+9tNYhSB1SgheJwLRp02odgtQhddGIRGDdunWsW7eu1mFIndEIXiQCZ511FqAavERLCV4kAldccUWtQ5A6pAQvEoEjjzyy1iFIHVINXiQCyx9fwy/+54lahyF1RiN4kQicfsbnaWvPsflPv6t1KFJHlOBFIvC+k77I62+31ToMqTNK8CIR2HW/9/H21nStw5A6oxq8SAQ2vfhn3njpL7UOQ+qMErxIBJ7+yb/y4r031DoMqTPBSzRmFgNWARvc/ZOhrycyEI099gtseacNd8fMah2O1IkoavDnAc8Cu0VwLZEBqXHMgTRvy9DaniMRj9U6HKkTQUs0ZjYW+ATwg5DXERno3njxOdpeXUeqLVvrUKSOhB7BXwt8DRje2wFmNgeYA7DffvsFDkckermc8+oDNwOQypzNiBrHI/UjWII3s08Cr7n7ajOb2ttx7j4fmA8wefJkDxWPSK20tufY8+g5AKQzGsFLdEKO4I8ATjSz44EEsJuZLXT3WQGvKTLgpDJZmvbev/RaJCrBavDufrG7j3X3CcAM4JdK7lKPUpksra88R+srz5HO5GodjtQRPckqElg6k+WNX91aeD27xtFIPYkkwbv7cmB5FNcSGWhSbVn2POZLpdciUdEIXiSwdCZL0+gJ+dftSvASHSV4kcDSmRzpl54FINX2/hpHI/VEc9GIBJbKZHnz17fx5q9vU5ukREojeJHA0pksI489t/BaXTQSHSV4kcBSmSzxkWNLr0WiogQvElg6kyX94lOF1wfUOBqpJ0rwIoGlM1nefOROzIzUzBNqHY7UESV4kcBSbTlGHj+XEcm4brJKpJTgRQJLZbLsMmof9twtoZusEim1SYoEls5kaX9xDe/89Qk9ySqR0gheJLB0JsvmRxbxVqyBSR/+eK3DkTqiBC8SWCqT5aCZlzB612bV4CVSSvAigaUzWfYY/S723C3Bm9vaah2O1BEleJHAUpkcW/+0koZhTbTvo7loJDq6ySoSWLoty19a7uT3P79NXTQSKY3gRQJLt2f5xy//C3sNb+axjarBS3Q0ghcJLNWWZeTovRi11966ySqR0gheJLBUJsuG3z/CO8km0pnxtQ5H6ogSvEhg6UyONT9fSFOsgcxxl9GezdEY03+eJTwleJHA0pksMy++lr2GN3P9o6+Sbs+xqxK8REB/y0QCS2eyjBw1ktGjRwFaeFuioxG8SECZbI72nLP2sRZeTTYB++pGq0RGCV4koOIKTr/574U0NTbA0V9XgpfIKMGLBFRM5udffQt7D09w3k+f07J9EhkleJGA0m35J1dHjhjBqN0T+W16mlUiogQvElBxtL7yl/eyezIOjNEIXiKjBC8SULFEs+wntxNvbIB/uFhdNBIZtUmKBFQcrX//1kUs+NESAFrbleAlGhrBiwRUTPAjdhvOiN3yNXiN4CUqSvAiAbUWEvwD9yxmj2QcGK0avERGCV4koGIy/+mPbs/3wU/5mrpoJDKqwYsElCq0SS6+5z5aHnwwv00jeImIRvAiARW7aIYnEzQ1xUnEG0plG5HQlOBFAiqO1n/8ozuIxxpIxvfRCF4iowQvElBrJosZ3HnH7QAkjv2GumgkMqrBiwSUymRJxmMsX76c5cuXk4zHSLfrJqtEQwleJKBigi9qjsc0gpfIqEQjElA6kyMRj3HLLbcAkIwfpOmCJTLBEryZJYBfA82F6yx298tDXU9kIEplsiTiDdx1110A7D3jSiV4iUzIEk0rcJS7HwIcCkw3s48GvJ7IgJNuy5JsitHS0kJLSwuJxpi6aCQywUbw7u7A24W38cIvD3U9kYEo3Z4l0dhRg080KcFLdILW4M0sBqwG3gPc6O6Ph7yeyECTasuyS3MjN910EwDJ0UfQqqkKJCJBu2jcPevuhwJjgY+Y2aTux5jZHDNbZWarNm3aFDIckcilCjdZly5dytKlS0nEGzSCl8hE0ibp7m8CvwKml9k3390nu/vk0aNHRxGOSGRaM1kS8Rj3338/999/f74PXgleIhIswZvZaDPbo/A6CRwD/DHU9UQGonwffMc/s0Q8X4PP36ISCStkDf5dwG2FOnwD8GN3vzfg9UQGnOKDTtdddx0Aifd/Andobc+XbkRCCtlF83vgA6E+X2QwSBdKNA899BAAn/rQiQC0ZpTgJTw9ySoSiLuXnmS95557APivx18E8iP73YnXMjypA5qLRiSQ1sKkYp1H6smm/D85ddJIFDSCFwmkOKlYMt7AvHnzAJg0/Z8B1EkjkdAIXiSQ4ig92RRjxYoVrFixgubCaF4jeImCRvAigRRH6Yl4jLvvvhuAx9Zt6bJPJCSN4EUCSXVK8EXFueGV4CUKGsGLBFJM4sl4jKuuugqAfzrjHABSbZqPRsJTghcJJJ3p6KJZs2YNAKdrBC8RUoIXCaSjiybGokWLAHjtrXR+nxK8REA1eJFAOrpoOs1F06QRvERHI3iRQIpJvLkxxre//W0ALrrk6132iYSkBC8SSLpTH/zatWsBiMcaiDWYSjQSCSV4kUBSnbpoFi5cWNqenxNeXTQSnmrwIoF07qLprDgnvEhoSvAigaQyWZoKJZnLLruMyy67DIBEvIF0mxK8hKcSjUggqbYszYXVnNavX1/anozHSLcrwUt4SvAigbS2Z0tTE/zwhz8sbU/EY6UeeZGQVKIRCSTVliXZ1HPVpqRq8BKRfhO8mTWY2WeiCEZkKElnciQa8wn+4osv5uKLLwbyDzupi0ai0G+Cd/cc8LUIYhEZUlKZbOnJ1S1btrBlS36q4ERjgx50kkhUWoNvMbMLgLuAd4ob3f31IFGJDAGpTJZk4Sbr/PnzS9uTTTEleIlEpQn+tMLv53Ta5sD+1Q1HZOhozWQZsUtTj+2qwUtUKkrw7v7u0IGIDDWpTJZ9Cl00F1xwAQDz5s1TF41EpqIEb2Zx4MvAPxQ2LQdudvdMoLhEBr18iaawBmsqVdqeiMdIt+smq4RXaYnm34E4cFPh/ezCtrNDBCUyFKQzudIi2zfeeGNpezIeo609RzbnxBqsVuFJHag0wX/Y3Q/p9P6XZvZkiIBEhop0W8cIvrNE4cZrOpNll2Y9ayjhVPqgU9bMDii+MbP9ARURRfqQymRLi33MnTuXuXPnApQeflInjYRW6fDhQuBXZrYOMGA8cGawqEQGuUw2R3vOSw86dVbcpk4aCa3SLpqHzOxAYGJh01p3bw0Xlsjg1nmxD4Brr722tE/L9klU+kzwZnaUu//SzE7utus9Zoa7LwkYm8igVRydN5epwRfr8pquQELrbwR/JPBL4IQy+xxQghcpo7WQvIvJ/Jxz8s8I3njjjaWbrCrRSGh9Jnh3v9zMGoD73f3HEcUkMuh1Xq4PIJlMlvZ1jOCV4CWsfmvw7p4zs68BSvAiFSom7+Jofd68eaV9xSX89DSrhFZpm2SLmV1gZuPMbM/ir6CRiQxixeRdvg9eXTQSDU02JhJAMXkXO2bmzJkD5GeVLHbWtOomqwSmycZEAih2yBR73keOHFnal2jUTVaJRqWTjQ0D/g+wn7vPKfbEu/u9QaMTGaS698F/97vfLe0rblOCl9AqrcH/EGgDDi+83wBcGSQikSGgexdNZ8VRvbpoJLRKE/wB7v7/gAyAu28jP2WBiJTRvYvmzDPP5Mwz87N7NDQYTY0NGsFLcJXeZG0zsyT5G6sUJh7rc6oCMxsH3A7sXThvvrtftxOxigwapZushRH8uHHjuuxPxmO6ySrBVZrgvwksA8aZ2Z3AEfQ/2Vg7cL67P2Fmw4HVZvagu/9hh6MVGSTSbVnMoLlwQ/Vb3/pWl/1JreokEai0i+YBM1sNfJR8aeY8d9/czzmvAK8UXv/NzJ4F9gWU4GXIS7fnSDTGMCtfyUzEVaKR8CqqwZvZQ+6+xd1/7u73uvtmM3uo0ouY2QTgA8DjZfbNMbNVZrZq06ZNlX6kyICWasuWumUAZs2axaxZs0rvE/GYbrJKcP3NJpkAhgGjzGwEHTdWdyM/Gu+Xme0K3A3Mdfe3uu939/nAfIDJkyd75aGLDFypTLbU7w4wceLELvuTTTGN4CW4/ko0XwTmAvsAq+lI8G8BN/T34YXFuu8G7tTUwlJP0pls6SlWgG984xtd9icaNYKX8PqbTfI64Doz+9/u/m/b88GWLz7+J/Csu39/J2IUGXTSmfLrsRYlm2Js+lt7hBFJPaq0D35joRMGM7vUzJaY2Qf7OecIYDZwlJmtKfw6fmeCFRks0plcqUUSYMaMGcyYMaP0XjdZJQqVtkl+w91/YmYfA6YBVwP/DhzW2wnu/gh6GErqVKrbCP7QQw/tsl83WSUKlSb44t/ET5B/YOnnZqapCkR6kWrLMmJYU+n9RRdd1GV/UgleIlBpiWaDmd1Mftrg+8yseTvOFak76fZsaZqCchJ60EkiUGmS/gzwC+BYd38T2BO4MFhUIoNcuq1rieaUU07hlFNOKb1PxmOk23O4qzNYwqn0SdZtZvYX4FgzOxb4jbs/EDY0kcErlen6oNOUKVO67E82xcjmnEzWaWrUrSoJo9L54M8DvgAUe9kXmtn87W2dFKkX3btoLrjggi77mzst+tHUqGqnhFHpTdbPA4e5+zsAZvY9YAWgBC/Sjbvnn2Ttpw8eoDWThWQ8qtCkzlQ6dDA6OmkovNb/K0XKaG3PTwPcuQZ/4okncuKJJ5beFxf9UC+8hFTpCP6HwONm9tPC+0+Rf0pVRLrpvtgHwNFHH93lGC3bJ1Go9Cbr981sOfCxwqYz3f13waISGcTKLdd33nnndTmmuC+tRT8koEpmk/wS8B7gKeAmd9cEGiJ9KPa391WDby6M7tULLyH1V4O/DZhMPrkfB8wLHpHIIFcclXdO8McddxzHHXdc6X1pBN+uBC/h9FeiOcjdDwYws/8Efhs+JJHBrVSi6dQHf8IJJ3Q5prgvrRG8BNRfgs8UX7h7e2/Lj4lIh9JN1k797V/5yle6HKMuGolCfwn+EDMrrsJkQLLw3gB3992CRicyCKXLjOC7K43gdZNVAupvwY/e/4aKSFnlumimTZsGQEtLC9BRn9cIXkKqtA9eRCpU7ibraaed1uWYYo+8pgyWkJTgRaoslenZJvmFL3yhyzFNsQYaTAlewtIsRyJVVuyM6asGb2aaE16CU4IXqbJyXTRTp05l6tSpXY7LzwmvBC/hqEQjUmWpTJZ4zGiMdST4M844o8dx+RG8umgkHCV4kSorN1Vw+QTfoBq8BKUSjUiVdV/sAyCTyZDJZLpsSzZp4W0JSyN4kSpLZ7quxwpwzDHHALB8+fLStmQ8pj54CUoJXqTKUm3ZLnPBA5x99tk9jkvEY7zdqslZJRwleJEqS7f3HMHPmjWrx3GJeIzNb7dFFZbUIdXgRaosP4LvmuC3bdvGtm3bumxLxFWDl7A0ghepsnQmyx7DmrpsO/7444HuNXh10UhYSvAiVZbO5HqUaL785S/3OE43WSU0JXiRKktlsj2mKeg+2RigqQokONXgRaosnenZRbN161a2bt3aZVsiHqO1PUcu51GGJ3VEI3iRKiv3JOtJJ50EdKvBF0b5re25PicmE9lRSvAiVVbuQaevfvWrPY4rTkZWrqQjUg1K8CJV1J7Nkcl6jxH8ySef3OPYjmX7VIeXMFSDF6midHt+dsjuI/jNmzezefPmLtu0bJ+EphG8SBUVu2IS3Uoup556KtC1Bl9K8OqkkUCU4EWqqNxiHwDnn39+j2OLo/xWLfohgSjBi1RRMcF3v2l6wgkn9Di2YwSvRT8kDNXgRaqotOB2Y9cEv3HjRjZu3NhlW3EEr5usEkqwBG9mt5rZa2b2dKhriAw06UzhJmu3EfyMGTOYMWNGl23Jpo42SZEQQpZoFgA3ALcHvIbIgFIawXfrornooot6HNvcqC4aCStYgnf3X5vZhFCfLzIQlbpouk1VMH369B7Hlp5kVYKXQFSDF6miYkdM9z749evXs379+i7bkuqDl8Bq3kVjZnOAOQD77bdfjaMR2TnFEXz3Gvzs2bOB3vrg1UUjYdQ8wbv7fGA+wOTJkzWtngxq6V66aC699NIex8YajKZYA2n1wUsgNU/wIkNJqpcummnTppU9vjneoCdZJZiQbZI/AlYAE83sJTP7fKhriQwUxXp6c7cnWdetW8e6det6HJ+Mx/QkqwQTsotmZqjPFhmoWguLfZhZl+1nnXUW0LUGD/mRvkbwEopKNCJVlCozFzzAFVdcUfb4RKPWZZVwlOBFqijVVj7BH3nkkWWPTzTFSk+/ilSb+uBFqijdnuvxFCvA2rVrWbt2bY/tyXiDRvASjEbwIlWUauu5HivAF7/4RaBnDT4Rj/H6O21RhCZ1SAlepIrShZus3X3nO98pe3wyHtNskhKMErxIFaV7WUD78MMPL3t8Mq6brBKOavAiVdRbF83TTz/N00/3nDm7Oa6brBKORvAiVZTKZGkuk+DPPfdcoEwffDxGWn3wEogSvEgVtWZyZUfwV199ddnjE+qikYCU4EWqqLcSzYc//OGyxyfjMdpzTiabIx5TxVSqS3+jRKoo3ybZ85/VmjVrWLNmTY/txRuy6qSREDSCF6kSdyfdXn4EP3fuXKBnDb6506IfwxPx4DFKfVGCF6mS1vYc7vnpB7q79tpry55T/GHQqk4aCUAJXqRKikm6+2IfAIceemjZc7Rsn4SkGrxIlRSTdLkHnVauXMnKlSt7bC/W61WDlxA0ghepklKCL1ODv/DCC4HyffCA5oSXIJTgRaqktB5rmS6aG264oew5zSrRSEBK8CJVkiol+J4j+EmTJpU9pziC13QFEoJq8CJVUpxyoFyCf/TRR3n00Ud7bFcfvISkEbxIlaTbe6/BX3LJJUC5+eDzYyyVaCQEJXiRKkm15css5bpobr755rLndJRolOCl+pTgRaqkVIMv0wc/ceLEsuckdJNVAlINXqRKSl00TT3/WT388MM8/PDDPbY3NzZghqYMliA0ghepknQfffCXX3450LMGb2YkGmOk29VFI9WnBC9SJak+umhuvfXWXs9LNsX0oJMEoQQvUiVvbMsQj1nZed3333//Xs9LNDawTQleAlANXqQK2tpzLP39y3zsPaPK7m9paaGlpaXsvoljhvPInzeRyapMI9WlBC9SBb94ZiOb/tbKZw+fUHb/lVdeyZVXXll23+wp43n1rVaWPb0xYIRSj1SiEamC21c8z/iRwzjywNFl999xxx29njv17/Zi/MhhLHj0eU44ZJ9AEUo90gheZCc9+8pbrHz+DWYdNp6GBit7zLhx4xg3blzZfQ0NxmenTGD1C2/w9IatIUOVOqMEL7KTbl/xAol4A5+ePLbXY5YtW8ayZct63f/pyWMZ1hRjwaPPB4hQ6pUSvMhO2JrK8N+/28BJh+zLHsOaej3uqquu4qqrrup1/26JOCd/cF/uefJltrzdGiJUqUNK8CI7YfHql0hlssyeMr7P4xYtWsSiRYv6POZzUybQ1p5j0cr11QxR6pgSvMgOyuWcO1Y8z4fGj2DSvrv3eeyYMWMYM2ZMn8ccuPdwPvaeUSx87AW1TEpVKMGL7KDf/Hkzz2/Zxmf7Gb0DLF26lKVLl/Z73OcOn8ArW9M88Myr1QhR6pwSvMgOumPF84zatYnpk/oemQNcc801XHPNNf0ed9Tf78XYEUlu081WqQIleJEdsP71bTz0x9eY+ZH9aC4zPXB3ixcvZvHixf0eF2swPjdlAr99/nWeeVktk7JzlOBFdsDCx1+gwYzTD9uvouNHjRrFqFHlpzHo7jOTx5GMxzSKl52mBC+yndKZLHetXM8x792bd+2erOicJUuWsGTJkoqO3X1YnE99YF9+tuZlXn+nbWdClToXNMGb2XQzW2tmfzazi0JeSyQqS598mTe3Zfjs4f3fXC26/vrruf766ys+/ozDJ9DanmPRyhd3JEQRIOBcNGYWA24EjgFeAlaa2T3u/odQ1xQJzd25fcULHLjXrkzZf2TF5/3sZz/brutMHDOcKfuPZOGKF5jz8f1pLDMFsUh/Qk429hHgz+6+DsDMFgEnAb0m+L9ufofTb3ksYEgilXEvvz2bc57asJVvnfQ+zMrPO1PO7rv33SdfzucOn8CXFq7mlP9YwbAyi4gAbEcIUodCJvh9gc6P5L0EHNb9IDObA8wB2OVdB+gBDxkwjPLZ85iD9ubkD/Y+70w5d911FwCnnXZaxeccc9De/NMH9mXDGymyuZ4/cZxefgqJFJj3NlTZ2Q82OxWY7u5nF97PBg5z93N7O2fy5Mm+atWqIPGI1NLUqVOBnmuyiuwsM1vt7pPL7Qs5gt8AdJ4fdWxhm0jdue+++2odgtShkHduVgIHmtm7zawJmAHcE/B6IgPWsGHDGDZsWK3DkDoTbATv7u1mdi7wCyAG3Oruz4S6nshAtnDhQgBmzZpV40ikngRdss/d7wP0f1Opez/4wQ8AJXiJltZkFYnAgw8+WOsQpA4pwYtEIB6P1zoEqUN6PE4kAgsWLGDBggW1DkPqjBK8SASU4KUWgj3otCPMbBPwQo3DGAVsrnEMA4W+iw76Ljrou+gwEL6L8e4+utyOAZXgBwIzW9XbU2H1Rt9FB30XHfRddBjo34VKNCIiQ5QSvIjIEKUE39P8WgcwgOi76KDvooO+iw4D+rtQDV5EZIjSCF5EZIhSghcRGaKU4PtgZuebmZvZqFrHUitmdrWZ/dHMfm9mPzWzPWodU5S0cHyemY0zs1+Z2R/M7BkzO6/WMdWamcXM7Hdmdm+tY+mNEnwvzGwc8L+Ael/W/kFgkru/H3gOuLjG8USm08LxxwEHATPN7KDaRlUz7cD57n4Q8FHgnDr+LorOA56tdRB9UYLv3b8CX4P6XvjS3R9w9/bC28fIr8xVL0oLx7t7G1BcOL7uuPsr7v5E4fXfyCe2fWsbVe2Y2VjgE8APah1LX5TgyzCzk4AN7v5krWMZYM4C7q91EBEqt3B83Sa1IjObAHwAeLy2kdTUteQHgLlaB9KXup0u2MxagDFldn0duIR8eaYu9PVduPvPCsd8nfx/0++MMjYZWMxsV+BuYK67v1XreGrBzD4JvObuq81saq3j6UvdJnh3n1Zuu5kdDLwbeNLMIF+SeMLMPuLuGyMMMTK9fRdFZnYG8EngaK+vBye0cHwnZhYnn9zvdPcltY6nho4ATjSz44EEsJuZLXT3Abdclx506oeZPQ9MdvdazxhXE2Y2Hfg+cKS7b6p1PFEys0byN5aPJp/YVwKn1+PawpYf7dwGvO7uc2sdz0BRGMFf4O6frHUs5agGL/25ARgOPGhma8zsP2odUFQKN5eLC8c/C/y4HpN7wRHAbOCowt+DNYURrAxgGsGLiAxRGsGLiAxRSvAiIkOUEryIyBClBC8iMkQpwYuIDFFK8CIiQ5QSvAwqZjZ1e6ZnNbNhZnanmT1lZk+b2SNmNr5TL/dGM9vQ6X1T4bxPFaaK/vvC+4M7HfO6mf218LqlsD/baf893WIYZWYZM/tSFb+HBWZ2arU+T4amup2qQIa+wpOo5wGvuvvBhW0TgY3ufmjh/TeBt919XrfTZwKPFH6/3N2fAornLADudffFnY5PFT+zjE+Tn4lzJlDxg2JmFnP3bKXHi3SnBC8DipntAvyY/LwvMeDbwFbys/dtI590+zr/m8ABwP7k5/LfBLxQ3O/uayuIYVfgY8A/AkuBy7f/T9LFTOB84L/MbKy7v9THtd8GbgamkZ9zPUV+qohdgc3AGe7+yk7GI3VCJRoZaKYDL7v7Ie4+CVgG3AKcAHyI8rNedncQMM3dZwK3Av/XzFaY2ZVmdmAF558ELHP354AtZvahCs5JmNkqM3vMzD5V3FhYOOZd7v5b8j+4Tuvnc3YBHnf3Q8hPx/tvwKnu/qHCn+VfKohFBFCCl4HnKeAYM/uemX2c/Myef3X3PxVmslxYwWfc4+4pAHdfQ340fzWwJ7DSzN7bz/kzyS/uQeH3mRVcc7y7TwZOB641swMK208jn9gr/aws+RkbASYCkyjMAwRcSn0tuCI7SSUaGVDc/Tkz+yBwPHAl8NAOfMw73T7zbWAJsMTMcoXPLrvUmpntCRwFHGxmTr5M5GZ2YV9TJbv7hsLv68xsOfkFMf5CPqGPMbN/Lhy6j5kd6O5/6uWj0p3q7gY84+5T+v0Ti5ShEbwMKGa2D7DN3ReSH3UfDkzoNCKuZDTd+fOOMLMRhddN5Ms3L/RxyqnAHe4+3t0nuPs44K/Ax/u4xggzay68HkV+5sU/mNnfAbu6+76Fz5oAfHc7/gxrgdFmNqXw2XEze1+F54oowcuAczDw20JJ4nLyZYk5wM/N7Angte38vAOAh83sKeB3wCo6SiDlzAR+2m3b3fSdlN8LrDKzJ4FfAVe5+x928LNKCuvAngp8r/DZa8j/wBOpiKYLFhEZojSCFxEZonSTVQYlMzuT/ENMnf2Pu59Ti3i2l5k9DjR32zy78ECVSFWoRCMiMkSpRCMiMkQpwYuIDFFK8CIiQ5QSvIjIEPX/ARpKqYqc0yGjAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "h = pyabc.History(\"sqlite:///tmp/petab_amici_boehm.db\", _id=1)\n", + "refval = {k: v for k,v in zip(petab_problem.x_free_ids, petab_problem.x_nominal_free_scaled)}\n", + "for i, par in enumerate(petab_problem.x_free_ids):\n", + " pyabc.visualization.plot_kde_1d_highlevel(\n", + " h, x=par,\n", + " xmin=petab_problem.get_lb(scaled=True,fixed=False)[i],\n", + " xmax=petab_problem.get_ub(scaled=True,fixed=False)[i],\n", + " refval=refval, refval_color='k')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Apparently, in this case seven out of the nine parameters can be estimated with high confidence, while two other parameters can only be bounded." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index 50640a49f..64b2f6b18 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -4,6 +4,21 @@ Release Notes ============= +0.10 series +........... + + +0.10.0 (2020-02-18) +------------------- + +* Exact inference via stochastic acceptor finalized and tested (developed + throughout the 0.9 series). +* Support basic PEtab functionality using AMICI ODE simulations (#268). +* Various error fixes (#265, #267). +* Log number of processes used by multiprocessing samplers (#263). +* Implement pyabc.acceptor.ScaledPDFNorm (#269). + + 0.9 series .......... diff --git a/flake8_exclude.txt b/flake8_exclude.txt index 43a938890..24c995cde 100644 --- a/flake8_exclude.txt +++ b/flake8_exclude.txt @@ -1 +1 @@ -doc/conf.py,test_nondeterministic,build,test_performance,tmp +doc/conf.py,test_nondeterministic,build,test_performance,tmp,*amici_models* diff --git a/pyabc/__init__.py b/pyabc/__init__.py index 41fc4c15b..68ee37fb8 100644 --- a/pyabc/__init__.py +++ b/pyabc/__init__.py @@ -33,6 +33,7 @@ PercentileDistance, RangeEstimatorDistance, DistanceWithMeasureList, + StochasticKernel, NormalKernel, IndependentNormalKernel, IndependentLaplaceKernel, @@ -116,6 +117,7 @@ "PercentileDistance", "RangeEstimatorDistance", "DistanceWithMeasureList", + "StochasticKernel", "NormalKernel", "IndependentNormalKernel", "IndependentLaplaceKernel", diff --git a/pyabc/parameters.py b/pyabc/parameters.py index 26233db19..a0956e1ef 100644 --- a/pyabc/parameters.py +++ b/pyabc/parameters.py @@ -1,7 +1,4 @@ -from collections import UserDict - - -class ParameterStructure(UserDict): +class ParameterStructure(dict): """ Basic functionality of a structure containing parameters. """ diff --git a/pyabc/petab/__init__.py b/pyabc/petab/__init__.py new file mode 100644 index 000000000..e69d9c472 --- /dev/null +++ b/pyabc/petab/__init__.py @@ -0,0 +1,6 @@ +from .amici import AmiciPetabImporter + + +__all__ = [ + 'AmiciPetabImporter' +] diff --git a/pyabc/petab/amici.py b/pyabc/petab/amici.py new file mode 100644 index 000000000..9a5adf7a4 --- /dev/null +++ b/pyabc/petab/amici.py @@ -0,0 +1,138 @@ +import logging +from collections.abc import Sequence, Mapping +from typing import Callable, Union + +import pyabc +from .base import PetabImporter + +logger = logging.getLogger(__name__) + +try: + import petab +except ImportError: + logger.error("Install petab (see https://github.com/icb-dcm/petab) to use " + "the petab functionality.") + +try: + import amici + from amici.petab_objective import simulate_petab, LLH, RDATAS +except ImportError: + logger.error("Install amici (see https://github.com/icb-dcm/amici) to use " + "the amici functionality.") + + +class AmiciPetabImporter(PetabImporter): + """ + Import a PEtab model using AMICI to simulate it as a deterministic ODE. + + Parameters + ---------- + + petab_problem: + A PEtab problem containing all information on the parameter estimation + problem. + free_parameters: + Whether to estimate free parameters (column ESTIMATE=1 in the + parameters table). + fixed_parameters: + Whether to estimate fixed parameters (column ESTIMATE=0 in the + parameters table). + amici_model: + A corresponding compiled AMICI model that allows simulating data for + parameters. If not provided, one is created using + `amici.petab_import.import_petab_problem`. + amici_solver: + An AMICI solver to simulate the model. If not provided, one is created + using `amici_model.getSolver()`. + store_simulations: + Whether to store performed simulations. Per default, only parameters + and likelihood valuaes are stored. Since an ODE model + is deterministic, the trajectories can easily be reproduced. + """ + + def __init__( + self, + petab_problem: petab.Problem, + amici_model: amici.Model = None, + amici_solver: amici.Solver = None, + free_parameters: bool = True, + fixed_parameters: bool = False, + store_simulations: bool = False): + super().__init__( + petab_problem=petab_problem, + free_parameters=free_parameters, + fixed_parameters=fixed_parameters) + + if amici_model is None: + amici_model = amici.getab_import.import_petab_problem( + petab_problem) + self.amici_model = amici_model + + if amici_solver is None: + amici_solver = self.amici_model.getSolver() + self.amici_solver = amici_solver + + self.store_simulations = store_simulations + + def create_model( + self + ) -> Callable[[Union[Sequence, Mapping]], Mapping]: + """Create model.""" + # parameter ids to consider + x_ids = self.petab_problem.get_x_ids( + free=self.free_parameters, fixed=self.fixed_parameters) + + # extract variables for improved pickling + petab_problem = self.petab_problem + amici_model = self.amici_model + amici_solver = self.amici_solver + store_simulations = self.store_simulations + + # no gradients for pyabc + amici_solver.setSensitivityOrder(0) + + def model(par: Union[Sequence, Mapping]) -> Mapping: + """The model function.""" + # convenience to allow calling model not only with dicts + if not isinstance(par, Mapping): + par = {key: val for key, val in zip(x_ids, par)} + + # simulate model + sim = simulate_petab( + petab_problem=petab_problem, + amici_model=amici_model, + solver=amici_solver, + problem_parameters=par, + scaled_parameters=True) + + # return values of interest + ret = {'llh': sim[LLH]} + if store_simulations: + for i_rdata, rdata in enumerate(ret[RDATAS]): + ret[f'y_{i_rdata}'] = rdata['y'] + + return ret + + return model + + def create_kernel( + self + ) -> pyabc.StochasticKernel: + """ + Create acceptance kernel. + + Returns + ------- + kernel: + A pyabc distribution encoding the kernel function. + """ + def kernel_fun(x, x_0, t, par) -> float: + """The kernel function.""" + # the kernel value is computed by amici already + return x['llh'] + + # create a kernel from function, returning log-scaled values + kernel = pyabc.distance.SimpleFunctionKernel( + kernel_fun, ret_scale=pyabc.distance.SCALE_LOG) + + return kernel diff --git a/pyabc/petab/base.py b/pyabc/petab/base.py new file mode 100644 index 000000000..8929ceec4 --- /dev/null +++ b/pyabc/petab/base.py @@ -0,0 +1,142 @@ +import pyabc + +from collections.abc import Sequence, Mapping +from typing import Callable, Union +import abc +import logging + +logger = logging.getLogger(__name__) + +try: + import petab +except ImportError: + + logger.error("Install petab (see https://github.com/icb-dcm/petab) to use " + "the petab functionality.") + + +class PetabImporter(abc.ABC): + """ + Import a PEtab model to parameterize it using pyABC. + + This class provides methods to generate prior, model, and stochastic kernel + for a pyABC analysis. + + Parameters + ---------- + + petab_problem: + A PEtab problem containing all information on the parameter estimation + problem. + free_parameters: + Whether to estimate free parameters (column ESTIMATE=1 in the + parameters table). + fixed_parameters: + Whether to estimate fixed parameters (column ESTIMATE=0 in the + parameters table). + """ + + def __init__( + self, + petab_problem: petab.Problem, + free_parameters: bool = True, + fixed_parameters: bool = False): + self.petab_problem = petab_problem + self.free_parameters = free_parameters + self.fixed_parameters = fixed_parameters + + def create_prior(self) -> pyabc.Distribution: + """ + Create prior. + + Returns + ------- + prior: + A valid pyabc.Distribution for the parameters to estimate. + """ + # add default values + parameter_df = petab.normalize_parameter_df( + self.petab_problem.parameter_df) + + prior_dct = {} + + # iterate over parameters + for _, row in parameter_df.reset_index().iterrows(): + # check whether we can ignore + if not self.fixed_parameters and row[petab.C.ESTIMATE] == 0: + # ignore fixed parameters + continue + if not self.free_parameters and row[petab.C.ESTIMATE] == 1: + # ignore free parameters + continue + + # pyabc currently only knows objective priors, no + # initialization priors + prior_type = row[petab.C.OBJECTIVE_PRIOR_TYPE] + pars_str = row[petab.C.OBJECTIVE_PRIOR_PARAMETERS] + prior_pars = tuple([float(val) for val in pars_str.split(';')]) + + # create random variable from table entry + if prior_type in [petab.C.PARAMETER_SCALE_UNIFORM, + petab.C.UNIFORM]: + lb, ub = prior_pars + rv = pyabc.RV('uniform', lb, ub-lb) + elif prior_type in [petab.C.PARAMETER_SCALE_NORMAL, + petab.C.NORMAL]: + mean, std = prior_pars + rv = pyabc.RV('norm', mean, std) + elif prior_type in [petab.C.PARAMETER_SCALE_LAPLACE, + petab.C.LAPLACE]: + mean, scale = prior_pars + rv = pyabc.RV('laplace', mean, scale) + elif prior_type == petab.C.LOG_NORMAL: + mean, std = prior_pars + rv = pyabc.RV('lognorm', mean, std) + elif prior_type == petab.C.LOG_LAPLACE: + mean, scale = prior_pars + rv = pyabc.RV('loglaplace', mean, scale) + else: + raise ValueError(f"Cannot handle prior type {prior_type}.") + + prior_dct[row[petab.C.PARAMETER_ID]] = rv + + # create prior distribution + prior = pyabc.Distribution(**prior_dct) + + return prior + + @abc.abstractmethod + def create_model( + self + ) -> Callable[[Union[Sequence, Mapping]], Mapping]: + """ + Create model. The model takes parameters and simulates data + for these. Different model simulation formalisms may be employed. + + .. note:: + This method must be overwritten in derived classes. + + Returns + ------- + model: + Employs some model formalism to generate simulated data for the + analyzed system given parameters. + """ + + @abc.abstractmethod + def create_kernel( + self + ) -> pyabc.StochasticKernel: + """ + Create acceptance kernel. The kernel takes the simulation result + and computes a likelihood value by comparing simulated and observed + data. + + .. note:: + This method must be overwritten in derived classes. + + Returns + ------- + kernel: + A pyabc distribution encoding the kernel function. + """ diff --git a/pyabc/smc.py b/pyabc/smc.py index e381262b4..915f0a0c7 100644 --- a/pyabc/smc.py +++ b/pyabc/smc.py @@ -727,7 +727,7 @@ def transition_pdf(m_ss, theta_ss): transition_pd = model_factor * particle_factor if transition_pd == 0: - logger.info("Transition density is zero!") + logger.debug("Transition density is zero!") return transition_pd return transition_pdf diff --git a/pyabc/version.py b/pyabc/version.py index fbf8d12ff..61fb31cae 100644 --- a/pyabc/version.py +++ b/pyabc/version.py @@ -1 +1 @@ -__version__ = "0.9.26" +__version__ = "0.10.0" diff --git a/setup.py b/setup.py index d25ad1cf1..3ad1b4be4 100644 --- a/setup.py +++ b/setup.py @@ -23,7 +23,8 @@ def read(fname): "feather-format>=0.4.0", "bkcharts>=0.2", "distributed>=1.23.3", "pygments>=2.2.0", "IPython>=7.0.1", "pyarrow>=0.14.1"], - extras_require={"R": ["rpy2>=3.2.0", "cffi>=1.13.1"]}, + extras_require={"R": ["rpy2>=3.2.0", "cffi>=1.13.1"], + "amici-petab": ["petab>=0.1.1", "amici>=0.10.18"]}, python_requires='>=3.6', packages=find_packages(exclude=["examples*", "devideas*", "test*", "test"]), diff --git a/test/test_petab.py b/test/test_petab.py new file mode 100644 index 000000000..61b2a3817 --- /dev/null +++ b/test/test_petab.py @@ -0,0 +1,55 @@ +import amici.petab_import +import petab +import pyabc.petab + +import git +import os +import numpy as np + + +def test_import(): + # download archive + benchmark_dir = "doc/examples/tmp/benchmark-models" + if not os.path.exists(benchmark_dir): + git.Repo.clone_from( + "https://github.com/LeonardSchmiester/Benchmark-Models.git", + benchmark_dir, depth=1) + g = git.Git(benchmark_dir) + + # update repo if online + try: + g.pull() + except git.exc.GitCommandError: + pass + + # create problem + petab_problem = petab.Problem.from_yaml(os.path.join( + benchmark_dir, "hackathon_contributions_new_data_format", + "Boehm_JProteomeRes2014", "Boehm_JProteomeRes2014.yaml")) + + # compile amici + model = amici.petab_import.import_petab_problem(petab_problem) + solver = model.getSolver() + + # import to pyabc + importer = pyabc.petab.AmiciPetabImporter(petab_problem, model, solver) + + # extract required objects + prior = importer.create_prior() + model = importer.create_model() + kernel = importer.create_kernel() + + # call model + assert np.isclose( + model(petab_problem.x_nominal_free_scaled)['llh'], -138.221996) + + # mini analysis + temperature = pyabc.Temperature( + enforce_exact_final_temperature=False, + schemes=[pyabc.AcceptanceRateScheme()]) + acceptor = pyabc.StochasticAcceptor() + + abc = pyabc.ABCSMC(model, prior, kernel, eps=temperature, + acceptor=acceptor, population_size=10) + abc.new(pyabc.storage.create_sqlite_db_id(), None) + abc.run(max_nr_populations=1) diff --git a/test/test_stop_sampling.py b/test/test_stop_sampling.py index 047b4fb65..860961835 100644 --- a/test/test_stop_sampling.py +++ b/test/test_stop_sampling.py @@ -41,6 +41,6 @@ def test_stop_early(db_path): # offset with n_procs as more processes can have run at termination n_procs = sampler.n_procs if hasattr(sampler, 'n_procs') else 1 df["corrected_acceptance_rate"] = \ - (df["particles"] - (n_procs-1)) / df["samples"] + df["particles"] / (df["samples"] - (n_procs-1)) assert df["corrected_acceptance_rate"].iloc[-1] >= set_acc_rate From 688c45f51196427995de6340369528a832cd9f7c Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Wed, 19 Feb 2020 10:05:29 +0100 Subject: [PATCH 06/14] address reviewer comments --- pyabc/acceptor/pdf_norm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyabc/acceptor/pdf_norm.py b/pyabc/acceptor/pdf_norm.py index c959ddffd..2ed73f34f 100644 --- a/pyabc/acceptor/pdf_norm.py +++ b/pyabc/acceptor/pdf_norm.py @@ -40,7 +40,7 @@ def pdf_norm_max_found( class ScaledPDFNorm: """ Finds the previously found maximum density value, but then scales it - by a factor `factor**T` such that the probabiliy of particles getting + by a factor `factor**T` such that the probability of particles getting accepted is increased by y value of up to `factor`. Some additional rules are applied to make the scheme stable. The scaling From bb4b45a0379fe274904f6223710906dc46c7539d Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Wed, 19 Feb 2020 11:15:29 +0100 Subject: [PATCH 07/14] review travis run times --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 5b377b11f..e307d7ee1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -37,9 +37,9 @@ install: # run tests script: -- travis_wait 20 python -m pytest --cov=pyabc test/test_* +- travis_wait 25 python -m pytest --cov=pyabc test/test_* - travis_wait 5 xvfb-run -a python -m pytest --cov=pyabc --cov-append test/visualization/test_* -- if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 15 test/run_notebooks.sh; fi +- if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 20 test/run_notebooks.sh; fi after_success: - codecov From 8b6b02c75fcd9aba2a4562d1c9b78be180e9b653 Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Wed, 19 Feb 2020 13:17:43 +0100 Subject: [PATCH 08/14] explicitly specify petab fixed parameters on scale --- pyabc/petab/amici.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/pyabc/petab/amici.py b/pyabc/petab/amici.py index 9a5adf7a4..38f580ab5 100644 --- a/pyabc/petab/amici.py +++ b/pyabc/petab/amici.py @@ -1,6 +1,7 @@ import logging from collections.abc import Sequence, Mapping from typing import Callable, Union +import copy import pyabc from .base import PetabImporter @@ -82,6 +83,13 @@ def create_model( x_ids = self.petab_problem.get_x_ids( free=self.free_parameters, fixed=self.fixed_parameters) + # fixed paramters + x_fixed_ids = self.petab_problem.get_x_ids( + free=not self.free_parameters, fixed=not self.fixed_parameters) + x_fixed_vals = self.petab_problem.get_x_nominal( + scaled=True, + free=not self.free_parameters, fixed=not self.fixed_parameters) + # extract variables for improved pickling petab_problem = self.petab_problem amici_model = self.amici_model @@ -93,10 +101,17 @@ def create_model( def model(par: Union[Sequence, Mapping]) -> Mapping: """The model function.""" + # copy since we add fixed parameters + par = copy.deepcopy(par) + # convenience to allow calling model not only with dicts if not isinstance(par, Mapping): par = {key: val for key, val in zip(x_ids, par)} + # add fixed parameters + for key, val in zip(x_fixed_ids, x_fixed_vals): + par[key] = val + # simulate model sim = simulate_petab( petab_problem=petab_problem, From a35df04673a37e98b2ac85dbf80540540eded897 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Thu, 20 Feb 2020 11:06:41 +0100 Subject: [PATCH 09/14] Fix travis (#275) * use develop branches of amici, petab * shorten travis times * fix future warnings * test * test * gridsearchcv: explicit arguments * test * test * test --- .travis.yml | 6 ++++-- .travis_pip_reqs.txt | 2 -- pyabc/transition/model_selection.py | 9 ++++++--- pyabc/transition/transitionmeta.py | 2 +- 4 files changed, 11 insertions(+), 8 deletions(-) diff --git a/.travis.yml b/.travis.yml index e307d7ee1..d832c5020 100644 --- a/.travis.yml +++ b/.travis.yml @@ -33,13 +33,15 @@ install: - pip install --upgrade . - pip install --upgrade -r .travis_pip_reqs.txt - pip install --upgrade pytest +- pip install https://github.com/icb-dcm/petab/archive/develop.zip +- pip install -e git+https://github.com/icb-dcm/amici.git@develop#egg=amici\&subdirectory=python/sdist # run tests script: -- travis_wait 25 python -m pytest --cov=pyabc test/test_* +- travis_wait 20 python -m pytest --cov=pyabc test/test_* - travis_wait 5 xvfb-run -a python -m pytest --cov=pyabc --cov-append test/visualization/test_* -- if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 20 test/run_notebooks.sh; fi +- if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 15 test/run_notebooks.sh; fi after_success: - codecov diff --git a/.travis_pip_reqs.txt b/.travis_pip_reqs.txt index 28fa215bb..fcceff49f 100644 --- a/.travis_pip_reqs.txt +++ b/.travis_pip_reqs.txt @@ -30,5 +30,3 @@ flake8 pytest codecov pytest-cov -git+https://github.com/icb-dcm/petab.git@develop -amici diff --git a/pyabc/transition/model_selection.py b/pyabc/transition/model_selection.py index 82a12f1d2..a58f05275 100644 --- a/pyabc/transition/model_selection.py +++ b/pyabc/transition/model_selection.py @@ -35,9 +35,12 @@ def __init__(self, estimator=None, param_grid=None, if param_grid is None: param_grid = {'scaling': np.linspace(0.05, 1.0, 5)} - super().__init__(estimator, param_grid, scoring, n_jobs, - iid, refit, cv, verbose, pre_dispatch, - error_score, return_train_score) + super().__init__( + estimator=estimator, param_grid=param_grid, scoring=scoring, + n_jobs=n_jobs, pre_dispatch=pre_dispatch, iid=iid, + cv=cv, refit=refit, verbose=verbose, + error_score=error_score, + return_train_score=return_train_score) def fit(self, X, y=None, groups=None): if len(X) == 1: diff --git a/pyabc/transition/transitionmeta.py b/pyabc/transition/transitionmeta.py index 9d491d2bb..2379c55ac 100644 --- a/pyabc/transition/transitionmeta.py +++ b/pyabc/transition/transitionmeta.py @@ -33,7 +33,7 @@ def wrap_rvs_single(f): @functools.wraps(f) def rvs_single(self): if self.no_parameters: - return pd.Series() + return pd.Series(dtype=float) return f(self) return rvs_single From 7569dc795840edc4af460e722f4832fa91ca1eea Mon Sep 17 00:00:00 2001 From: Emad Alamoudi Date: Thu, 20 Feb 2020 11:25:27 +0100 Subject: [PATCH 10/14] find last id of successful run in the database (#273) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * find last id of successful run in the database * address reviewer comments * address additional reviewer comments * flake8 fix Co-authored-by: Yannik Schälte <31767307+yannikschaelte@users.noreply.github.com> --- pyabc/storage/history.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pyabc/storage/history.py b/pyabc/storage/history.py index 288712181..b633179d9 100644 --- a/pyabc/storage/history.py +++ b/pyabc/storage/history.py @@ -203,13 +203,15 @@ def all_runs(self): def _find_latest_id(self): """ If there are analysis objects saved in the database already, - the id of the latest appended one is returned. + the id of the last successful run is returned. This is because that is usually the run the user will be interested in. """ abcs = self._session.query(ABCSMC).all() if len(abcs) > 0: - return abcs[-1].id + for abc in reversed(abcs): + if len(abc.populations): + return abc.id return None @property From 40caba84597f0ec00894ce532ca547d225cf8636 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yannik=20Sch=C3=A4lte?= <31767307+yannikschaelte@users.noreply.github.com> Date: Thu, 20 Feb 2020 13:15:42 +0100 Subject: [PATCH 11/14] Feature listpopulationsize (#274) (#276) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Feature listpopulationsize (#274) * Init ListPopulation ListPopulation provides user definded population sizes which are comitted using a list. It's implementation follows the ListEpsilon case. List must have as many entries as populations are to be run. * Add t argument to adapt_population_size We will need to configure smc class such that it passes t as an argument to the _adapt_population_size. Therefor all adapt_population_size function have to be given t as well. * Adapt smc.run to ListPopulation In order to use ListPopulation we need to break before the _prepare_next_iteration in the end. Also pass t to _adapt_population_size * Update populationstrategy.py * Pass argumentname for better readability * Rename class Class name should contain Size as well * Added test for ListPopulationSize Simple test for ListPopulationSize according to the test_ListEpsilon function. * Add get_config function in ListPopulationSize Added get_config class according to ListEpsilon.get_config() function * Reformat code Added t==t_max other code termination block. Did not add logger info because while loop would not have produced a logger info itself. * Modify documentation Changed Population values to PopulationSize values * Add empty line for doc parsing * Remove empty line * Remove assertions Assertions didnt work. Co-authored-by: Yannik Schälte <31767307+yannikschaelte@users.noreply.github.com> * fixup * add docstring * fix style; back-relocate prepare_next_iteration * update releasenotes Co-authored-by: nbungi --- doc/releasenotes.rst | 4 +++- pyabc/populationstrategy.py | 35 ++++++++++++++++++++++++++++++--- pyabc/smc.py | 3 ++- test/test_populationstrategy.py | 12 ++++++++++- 4 files changed, 48 insertions(+), 6 deletions(-) diff --git a/doc/releasenotes.rst b/doc/releasenotes.rst index 64b2f6b18..774b71f7e 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -8,7 +8,7 @@ Release Notes ........... -0.10.0 (2020-02-18) +0.10.0 (2020-02-20) ------------------- * Exact inference via stochastic acceptor finalized and tested (developed @@ -17,6 +17,8 @@ Release Notes * Various error fixes (#265, #267). * Log number of processes used by multiprocessing samplers (#263). * Implement pyabc.acceptor.ScaledPDFNorm (#269). +* Implement list population size (#274, #276). +* On history loading, automatically find an id of a successful run (#273). 0.9 series diff --git a/pyabc/populationstrategy.py b/pyabc/populationstrategy.py index a0b46eb7a..a8152e497 100644 --- a/pyabc/populationstrategy.py +++ b/pyabc/populationstrategy.py @@ -51,7 +51,7 @@ def __init__(self, nr_particles: int, *, self.nr_samples_per_parameter = nr_samples_per_parameter def adapt_population_size(self, transitions: List[Transition], - model_weights: np.ndarray): + model_weights: np.ndarray, t: int = None): """ Select the population size for the next population. @@ -59,6 +59,7 @@ def adapt_population_size(self, transitions: List[Transition], ---------- transitions: List of Transitions model_weights: array of model weights + t: Time to adapt for Returns ------- @@ -108,7 +109,8 @@ class ConstantPopulationSize(PopulationStrategy): Number of samples to draw for a proposed parameter """ - def adapt_population_size(self, transitions, model_weights): + def adapt_population_size(self, transitions: List[Transition], + model_weights: np.ndarray, t: int = None): pass @@ -177,7 +179,7 @@ def get_config(self): "mean_cv": self.mean_cv} def adapt_population_size(self, transitions: List[Transition], - model_weights: np.ndarray): + model_weights: np.ndarray, t: int = None): test_X = [trans.X for trans in transitions] test_w = [trans.w for trans in transitions] @@ -196,3 +198,30 @@ def adapt_population_size(self, transitions: List[Transition], logger.info("Change nr particles {} -> {}" .format(reference_nr_part, self.nr_particles)) + + +class ListPopulationSize(PopulationStrategy): + """ + Return population size values from a predefined list. For every time point + enquired later (specified by time t), an entry must exist in the list. + + Parameters + ---------- + values: List[float] + List of population size values. + ``values[t]`` is the value for population t. + """ + + def __init__(self, + values: List[float]): + super().__init__(nr_particles=list(values)[0]) + self.population_values = list(values) + + def get_config(self): + config = super().get_config() + config["population_values"] = self.population_values + return config + + def adapt_population_size(self, transitions: List[Transition], + model_weights: np.ndarray, t: int = None): + self.nr_particles = self.population_values[t] diff --git a/pyabc/smc.py b/pyabc/smc.py index 915f0a0c7..754db9cb7 100644 --- a/pyabc/smc.py +++ b/pyabc/smc.py @@ -1040,7 +1040,8 @@ def _adapt_population_size(self, t): # WARNING: the deepcopy also copies the random states of scipy.stats # distributions copied_transitions = copy.deepcopy(self.transitions) - self.population_strategy.adapt_population_size(copied_transitions, w) + self.population_strategy.adapt_population_size( + copied_transitions, w, t) def _fit_transitions(self, t): """ diff --git a/test/test_populationstrategy.py b/test/test_populationstrategy.py index 36ef8253d..5d8cf8dd7 100644 --- a/test/test_populationstrategy.py +++ b/test/test_populationstrategy.py @@ -1,5 +1,6 @@ import pytest -from pyabc.populationstrategy import (AdaptivePopulationSize, +from pyabc.populationstrategy import (ListPopulationSize, + AdaptivePopulationSize, ConstantPopulationSize, PopulationStrategy) from pyabc.transition import MultivariateNormalTransition @@ -108,3 +109,12 @@ def test_transitions_not_modified(population_strategy: PopulationStrategy): " modified the transitions".format(population_strategy)) assert same, err_msg + + +def test_list_population_size(): + """Test list population size.""" + pop_size = ListPopulationSize(values=[100, 1000, 1000]) + pop_size.adapt_population_size(None, None, 0) + assert pop_size.nr_particles == 100 + pop_size.adapt_population_size(None, None, 2) + assert pop_size.nr_particles == 1000 From 3011839c65d760a2f3e46157df1affb381962318 Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Thu, 20 Feb 2020 13:32:59 +0100 Subject: [PATCH 12/14] fix tests: use larger population size --- test/test_acceptor.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_acceptor.py b/test/test_acceptor.py index ee8522551..3fa09f90c 100644 --- a/test/test_acceptor.py +++ b/test/test_acceptor.py @@ -123,9 +123,9 @@ def model(par): prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, - population_size=5) + population_size=20) abc.new(pyabc.create_sqlite_db_id(), x_0) - abc.run(max_nr_populations=2) + abc.run(max_nr_populations=1) def test_pdf_norm_methods(): From 84530bdb675a7e4e2af08ac3e3684a0218fa0906 Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Thu, 20 Feb 2020 13:51:07 +0100 Subject: [PATCH 13/14] fixup --- test/test_acceptor.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/test_acceptor.py b/test/test_acceptor.py index 3fa09f90c..01801b845 100644 --- a/test/test_acceptor.py +++ b/test/test_acceptor.py @@ -100,9 +100,9 @@ def model(par): acceptor = pyabc.StochasticAcceptor() eps = pyabc.Temperature() abc = pyabc.ABCSMC(model, prior, distance, eps=eps, - acceptor=acceptor, population_size=10) + acceptor=acceptor, population_size=20) abc.new(pyabc.create_sqlite_db_id(), x_0) - abc.run(max_nr_populations=3, minimum_epsilon=1.) + abc.run(max_nr_populations=3) def test_pdf_norm_methods_integration(): @@ -118,14 +118,14 @@ def model(par): ]: # just run acceptor = pyabc.StochasticAcceptor(pdf_norm_method=pdf_norm) - eps = pyabc.Temperature(enforce_exact_final_temperature=False) + eps = pyabc.Temperature() distance = pyabc.IndependentNormalKernel(var=np.array([1, 1])) prior = pyabc.Distribution(p0=pyabc.RV('uniform', -1, 2)) abc = pyabc.ABCSMC(model, prior, distance, eps=eps, acceptor=acceptor, population_size=20) abc.new(pyabc.create_sqlite_db_id(), x_0) - abc.run(max_nr_populations=1) + abc.run(max_nr_populations=3) def test_pdf_norm_methods(): From 05a44c75c7a78300071160e738de18fe64a6014b Mon Sep 17 00:00:00 2001 From: yannikschaelte Date: Thu, 20 Feb 2020 14:19:53 +0100 Subject: [PATCH 14/14] speed up travis --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index d832c5020..9417dcb3d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -39,8 +39,8 @@ install: # run tests script: -- travis_wait 20 python -m pytest --cov=pyabc test/test_* -- travis_wait 5 xvfb-run -a python -m pytest --cov=pyabc --cov-append test/visualization/test_* +- travis_wait 10 python -m pytest --cov=pyabc test/test_* +- travis_wait 3 xvfb-run -a python -m pytest --cov=pyabc --cov-append test/visualization/test_* - if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then travis_wait 15 test/run_notebooks.sh; fi after_success: