diff --git a/.github/workflows/pipeline.yml b/.github/workflows/pipeline.yml index 20b308c..b800370 100644 --- a/.github/workflows/pipeline.yml +++ b/.github/workflows/pipeline.yml @@ -11,7 +11,7 @@ jobs: steps: - uses: actions/checkout@v2 - name: Install miniconda - uses: goanpeca/setup-miniconda@v1 + uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true activate-environment: rtlive-test diff --git a/notebooks/DE_Scaling with summary reports from OWID.ipynb b/notebooks/DE_Scaling with summary reports from OWID.ipynb new file mode 100644 index 0000000..9bbc686 --- /dev/null +++ b/notebooks/DE_Scaling with summary reports from OWID.ipynb @@ -0,0 +1,742 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scaling factor correction\n", + "In this notebook you can see how test counts are corrected by the weekly report from Our World in Data (OWID).\n", + "We first make the prediction with Prophet and then correct by comparing the predicted test count volume to the summarized report uploaded to OWID.\n", + "\n", + "**Note**: This notebook cannot be executed because the test count data from RKI cannot be uoloaded to git for privacy reasons" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# this cell makes it easier to mess with the project code interactively\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:fbprophet.plot:Importing plotly failed. Interactive plots will not work.\n" + ] + } + ], + "source": [ + "import datetime\n", + "import logging\n", + "import numpy\n", + "import pandas\n", + "import pathlib\n", + "import matplotlib\n", + "from matplotlib import pyplot, cm\n", + "\n", + "import arviz\n", + "import pymc3\n", + "\n", + "_log = logging.getLogger('notebook')\n", + "logging.basicConfig(level=logging.INFO)\n", + "\n", + "# messing with the path to get imports working\n", + "import sys\n", + "sys.path.append(str(pathlib.Path(\"..\").resolve()))\n", + "\n", + "import rtlive\n", + "from rtlive import data, preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# import of the country submodule adds data loading/preprocessing support\n", + "from rtlive.sources import data_de" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running for DE on 2021-02-03\n" + ] + } + ], + "source": [ + "country_alpha2 = 'DE'\n", + "run_date = datetime.datetime.today()\n", + "run_date_str = run_date.strftime('%Y-%m-%d')\n", + "print(f\"Running for {country_alpha2} on {run_date_str}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create two DataFrames for testing: One with confirmed test cases for January and one without" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# The following file contains the ARCGIS data from January 17 \n", + "# and confirmed regional test counts sent by RKI on January 14\n", + "df_with_january_tests = pandas.read_csv(\"2021-01-17 de_all_data.csv\", index_col=[\"region\", \"date\"], parse_dates=[\"date\"])\n", + "df_with_december_tests = df_with_january_tests.copy()\n", + "# Here we create a DataFrame where we pretend to not have the confirmied daily tests of January\n", + "# We therefore overwrite the \"new_test\" and \"positive fraction\" columns by a file from January 13\n", + "# (On that day we didn't have the confirmed daily tests for January)\n", + "df_temp = pandas.read_csv(\"2021-01-13 de_all_data.csv\", index_col=[\"region\", \"date\"], parse_dates=[\"date\"])\n", + "df_with_december_tests[[\"new_tests\", \"positive_fraction\"]] = numpy.nan\n", + "df_with_december_tests[\"new_tests\"] = df_temp.loc[df_temp.index, \"new_tests\"]\n", + "df_with_december_tests[\"positive_fraction\"] = df_temp.loc[df_temp.index, \"positive_fraction\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load data from OWID for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "df_owid = data_de.get_owid_summarized_totals(run_date)\n", + "# Update the artificially generated DataFrame with OWID data\n", + "# This is normally done in \"get_testcounts_DE\"\n", + "df_with_december_tests = df_with_december_tests.assign(owid_total_tests=df_owid)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:\\\\ibt733\\repos\\rtlive-global-pr\\rtlive\\preprocessing.py:Forecasting testcount gaps for all from 287 training points.\n", + "WARNING:pystan:n_eff / iter below 0.001 indicates that the effective sample size has likely been overestimated\n", + "WARNING:pystan:Rhat above 1.1 or below 0.9 indicates that the chains very likely have not mixed\n" + ] + } + ], + "source": [ + "df, results = data_de.forecast_DE(df_with_december_tests.loc[[\"all\"]])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
new_casesnew_deathsnew_testspositive_fractionowid_total_testspredicted_new_tests_rawscaling_factorpredicted_new_tests
regiondate
all2020-12-1731450899NaNNaNNaN102871.4877502.68457276166
2020-12-1829291787NaNNaNNaN98908.9730672.68457265528
2020-12-1921448609NaNNaNNaN27248.1032902.6845773149.5
2020-12-2013703415NaNNaN33142332.019187.6101482.6845751510.5
2020-12-2120013645NaNNaNNaN130084.5459861.97407256797
2020-12-2228417850NaNNaNNaN117414.3088041.97407231785
2020-12-2333290859NaNNaNNaN106623.3678371.97407210483
2020-12-2420820486NaNNaNNaN103268.9022931.97407203861
2020-12-2513036363NaNNaNNaN68952.7197831.97407136118
2020-12-2611400405NaNNaNNaN0.0000001.974070
2020-12-279695321NaNNaN34219398.019261.6134631.9740738023.9
2020-12-2815585571NaNNaNNaN130585.9834401.40292183201
2020-12-2927002769NaNNaNNaN117866.6571451.40292165357
2020-12-3030631720NaNNaNNaN107033.9172311.40292150160
2020-12-3119375450NaNNaNNaN103666.3168351.40292145435
2021-01-0110185222NaNNaNNaN69217.9279551.4029297106.9
2021-01-029960279NaNNaNNaN27458.4016611.4029238521.8
2021-01-038705246NaNNaN35026306.019335.6167771.4029227126.2
2021-01-0413978379NaNNaNNaN131087.4208931.99752261850
2021-01-0526987438NaNNaNNaN118319.0054851.99752236345
2021-01-0627348344NaNNaNNaN107444.4666261.99752214623
2021-01-0725556352NaNNaNNaN104063.7313781.99752207870
2021-01-0823760239NaNNaNNaN100054.6602811.99752199861
2021-01-0916162139NaNNaNNaN27563.5508461.9975255058.8
2021-01-10834193NaNNaN36240685.019409.6200911.9975238771.2
2021-01-1113352119NaNNaNNaN131588.8583471.99752262852
2021-01-1222062147NaNNaNNaN118771.3538261.99752237249
2021-01-132346580NaNNaNNaN107855.0160201.99752215443
2021-01-141977573NaNNaNNaN104461.1459201.99752208664
2021-01-151637576NaNNaNNaN100436.5560181.99752200624
\n", + "
" + ], + "text/plain": [ + " new_cases new_deaths new_tests positive_fraction \\\n", + "region date \n", + "all 2020-12-17 31450 899 NaN NaN \n", + " 2020-12-18 29291 787 NaN NaN \n", + " 2020-12-19 21448 609 NaN NaN \n", + " 2020-12-20 13703 415 NaN NaN \n", + " 2020-12-21 20013 645 NaN NaN \n", + " 2020-12-22 28417 850 NaN NaN \n", + " 2020-12-23 33290 859 NaN NaN \n", + " 2020-12-24 20820 486 NaN NaN \n", + " 2020-12-25 13036 363 NaN NaN \n", + " 2020-12-26 11400 405 NaN NaN \n", + " 2020-12-27 9695 321 NaN NaN \n", + " 2020-12-28 15585 571 NaN NaN \n", + " 2020-12-29 27002 769 NaN NaN \n", + " 2020-12-30 30631 720 NaN NaN \n", + " 2020-12-31 19375 450 NaN NaN \n", + " 2021-01-01 10185 222 NaN NaN \n", + " 2021-01-02 9960 279 NaN NaN \n", + " 2021-01-03 8705 246 NaN NaN \n", + " 2021-01-04 13978 379 NaN NaN \n", + " 2021-01-05 26987 438 NaN NaN \n", + " 2021-01-06 27348 344 NaN NaN \n", + " 2021-01-07 25556 352 NaN NaN \n", + " 2021-01-08 23760 239 NaN NaN \n", + " 2021-01-09 16162 139 NaN NaN \n", + " 2021-01-10 8341 93 NaN NaN \n", + " 2021-01-11 13352 119 NaN NaN \n", + " 2021-01-12 22062 147 NaN NaN \n", + " 2021-01-13 23465 80 NaN NaN \n", + " 2021-01-14 19775 73 NaN NaN \n", + " 2021-01-15 16375 76 NaN NaN \n", + "\n", + " owid_total_tests predicted_new_tests_raw scaling_factor \\\n", + "region date \n", + "all 2020-12-17 NaN 102871.487750 2.68457 \n", + " 2020-12-18 NaN 98908.973067 2.68457 \n", + " 2020-12-19 NaN 27248.103290 2.68457 \n", + " 2020-12-20 33142332.0 19187.610148 2.68457 \n", + " 2020-12-21 NaN 130084.545986 1.97407 \n", + " 2020-12-22 NaN 117414.308804 1.97407 \n", + " 2020-12-23 NaN 106623.367837 1.97407 \n", + " 2020-12-24 NaN 103268.902293 1.97407 \n", + " 2020-12-25 NaN 68952.719783 1.97407 \n", + " 2020-12-26 NaN 0.000000 1.97407 \n", + " 2020-12-27 34219398.0 19261.613463 1.97407 \n", + " 2020-12-28 NaN 130585.983440 1.40292 \n", + " 2020-12-29 NaN 117866.657145 1.40292 \n", + " 2020-12-30 NaN 107033.917231 1.40292 \n", + " 2020-12-31 NaN 103666.316835 1.40292 \n", + " 2021-01-01 NaN 69217.927955 1.40292 \n", + " 2021-01-02 NaN 27458.401661 1.40292 \n", + " 2021-01-03 35026306.0 19335.616777 1.40292 \n", + " 2021-01-04 NaN 131087.420893 1.99752 \n", + " 2021-01-05 NaN 118319.005485 1.99752 \n", + " 2021-01-06 NaN 107444.466626 1.99752 \n", + " 2021-01-07 NaN 104063.731378 1.99752 \n", + " 2021-01-08 NaN 100054.660281 1.99752 \n", + " 2021-01-09 NaN 27563.550846 1.99752 \n", + " 2021-01-10 36240685.0 19409.620091 1.99752 \n", + " 2021-01-11 NaN 131588.858347 1.99752 \n", + " 2021-01-12 NaN 118771.353826 1.99752 \n", + " 2021-01-13 NaN 107855.016020 1.99752 \n", + " 2021-01-14 NaN 104461.145920 1.99752 \n", + " 2021-01-15 NaN 100436.556018 1.99752 \n", + "\n", + " predicted_new_tests \n", + "region date \n", + "all 2020-12-17 276166 \n", + " 2020-12-18 265528 \n", + " 2020-12-19 73149.5 \n", + " 2020-12-20 51510.5 \n", + " 2020-12-21 256797 \n", + " 2020-12-22 231785 \n", + " 2020-12-23 210483 \n", + " 2020-12-24 203861 \n", + " 2020-12-25 136118 \n", + " 2020-12-26 0 \n", + " 2020-12-27 38023.9 \n", + " 2020-12-28 183201 \n", + " 2020-12-29 165357 \n", + " 2020-12-30 150160 \n", + " 2020-12-31 145435 \n", + " 2021-01-01 97106.9 \n", + " 2021-01-02 38521.8 \n", + " 2021-01-03 27126.2 \n", + " 2021-01-04 261850 \n", + " 2021-01-05 236345 \n", + " 2021-01-06 214623 \n", + " 2021-01-07 207870 \n", + " 2021-01-08 199861 \n", + " 2021-01-09 55058.8 \n", + " 2021-01-10 38771.2 \n", + " 2021-01-11 262852 \n", + " 2021-01-12 237249 \n", + " 2021-01-13 215443 \n", + " 2021-01-14 208664 \n", + " 2021-01-15 200624 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail(n=30)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = pyplot.subplots(figsize=(14,6))\n", + "\n", + "axs.scatter(\n", + " df_with_january_tests.xs(\"all\").index,\n", + " df_with_january_tests.xs(\"all\").new_tests,\n", + " label=\"unknown truth\",\n", + " marker=\"o\", color=\"gray\",\n", + ")\n", + "axs.plot(\n", + " df.xs(\"all\").index,\n", + " df.xs(\"all\").predicted_new_tests_raw,\n", + " label=\"raw prediction\",\n", + " color=\"orange\",\n", + ")\n", + "axs.plot(\n", + " df.xs(\"all\").index,\n", + " df.xs(\"all\").predicted_new_tests,\n", + " label=\"corrected prediction\",\n", + " color=\"red\",\n", + ")\n", + "axs.scatter(\n", + " df.xs(\"all\").index,\n", + " df.xs(\"all\").new_tests,\n", + " label=\"training data\",\n", + " marker=\"x\", color=\"orange\",\n", + ")\n", + "axs.legend()\n", + "#axs.set_xlim(pandas.Timestamp(\"2020-11\"))\n", + "axs.set_ylabel('daily test counts [-]')\n", + "axs.set_ylim(0)\n", + "pyplot.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.9" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/rtlive/preprocessing.py b/rtlive/preprocessing.py index 3127e2b..f9c82f6 100644 --- a/rtlive/preprocessing.py +++ b/rtlive/preprocessing.py @@ -250,7 +250,7 @@ def predict_testcounts_all_regions( df = df.copy() results = {} # forecast testcounts in all regions - for region in df.index.levels[0]: + for region in numpy.unique(df.index.get_level_values("region")): new_tests_nans = df.xs(region).new_tests.isna() n_train = sum(~new_tests_nans) if sum(~new_tests_nans) > 10: diff --git a/rtlive/sources/data_de.py b/rtlive/sources/data_de.py index 6118a50..48e1beb 100644 --- a/rtlive/sources/data_de.py +++ b/rtlive/sources/data_de.py @@ -34,6 +34,7 @@ from .. import preprocessing +from . import ourworldindata _log = logging.getLogger(__file__) @@ -278,20 +279,134 @@ def get_testcounts_DE(run_date, take_latest:bool=True) -> pandas.DataFrame: # drop non-associated AFTER calculating the sum df_merged.drop(index='nicht zugeordnet', inplace=True) - return df_merged + # Get the sparse data of total tests from OWID + df_owid = get_owid_summarized_totals(run_date) + df_merged = df_merged.assign(owid_total_tests=df_owid) + return df_merged -def forecast_DE(df: pandas.DataFrame): - """ Applies testcount interpolation/extrapolation to french data. - Currently this assumes the OWID data, which only has an "all" region. - In the future, this should be replaced with more fine graned data loading! +def forecast_DE(df: pandas.DataFrame) -> typing.Tuple[pandas.DataFrame, typing.Dict[str, preprocessing.ForecastingResult]]: + """ Applies testcount interpolation/extrapolation to German data. """ # forecast with existing data - df['predicted_new_tests'], results = preprocessing.predict_testcounts_all_regions(df, 'DE') + df['predicted_new_tests_raw'], results = preprocessing.predict_testcounts_all_regions(df, 'DE') + + # scale the daily forecast by OWID summary reports (RKI weekly test report) + df_factors = calculate_daily_scaling_factors( + forecasted_daily_tests=df.loc['all', 'predicted_new_tests_raw'], + sparse_reported_totals=df.loc['all', 'owid_total_tests'] + ) + df["scaling_factor"] = numpy.nan + df["predicted_new_tests"] = numpy.nan + # the scaling factor calculated from "all"-level forecasts and total reports is used + # for all regions, because regional totals are currently not available from OWID + for region in numpy.unique(df.index.get_level_values("region")): + # the scaling factor column will be included in the result + sfs = df_factors.scaling_factor + df.loc[pandas.IndexSlice[region, list(sfs.index)], 'scaling_factor'] = sfs.to_numpy() + df['predicted_new_tests'] = df['predicted_new_tests_raw'] * df['scaling_factor'] return df, results +def get_owid_summarized_totals(run_date): + """ Get the total amount of tests reported to OWID. + + At the moment only the `all` region is included. + At time of writing only sundays have a value that is not NaN. + """ + f = ourworldindata.create_loader_function("DE") + data = f(run_date) + return data.total_tests.rename("owid_total_tests").to_frame() + + +def calculate_daily_scaling_factors( + *, + forecasted_daily_tests: pandas.Series, + sparse_reported_totals: pandas.Series +) -> pandas.DataFrame: + """ Scale the daily test counts per region coming from the Prophet forecast by the test count report + from OurWorldInData, which is available before the real daily testcounts are known. + + Parameters + ---------- + forecasted_daily_tests: pandas.Series + Series from the Prophet forecast containing the confirmed daily test counts + sent from RKI privately as well as predicted test counts. + Both data are scaled by the total reported tests by OurWorldInData (OWID! + sparse_reported_totals : pandas.Series + Series from OWID containing total test counts summarized for a period of time + (mostly one week) for all of Germany. It is expected to contain NaN gaps in the data. + The differences between this report and the forecast data will be used to make sure + the total number of tests in the forecast matches the OWID data. + + Returns + ------- + correction_factor: pandas.DataFrame + The scaling factor for all dates including the future. + """ + assert isinstance(forecasted_daily_tests, pandas.Series) + assert isinstance(sparse_reported_totals, pandas.Series) + + df_factors = pandas.DataFrame( + index=forecasted_daily_tests.index, + columns=["sum_predicted", "diff_reported", "scaling_factor"] + ) + sum_dates = list(sparse_reported_totals.dropna().index) + for dfrom, dto in zip(sum_dates[:-1], sum_dates[1:]): + day = pandas.Timedelta("1D") + interval = slice(dfrom + day, dto) + # sum over the predictions in this inverval + sum_predicted = forecasted_daily_tests.loc[dfrom + day : dto].sum() + df_factors.loc[interval, ["sum_predicted"]] = sum_predicted + + # diff of the reports + prevtot = float(sparse_reported_totals.loc[dfrom]) + nexttot = float(sparse_reported_totals.loc[dto]) + diff_reported = nexttot - prevtot + df_factors.loc[interval, ["diff_reported"]] = diff_reported + + df_factors["scaling_factor"] = df_factors.diff_reported / df_factors.sum_predicted + # extrapolate backwards at the beginning + first = df_factors.dropna().iloc[0] + df_factors.loc[:first.name, "scaling_factor"] = first.scaling_factor + # continue into the future with the last known scaling factor + last = df_factors.dropna().iloc[-1] + df_factors.loc[last.name:, "scaling_factor"] = last.scaling_factor + return df_factors + + +def estimate_test_percentages_for_regions(df: pandas.DataFrame) -> pandas.Series: + """ Calculates the fraction of tests per region. + + Uses the 7 days up to the last day for which daily new_test data is available for all regions. + + WARNING: If any region has a gap _before_ the last day for which all of them have data, this + function will fail to return the correct result. + + Parameters + ---------- + df: pandas.DataFrame + The dataframe containing the new_test column with a [region, date] index as genereated by get_testcounts_DE. An `all` region has to be included. + + Returns + ------- + region_test_percentages: pandas.Series + Region-indexed series of fractions of all tests. + """ + rows_with_testcounts = df.new_tests[~df.new_tests.isna()] + last_date_with_testcounts_for_all_regions = rows_with_testcounts.groupby('region').tail(1).reset_index()['date'].min() + + # select the last 7 days up to the latest testcount data point + last_week_of_testcounts = slice(last_date_with_testcounts_for_all_regions - pandas.Timedelta('6D'), last_date_with_testcounts_for_all_regions) + + # Then calculate the sum of tests one week up to that date + testcounts_in_last_daily_data = df.new_tests.xs(last_week_of_testcounts, level='date').groupby('region').sum() + + # Finally convert absolutes to fractions + return testcounts_in_last_daily_data / testcounts_in_last_daily_data['all'] + + def download_rki_nowcast(run_date, target_filename) -> pathlib.Path: """ Downloads RKI nowcasting data unless [target_filename] already exists. diff --git a/rtlive/tests.py b/rtlive/tests.py index 6f7f2fa..428214c 100644 --- a/rtlive/tests.py +++ b/rtlive/tests.py @@ -88,6 +88,71 @@ def test_unsupported_country(self): ) +class TestDataDE: + def test_estimate_test_percentages(self): + from rtlive.sources import data_de + + df = pandas.DataFrame( + index=pandas.MultiIndex.from_product([ + ["RegionA", "RegionB", "RegionC", "all"], + pandas.date_range("2020-11-01", periods=14), + ], names=["region", "date"]), + data={ + "new_tests": numpy.nan + } + ) + na = numpy.nan + # TODO: The function fails on the scenario that there is a gap in any region _before_ the + # last day where all of them have data. + df.loc["RegionA", "new_tests"] = [10, 10, 10, 10, 10, 20, 20, 20, na, na, na, na, na, na] + df.loc["RegionB", "new_tests"] = [10, 10, 10, 10, 30, 20, 20, 30, 30, 30, na, 12, na, na] + df.loc["RegionC", "new_tests"] = [40, 40, 40, 10, 30, 20, 0., 17, 40, na, 20, na, na, na] + df.loc["all", "new_tests"] = [60, 60, 60, 30, 70, 60, 40, 67, 70, 30, 20, 12, na, na] + df.loc["all", "new_tests"] = df.loc["all", "new_tests"].values * 1.3 # plus a 30 % dark figure + # the last 7 days with data for all: |=========================| + # total tests in that window: 100 + 130 + 157 = 387 + total = 387 * 1.3 + expected = dict( + RegionA=100/total, RegionB=130/total, RegionC=157/total + ) + df_fractions = data_de.estimate_test_percentages_for_regions(df) + for reg, exp in expected.items(): + assert df_fractions.loc[reg] == exp, f"{reg}: {df_fractions.loc[reg]} != {exp}" + pass + + def test_calculate_scaling_factor(self): + from rtlive.sources import data_de + + na = numpy.nan + ser_predicted = pandas.Series( + index=pandas.date_range("2021-04-01", "2021-04-15"), + data=[15,20,10] * 5 + ) + ser_reported = pandas.Series( + index=pandas.date_range("2021-04-01", "2021-04-13"), + data=[na,na,45]+[na,na,45+90]+[na,na,45+90+45]+[na,na,45+90+45+135]+[na] + ) + result = data_de.calculate_daily_scaling_factors( + forecasted_daily_tests=ser_predicted, + sparse_reported_totals=ser_reported, + ) + assert isinstance(result, pandas.DataFrame) + numpy.testing.assert_array_equal( + result.sum_predicted.to_numpy().astype(float), + [na, na, na, *[45.]*9, na, na, na] + ) + numpy.testing.assert_array_equal( + result.diff_reported.to_numpy().astype(float), + [na, na, na, 90,90,90,45,45,45,135,135,135, na, na, na] + ) + assert result.loc["2021-04-01", "scaling_factor"] == 2 + assert result.loc["2021-04-05", "scaling_factor"] == 2 + assert result.loc["2021-04-07", "scaling_factor"] == 1 + assert result.loc["2021-04-12", "scaling_factor"] == 3 + assert result.loc["2021-04-15", "scaling_factor"] == 3 + pass + + class TestModel: def test_build(self): from rtlive.sources import data_ch