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..9417dcb3d 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,23 +18,29 @@ 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 +- 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 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: 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": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEHCAYAAACjh0HiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3de3icdZn/8fedyTTTlENLWwV7oBZYVrdqXQMIutALihaEsgIuxV9ZAbEsh5XuAv6ARU66CIJa2IJQ5Qw/ARGlKCAtUMVFoAULlEO1DWqpcJFyKDRJM5nJ/fvjeSaZTGaSSZsnz5Pm87quXJ15vt+Z3gxN7nwPz/c2d0dERIavmrgDEBGReCkRiIgMc0oEIiLDnBKBiMgwp0QgIjLM1cYdQH+NGzfOp0yZEncYIiJDyjPPPLPB3ceXaxtyiWDKlCmsWLEi7jCkCuvWrQNg0qRJMUciImb2l0ptQy4RyNBx3HHHAbBs2bJ4AxGRXikRSGTOP//8uEMQkSooEUhkZs6cGXcIIlIF7RqSyDQ2NtLY2Bh3GCLSB40IJDInnngioDUCkaRTIpDIXHzxxXGHICJViDwRmFkKWAGsd/fDStrqgFuBTwFvAce4+5+jjkkGxwEHHBB3CCJShcFYIzgDeLlC21eBd9x9d+AHwOWDEI8MktWrV/PKK6/w2Ctv0tGh485FkirSRGBmE4EvAD+u0OUI4Jbw8T3AQWZmUcYkg+fkk09m7gknccLNy3ny1bfiDkdEKoh6amgB8A1g+wrtE4B1AO6eM7ONwFhgQ3EnM5sHzAOYPHlyZMHKwLr00kt59i/vcOVz8P7mXNzhiEgFkY0IzOww4E13f2Zr38vdF7l7g7s3jB9f9qgMSaD99tuPqdP+EYDN7fmYoxGRSqKcGvoMMNvM/gzcCRxoZreX9FkPTAIws1pgR4JFY9kGrFq1ildeehGAtvaOmKMRkUoiSwTufq67T3T3KcAc4FF3n1vSbTHwlfDx0WEfrSpuI04//XR+dHlwzMTmnEYEIkk16PcRmNklwAp3XwzcANxmZmuAtwkShmwjrrjiCn727Gvc+aqmhkSSbFASgbsvA5aFjy8our4Z+NJgxCCDb6+99uLxd3eEV//EZk0NiSSW7iyWyKxcuZK1L68FMhoRiCSYEoFEZv78+by6oRk77CLachoRiCSVTh+VyCxYsIDPzj0T0BqBSJIpEUhkpk+fzqgP7Q6gNQKRBFMikMgsX76cdatfALR9VCTJlAgkMmeffTYrfno1AG2aGhJJLCUCiczChQv5uy+eAWhqSCTJlAgkMtOmTSM1dldAi8UiSaZEIJF54okneHPN8wDaPiqSYEoEEpnzzjuPdQ/fAGhEIJJkSgQSmeuuu44xnzsN0K4hkSRTIpDI7Dp1D2p3mghosVgkyZQIJDIPP/oom//6Aqka09SQSILprCGJzGXf/hbv/vUdJn60gfda2+MOR0Qq0IhAInPJ9/6HsYfOZ6dRabL5DvIdqjkkkkRR1izOmNnTZvacmb1oZheX6XO8mTWZ2crw66So4pHBN3aXyaRH78yY+hEAZLWFVCSRohwRtAEHuvsngOnALDP7dJl+d7n79PDrxxHGI4Pst489SuufVzJ2uyARaJ1AJJmirFns7r4pfJoOvzQ3MIzctPB7bHzizs4RgbaQiiRTpGsEZpYys5XAm8ASd3+qTLejzOx5M7vHzCZFGY8Mrn//1lWMO+xMxo4qjAg0NSSSRJEmAnfPu/t0YCKwt5lNK+lyPzDF3T8OLAFuKfc+ZjbPzFaY2YqmpqYoQ5YBVD/mg9TuMJ4xozQ1JJJkg7JryN3fBR4DZpVcf8vd28KnPwY+VeH1i9y9wd0bxo8fH22wMmCefvwRWhufYSclApFEi3LX0HgzGx0+HgkcDLxS0meXoqezgZejikcG369uu46NT/60a41AU0MiiRTlDWW7ALeYWYog4dzt7r80s0uAFe6+GPi6mc0GcsDbwPERxiOD7F++cSU/efqvjKoL/pm1abFYJJEiSwTu/jzwyTLXLyh6fC5wblQxSLxqtxvD9ju1kkkHA0+NCESSSXcWS2Sef+JR2tY+TSadAjQiEEkqnTUkkXl68a20ZHNk0mcCWiwWSSolAonMP51yKe80Z8nUampIJMmUCCQyHXXbM7qOzqkhjQhEkkmJQCLTuPxRdsjUUle7D6ARgUhSKRFIZNY+9lPq62qpTf1famtMi8UiCaVEIJHZfe7F7Dt1LBBMD2lEIJJM2j4qkWmzDGNGjwYgk67R6aMiCaVEIJF587nH+NOTDwNQV5vSYrFIQikRSCSyuQ7efeZXLH/gLiAYEbRpakgkkbRGIJFozeb5wJcu4j8O+QhQWCPQiEAkiTQikEi0tOeoSWcYs8N2ANTVao1AJKmUCCQSzW15Nr34GE8v+QUQjAg0NSSSTEoEEonWbJ5Nz/2aR++7EwinhjQiEEkkrRFIJJqzOT54zLe5+sS9gXD7qEYEIomkEYFEojWbx1K17DAqA0BG20dFEivKUpUZM3vazJ4zsxfN7OIyferM7C4zW2NmT5nZlKjikcHVks2z6YWlPPTzYPtone4sFkmsKEcEbcCB7v4JYDowy8w+XdLnq8A77r478APg8gjjkUHUnM2x6YWlLP7p/wMK9xFoRCCSRJElAg9sCp+mwy8v6XYEcEv4+B7gIDOzqGKSwdOazbPzly/jlw8tAcI7i7VYLJJIka4RmFnKzFYCbwJL3P2pki4TgHUA7p4DNgJjy7zPPDNbYWYrmpqaogxZBkhzNgdA/YhgP0ImXUN73sl3lP4uICJxizQRuHve3acDE4G9zWzaFr7PIndvcPeG8ePHD2yQEolg++hD3HbzDQCqWyySYIOya8jd3wUeA2aVNK0HJgGYWS2wI/DWYMQk0WrJ5tm8+nfcfffdACpXKZJgUe4aGm9mo8PHI4GDgVdKui0GvhI+Php41N01d7ANaMnm+MhXr2Dp0qWAylWKJFmUN5TtAtxiZimChHO3u//SzC4BVrj7YuAG4DYzWwO8DcyJMB4ZRC3ZPPUjUp3PlQhEkiuyRODuzwOfLHP9gqLHm4EvRRWDxKe5LU/TU4u59tqXOfXUU8mkNTUkklS6s1gi0dqe4+2Xn+T+++8Hgu2jgLaQiiSQEoFEoiWb5+D/XMCDDz4IQF04ItAJpCLJo0QgkWhpq7BGoBGBSOIoEUgkWtpzrF56N1dddRUQHDoH6JgJkQRSIpBItLTlWf/S0zzyyCMAWiwWSTAlAolESzbP8Rddy+LFiwFtHxVJMiUCGXAdHU5re56RI7p2JysRiCSXEoEMuNbwh/3/3nsTV155JRAUrwfYnNPUkEjSqFSlDLiWbJAI/vrKSnizHig6dE5rBCKJo0QgA64lPIL6nCt/xFGfmghAqsZIp0zbR0USSFNDMuAKI4Li+whAdYtFkkqJQAZcYUTw85uv4bLLLuu8rrrFIsmkqSEZcIURwZ//+BLvrR/ReV11i0WSSYlABlwhEXz/upuYNmHHzut1tTVaIxBJIE0NyYArTA2Nquv+e0YmndKuIZEEUiKQAVcYEVy34Lt861vf6ryeSac0IhBJoChLVU4ys8fM7CUze9HMzijTZ4aZbTSzleHXBeXeS4aWlrZwjWDtn1i9enXn9Uy6RovFIgkU5RpBDjjT3Z81s+2BZ8xsibu/VNLvcXc/LMI4ZJAVRgR33H47tamu3zUytSnebWmPKywRqSCyEYG7v+7uz4aP3wdeBiZE9fdJcrS05xhRW9MtCUA4NaRdQyKJMyhrBGY2haB+8VNlmvc1s+fM7EEz+4cKr59nZivMbEVTU1OEkcpAaGnLM2pEigsuuIALLuia7avT1JBIIkW+fdTMtgN+Bsx39/dKmp8FdnX3TWZ2KPALYI/S93D3RcAigIaGBo84ZNlKLdk89SNqWffqum7X62pTtGmxWCRxIk0EZpYmSAJ3uPu9pe3FicHdHzCza81snLtviDIuiVZLNkf9iBQ33XRTt+vBDWUaEYgkTZS7hgy4AXjZ3b9foc/OYT/MbO8wnreiikkGRzAiSPW4ru2jIsnU54jAzGqAo9397n6+92eA44AXzGxleO08YDKAu18HHA2cYmY5oBWY4+6a+hniWrN5Ro5Ice655wLwne98Bwh2DbXnnXyHk6qxOEMUkSJ9JgJ37zCzbwD9SgTu/jug1+92d18ILOzP+0ryNWdz7LxDhrfe6j6466pbnO9x17GIxKfa78alZnYWcBfQXLjo7m9HEpUMaYURwcJFi7pdLy5XqUQgkhzVfjceE/55WtE1B6YObDiyLWjO5hg1ouc/rc4RgcpViiRKVYnA3T8cdSCy7WgJRwRnnXUWQFHdYhWwF0miqhJBuA30FGD/8NIy4Hp313kB0o27d+4aampt7dZWGBFoC6lIslQ7NfRDIA1cGz4/Lrx2UhRBydCVzXeQ73BG1dVyzTXXdGurK6wRaAupSKJUmwj2cvdPFD1/1MyeiyIgGdpawwPnRqbL3EegqSGRRKr2hrK8me1WeGJmUwF9N0sPzWEiGFWXYv78+cyfP7+zTVNDIslU7YjgbOAxM2skuDdgV+CEyKKSIas1rE42suyuIY0IRJKo2l1Dj5jZHsCe4aXV7t4WXVgyVDWHRWlGjUixYMGCbm0ZrRGIJFKvicDMDnT3R83syJKm3c2McgfJyfBWKEozssxZQ3W1hTuLNTUkkiR9jQgOAB4FDi/T5oASgXTT2h5MDdWPqOW004L7Dwu7hwojgjZNDYkkSq+JwN0vDA+de3ALDp2TYah4amjkyJHd2nRnsUgyRXbonAxPrUVTQ4U7igu0fVQkmardPrrUzM4ys0lmtlPhK9LIZEhqDncNlTtrqKbGGJFSuUqRpNGhczKgiheL582bB8CiolNIg7rFGhGIJElkh86Z2STgVuCDBEljkbtfVdLHgKuAQ4EW4Hh3f7a/f5ckR2s2T40FO4TGjh3bo111i0WSp9pD5+qB/wQmu/u8wj0F7v7LXl6WA85092fNbHvgGTNb4u4vFfU5hKBY/R7APgTnF+2zJf8hkgyFI6jNrLMyWbFMWlNDIklT7RrBTUAW2C98vh74dm8vcPfXC7/du/v7wMvAhJJuRwC3euBJYLSZ7VJt8JI8haI0lWTSGhGIJE21iWA3d/8u0A7g7i30UYaymJlNAT4JPFXSNAFYV/T8NXomC8xsnpmtMLMVTU1N1f61EoPmbFf1sRNOOIETTuh+EolGBCLJU+1icdbMRhLM9RMeQFfVERNmth3wM2C+u7+3JUG6+yJgEUBDQ4OK2ydYazbXefLopEmTerRnalNaLBZJmGoTwUXAQ8AkM7sD+AxVHDoXFrT5GXBHheMo1gPFPy0mhtdkiGpuC4rSAFxyySU92jPpFC3hFlMRSYZqdw09bGbPAJ8mmBI6w9039PaacEfQDcDL7v79Ct0WA6eb2Z0Ei8Qb3f31qqOXxGlpz7PjyHTF9ky6hrebNTUkkiTV7hp6xN0PAn5V5lolnyGoZPaCma0Mr50HTAZw9+uABwi2jq4h2D6qo62HuNZsjl12yAAwd+5cAG6//fbO9rralE4fFUmYvk4fzQD1wDgzG0PXAvEOlFnULebuv6OPBWV3d7rfpCZDXHNbnvq6YGpozz337NFel65RYRqRhOlrRHAyMB/4EPAMXT/Y3wMWRhiXDFGt7V1rBN/85jd7tGv7qEjy9HX66FXAVWb27+7+P4MUkwxhzW25sucMFQS7hjQiEEmSau8jeCO8OxgzO9/M7jWzf4wwLhmC8h1OW66j84ayOXPmMGfOnG59MjprSCRxqk0E33T3983ss8BMgt1AP4wuLBmKWsMf8IWpoenTpzN9+vRufTLpFLkOJ5fXqEAkKaq9j6DwK9wXCA6P+5WZ9XrEhAw/LW1d1ckAzjnnnB59iovTbJeq9vcQEYlStd+J683seoLjqB8ws7p+vFaGicIR1PW9nDVUp+I0IolT7Q/zfwF+DXze3d8FdgLOjiwqGZIKRWkKI4KjjjqKo446qlufzhGBEoFIYlR7Z3GLma0FPm9mnwced/eHow1NhprWkhHBvvvu26NPZwF71S0WSYxq7yw+A/gaUDgv6HYzW6QtpVKsdGrorLPO6tFHU0MiyVPtYvFXgX3cvRnAzC4Hfg8oEUinlpKpoXK6poY0IhBJimrXCIyunUOEj6uuRyDDQ+mIYPbs2cyePbtbn86pIY0IRBKj2hHBTcBTZvbz8Pk/E9xLINKpuZAIwrOGDjqo55mEhUSgg+dEkqPaxeLvm9ky4LPhpRPc/Q+RRSVDUmvJ1NAZZ5zRo09draaGRJKmmtNH/w3YHXgBuNbdVVVEyipMDRUqlJXTOSLQ1JBIYvS1RnAL0ECQBA4Brow8IhmyWrJ5MukaUjXB8tEhhxzCIYcc0q1PYbFY20dFkqOvqaGPuvvHAMzsBuDp6EOSoaolm+u2Y+jwww/v0Sej7aMiidNXImgvPHD3XFB9sjpmdiNwGPCmu08r0z4DuA94Nbx0r7v3LHIrQ0ZLUb1igFNPPbVHn66pIY0IRJKir0TwCTN7L3xswMjwuREUGNuhl9feTFC85tZe+jzu7odVG6wkW0s23+s5Q1C8WKwRgUhS9FWYpvfv6t5f+1szm7Klr5ehp7lkamjmzJkALF26tPNaTY0xorZG20dFEqTa+wiisq+ZPQf8DTjL3V8s18nM5gHzACZPnjyI4Ul/tJaMCI455piy/epqVbdYJEniTATPAru6+yYzOxT4BbBHuY7uvghYBNDQ0OCDF6L0R0s2z+j6dOfzr33ta2X7ZdIpTQ2JJEhsNQXc/T133xQ+fgBIm9m4uOKRrVe6a6iSTLpG20dFEiS2RGBmO1u4DcnM9g5jeSuueGTrlS4Wz5gxgxkzZvToFxSw14hAJCkimxoys58AM4BxZvYacCGQBnD364CjgVPMLAe0AnPcXdM+Q1iQCLr+SR1//PFl+2lqSCRZIksE7n5sH+0LCbaXyjbA3cOpoa4RQeVEUKP7CEQSRHWHZUC05Tro8K6TRwHa29tpb2/v0beuNqXtoyIJokQgA6KzFkHRgXMHH3wwBx98cI++GhGIJEvc9xHINqJcdbKTTjqpbN+6dEqFaUQSRIlABkRLSVEagLlz55btm6lNafuoSIJoakgGRGmZSoCWlhZaWlp69A2mhjQiEEkKjQhkQJSbGjr00EMBWLZsWbe+2j4qkixKBDIgWtp6jghOOeWUsn0z6Ro2a2pIJDGUCGRAtLT3TASVD51Lke9w2vMdpFOanRSJm74LZUC0tPWcGtq4cSMbN27s0bdQrlLTQyLJoBGBDIhyi8VHHHEEUH6NAIIqZdtnBic+EalMiUAGRLnF4q9//etl+xbqFrfp7mKRRFAikAHRks1TG1YfKzjyyCPL9q3rnBrSgrFIEmiNQAZEuXrFGzZsYMOGDT36dk0NaUQgkgQaEciAKFeU5uijjwYqrxFoakgkGZQIZECUGxGceeaZZfvW1WpqSCRJoixMcyNwGPCmu08r027AVcChQAtwvLs/G1U8Eq2WbL7bOUMAhx9+eNm+mhoSSZYo1whuBmb10n4IQbH6PYB5wA8jjEUi1pLNUZ/u/nvFG2+8wRtvvNGjb0aLxSKJEmWFst+a2ZReuhwB3BqWp3zSzEab2S7u/npUMUl0WrN5xowa0e3anDlzgDJrBNo+KpIoca4RTADWFT1/LbymRDAENWfzTBjTfWronHPOKdu3+IYyEYnfkFgsNrN5BNNHTJ48OeZopJzWbJ6RJVNDs2aVnxnUERMiyRLnfQTrgUlFzyeG13pw90Xu3uDuDePHjx+U4KR/mrM5RpUsFq9bt45169b16Ns5ItDUkEgixJkIFgP/aoFPAxu1PjB0tWTzjCzZPnrcccdx3HHH9eg7IqXFYpEkiXL76E+AGcA4M3sNuBBIA7j7dcADBFtH1xBsHz0hqlgkWrl8B9lcB6NKbig7//zzy/avCY+iUN1ikWSIctfQsX20O3BaVH+/DJ7mMkVpAGbOnFnxNZlalasUSQqdNSRb7S9vNwMwcUx9t+uNjY00NjaWfU0mrQL2IkkxJHYNSbI1NgWJYLfxo7pdP/HEE4Ge9xGA6haLJIkSgWy1tU2bSNUYk8d2HxFcfPHFFV+TSddosVgkIZQIZKs1NjUzacxI6mq7rxEccMABFV+TSae0fVQkIbRGIFttbdMmdhu/XY/rq1evZvXq1WVfU6fFYpHE0IhAtkq+w3l1QzP/tMe4Hm0nn3wyUHmN4P3NuajDE5EqKBHIVvnbu6205TrKjgguvfTSiq+rq03R1N4WZWgiUiUlAtkqa5s2ATC1TCLYb7/9Kr4uk64hq+2jIomgNQLZKoWto1NLto4CrFq1ilWrVpV9nbaPiiSHRgSyVdY2bWLHkWnGltQiADj99NOBSmsENWzWiEAkEZQIZKs0NjUzdfwogsqj3V1xxRUVX1dXqxGBSFIoEchWWdu0if3/rvzR4HvttVfF1wU3lOVx97JJREQGj9YIZIu9v7mdN99vK7s+ALBy5UpWrlxZti1Tm6LDoT3vUYYoIlXQiEC2WNcZQz13DAHMnz8fqHwfAQTFaUbU6vcRkTgpEcgWa9wQbB0tPWyuYMGCBRVfWyhX2dbeAZmBj01EqqdEIFussak5OGxup/KJYPr06RVfW9dZwF4LxiJxi3RMbmazzGy1ma0xs3PKtB9vZk1mtjL8OinKeGRgrW3axOSd6itO7Sxfvpzly5eXbStMDbXp4DmR2EVZqjIFXAMcDLwGLDezxe7+UknXu9z99KjikOg0NjUzdVz50QDA2WefDZRfI6irVd1ikaSIcmpob2CNuzcCmNmdwBFAaSKQISjf4TRuaK64dRRg4cKFFdsymhoSSYwoE8EEYF3R89eAfcr0O8rM9gf+CPyHu68r7WBm84B5AJMnT44gVOmvv73bSjbX0euIYNq0aRXbMhoRiCRG3Pv27gemuPvHgSXALeU6ufsid29w94bx4yv/BiqDZ0142NxuHyi/dRTgiSee4IknnijbpjUCkeSIckSwHphU9HxieK2Tu79V9PTHwHcjjEcGUOdhc72MCM477zygj/sINCIQiV2UiWA5sIeZfZggAcwBvlzcwcx2cffXw6ezgZcjjEcGUGPTJkbXp9mpzGFzBddff33FtsJ9BFojEIlfZInA3XNmdjrwayAF3OjuL5rZJcAKd18MfN3MZgM54G3g+KjikYG1tmkTU8eVP2yuYM8996zYVnxnsYjEK9Ibytz9AeCBkmsXFD0+Fzg3yhgkGo1Nve8YAvjNb34DlC9ir+2jIsmhO4ul3wqHzVU6Y6jgwgsvBPpaI9CIQCRuSgTSb71VJSt24403VmwrjAjalAhEYqdEIP1WqFPc14hg6tSpFdvMjLraGtpUpUwkdnHfRyBDUNdhc/W99lu6dClLly6t2K66xSLJoBGB9Fvjhk3s2sthcwXf/va3AZg5c2bZ9qBKmUYEInFTIpB+W/tmc5/rAwC33XZbr+2ZdErbR0USQIlA+iXf4bz6VjMH7Nn3UR+TJk3qtb2utkZTQyIJoDUC6Zf17wSHzVWqSlbsoYce4qGHHqrYHqwRaGpIJG4aEUi/rA3LU07tY8cQwGWXXQbArFmzyrZnarVYLJIESgTSL30VrC9255139tpel67h/c25AYlLRLacEoH0y9oqDpsr2HnnnXttz6RTNL3fNlChicgW0hqB9Etj06aqRgMA999/P/fff3/F9kw6pRvKRBJAIwLpl7VNzczo47C5gu9973sAHH744WXbtWtIJBmUCKRq721up+n9tqoWigHuueeeXtuDG8qUCETipkQgVetaKO576yjAuHHjem0Pdg1pakgkblojkKo1NlW/dRTg3nvv5d57763YXriz2N0HJD4R2TKRJgIzm2Vmq81sjZmdU6a9zszuCtufMrMpUcYjW6exqZnaGmPXsb0fNldw9dVXc/XVV1dsz6RrcIf2vBKBSJwimxoysxRwDXAw8Bqw3MwWu/tLRd2+Crzj7rub2RzgcuCYqGKSrbO2aROTd6onnaru94f77ruv1/bicpV9HWAnItGJco1gb2CNuzcCmNmdwBFAcSI4ArgofHwPsNDMzHuZK3h1QzNf/tGT0UQsAFT69Fet38g+U8dW/T477rhjr+2FRHDoVY9TV1tDOhV81aaMdE0NqRqjl5LIIjJAokwEE4B1Rc9fA/ap1Ccsdr8RGAtsKO5kZvOAeQCjdtmN9rwWGKNm9PwJ/JEP7cCXGiZW/R533XUXAMccU36Qd+Dff4Bj955MazZHe4fTnusg1+G05ztoz3eQ69D/Z5HBMCR2Dbn7ImARQENDg//03/aLOSKpxg9/+EOgciL40OiRfOfIjw1mSCLDlp1SuS3KRLAeKD6HeGJ4rVyf18ysFtgReCvCmGQQPfDAA3GHICJViHKFbjmwh5l92MxGAHOAxSV9FgNfCR8fDTza2/qADC319fXU11e3w0hE4hPZiCCc8z8d+DWQAm509xfN7BJghbsvBm4AbjOzNcDbBMlCthG33347AHPnzo05EhHpjQ21X8AbGhp8xYoVcYchVZgxYwYAy5YtizUOEQEze8bdG8q1DYnFYhmalixZEncIIlIFJQKJTDqdjjsEEamCbueUyNx8883cfPPNcYchIn1QIpDIKBGIDA1DbrHYzJqAv8QdBzCOkjughzF9Fl30WXTRZ9ElCZ/Fru5etqrUkEsESWFmKyqtwA83+iy66LPoos+iS9I/C00NiYgMc0oEIiLDnBLBllsUdwAJos+iiz6LLvosuiT6s9AagYjIMKcRgYjIMKdEICIyzCkRbCUzO9PM3MzGxR1LXMzsCjN7xcyeN7Ofm9nouGMabGY2y8xWm9kaMzsn7njiYmaTzOwxM3vJzF40szPijiluZpYysz+Y2S/jjqUSJYKtYGaTgM8Bf407lpgtAaa5+8eBPwLnxhzPoDKzFHANcAjwUeBYM/tovFHFJgec6e4fBT4NnDaMP4uCM4CX4w6iN0oEW+cHwDeAYb3i7u4Pu3sufPokQTW64WRvYI27N7p7FrgTOCLmmGLh7q+7+yi6H/EAAAQDSURBVLPh4/cJfgBOiDeq+JjZROALwI/jjqU3SgRbyMyOANa7+3Nxx5IwJwIPxh3EIJsArCt6/hrD+IdfgZlNAT4JPBVvJLFaQPDLYkfcgfRGx1D3wsyWAjuXafov4DyCaaFhobfPwt3vC/v8F8HUwB2DGZskj5ltB/wMmO/u78UdTxzM7DDgTXd/xsxmxB1Pb5QIeuHuM8tdN7OPAR8GnjMzCKZCnjWzvd39jUEMcdBU+iwKzOx44DDgoGFYd3o9MKno+cTw2rBkZmmCJHCHu98bdzwx+gww28wOBTLADmZ2u7snrnarbigbAGb2Z6DB3eM+XTAWZjYL+D5wgLs3xR3PYDOzWoJF8oMIEsBy4Mvu/mKsgcXAgt+MbgHedvf5cceTFOGI4Cx3PyzuWMrRGoEMhIXA9sASM1tpZtfFHdBgChfKTwd+TbA4evdwTAKhzwDHAQeG/xZWhr8RS4JpRCAiMsxpRCAiMswpEYiIDHNKBCIiw5wSgYjIMKdEICIyzCkRiIgMc0oEss0wsylmtqqKfg1mdnWEcdxsZkf3o/9oMzs1qnhE+qJEIMOOu69w96/HHUeR0UC/EoEF9P0rA0L/kGSbZGZTw2Ige5Vpm1EoEmJmF5nZLWb2uJn9xcyONLPvmtkLZvZQeG4OZvbnoutPm9nufYSwv5k9YWaNxaMDMzvbzJaHRXwuDi9fBuwW3oV7RaV+4YhntZndCqwCJpnZsWFMq8zs8q3+4GRYUiKQbY6Z7Ulw6Nnx7r68ipfsBhwIzAZuBx5z948BrQRnyRdsDK8vJDheuDe7AJ8lOIjvsjCuzwF7ENQvmA58ysz2B84B1rr7dHc/u5d+hNevdfd/ANqBy8PYpwN7mdk/V/HfK9KNEoFsa8YD9wH/px+1Ih5093bgBSAFPBRefwGYUtTvJ0V/7tvHe/7C3Tvc/SXgg+G1z4VffwCeBf6e4Ad7qd76/cXdnwwf7wUsc/em8LyjO4D9S99MpC86hlq2NRsJSod+Fnipyte0Abh7h5m1Fx2j3UH37xGv8Ljie4as6M/vuPv1xR3DAi6U9K/Ur7mPv1ek3zQikG1NFvgi8K9m9uUBfu9jiv78/Ra8/tfAiWHRFsxsgpl9AHif4PTWvvqVeho4wMzGhXWTjwV+swVxyTCnEYFsc9y9OawOtcTMNrn74gF66zFm9jzBb/vHbkFcD5vZR4DfhwWNNgFz3X2tmf1vuPX1wXCdoEc/IF/yfq+b2TnAYwSjiF8VqsWJ9IeOoRapwnAvPiTbNk0NiYgMcxoRyDbLzD5PsL2y2Kvu/sUBev//Ar5Ucvmn7v7fA/H+IoNFiUBEZJjT1JCIyDCnRCAiMswpEYiIDHNKBCIiw9z/B5JHdxAnUuC9AAAAAElFTkSuQmCC\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" + } + ], + "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..774b71f7e 100644 --- a/doc/releasenotes.rst +++ b/doc/releasenotes.rst @@ -4,6 +4,23 @@ Release Notes ============= +0.10 series +........... + + +0.10.0 (2020-02-20) +------------------- + +* 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). +* Implement list population size (#274, #276). +* On history loading, automatically find an id of a successful run (#273). + + 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 4fa354a3e..68ee37fb8 100644 --- a/pyabc/__init__.py +++ b/pyabc/__init__.py @@ -33,6 +33,7 @@ PercentileDistance, RangeEstimatorDistance, DistanceWithMeasureList, + StochasticKernel, NormalKernel, IndependentNormalKernel, IndependentLaplaceKernel, @@ -75,7 +76,8 @@ UniformAcceptor, StochasticAcceptor, pdf_norm_from_kernel, - pdf_norm_max_found) + pdf_norm_max_found, + ScaledPDFNorm) from .model import ( Model, SimpleModel, @@ -115,6 +117,7 @@ "PercentileDistance", "RangeEstimatorDistance", "DistanceWithMeasureList", + "StochasticKernel", "NormalKernel", "IndependentNormalKernel", "IndependentLaplaceKernel", @@ -174,6 +177,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 678fa8b84..2ed73f34f 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, @@ -34,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 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 + 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/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..38f580ab5 --- /dev/null +++ b/pyabc/petab/amici.py @@ -0,0 +1,153 @@ +import logging +from collections.abc import Sequence, Mapping +from typing import Callable, Union +import copy + +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) + + # 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 + 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.""" + # 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, + 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/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/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: diff --git a/pyabc/smc.py b/pyabc/smc.py index e381262b4..754db9cb7 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 @@ -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/pyabc/storage/history.py b/pyabc/storage/history.py index 14ac8cc7d..b633179d9 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 @@ -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 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 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_acceptor.py b/test/test_acceptor.py index bf229673e..01801b845 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( @@ -96,6 +100,60 @@ 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(): + """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() + 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=3) + + +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 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_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 diff --git a/test/test_stop_sampling.py b/test/test_stop_sampling.py index 9639b665e..860961835 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"] / (df["samples"] - (n_procs-1)) + + assert df["corrected_acceptance_rate"].iloc[-1] >= set_acc_rate