From 92e51e4998133c69040a1280f6997f2c497b2510 Mon Sep 17 00:00:00 2001 From: Schalk van Heerden Date: Tue, 7 Jul 2020 23:26:41 +0200 Subject: [PATCH 1/2] New Rt notebook model using MCMC --- data/calc/calculated_rt_sa_mcmc.csv | 132 + notebooks/covid-model/LICENSE | 13 + notebooks/covid-model/covid/__init__.py | 1 + notebooks/covid-model/covid/data.py | 123 + .../covid-model/covid/models/__init__.py | 0 .../covid-model/covid/models/generative.py | 231 ++ notebooks/covid-model/covid/patients.py | 102 + notebooks/covid-model/covid/storage.py | 23 + notebooks/covid-model/covid/tasks.py | 121 + notebooks/covid-model/data/p_delay.csv | 67 + notebooks/covid-model/requirements.txt | 11 + notebooks/covid-model/rtlive-model-za.ipynb | 2213 +++++++++++++++++ 12 files changed, 3037 insertions(+) create mode 100644 data/calc/calculated_rt_sa_mcmc.csv create mode 100644 notebooks/covid-model/LICENSE create mode 100644 notebooks/covid-model/covid/__init__.py create mode 100644 notebooks/covid-model/covid/data.py create mode 100644 notebooks/covid-model/covid/models/__init__.py create mode 100644 notebooks/covid-model/covid/models/generative.py create mode 100644 notebooks/covid-model/covid/patients.py create mode 100644 notebooks/covid-model/covid/storage.py create mode 100644 notebooks/covid-model/covid/tasks.py create mode 100644 notebooks/covid-model/data/p_delay.csv create mode 100644 notebooks/covid-model/requirements.txt create mode 100644 notebooks/covid-model/rtlive-model-za.ipynb diff --git a/data/calc/calculated_rt_sa_mcmc.csv b/data/calc/calculated_rt_sa_mcmc.csv new file mode 100644 index 000000000..d5c712e17 --- /dev/null +++ b/data/calc/calculated_rt_sa_mcmc.csv @@ -0,0 +1,132 @@ +date,Median,High_80,Low_80 +2020-02-26,1.894,2.184,1.567 +2020-02-27,1.896,2.169,1.582 +2020-02-28,1.884,2.148,1.573 +2020-02-29,1.879,2.093,1.551 +2020-03-01,1.865,2.113,1.611 +2020-03-02,1.851,2.099,1.603 +2020-03-03,1.830,2.041,1.585 +2020-03-04,1.811,2.050,1.609 +2020-03-05,1.780,1.959,1.551 +2020-03-06,1.744,1.931,1.551 +2020-03-07,1.701,1.900,1.543 +2020-03-08,1.660,1.808,1.478 +2020-03-09,1.613,1.766,1.461 +2020-03-10,1.559,1.700,1.422 +2020-03-11,1.503,1.632,1.376 +2020-03-12,1.443,1.566,1.322 +2020-03-13,1.390,1.504,1.285 +2020-03-14,1.338,1.436,1.226 +2020-03-15,1.290,1.385,1.186 +2020-03-16,1.247,1.330,1.144 +2020-03-17,1.207,1.290,1.105 +2020-03-18,1.178,1.269,1.093 +2020-03-19,1.148,1.233,1.067 +2020-03-20,1.130,1.213,1.054 +2020-03-21,1.115,1.190,1.036 +2020-03-22,1.103,1.179,1.028 +2020-03-23,1.095,1.167,1.010 +2020-03-24,1.090,1.169,1.011 +2020-03-25,1.084,1.157,1.006 +2020-03-26,1.079,1.153,1.004 +2020-03-27,1.075,1.155,1.004 +2020-03-28,1.074,1.152,0.994 +2020-03-29,1.077,1.156,0.995 +2020-03-30,1.078,1.158,0.995 +2020-03-31,1.078,1.166,0.997 +2020-04-01,1.081,1.152,0.985 +2020-04-02,1.082,1.168,1.000 +2020-04-03,1.081,1.162,1.000 +2020-04-04,1.086,1.159,0.999 +2020-04-05,1.087,1.155,0.991 +2020-04-06,1.088,1.172,1.009 +2020-04-07,1.088,1.174,1.008 +2020-04-08,1.087,1.168,1.007 +2020-04-09,1.088,1.161,0.998 +2020-04-10,1.088,1.162,0.999 +2020-04-11,1.091,1.171,1.009 +2020-04-12,1.096,1.178,1.020 +2020-04-13,1.099,1.171,1.013 +2020-04-14,1.102,1.183,1.024 +2020-04-15,1.109,1.186,1.028 +2020-04-16,1.114,1.196,1.039 +2020-04-17,1.117,1.195,1.035 +2020-04-18,1.125,1.199,1.037 +2020-04-19,1.131,1.207,1.042 +2020-04-20,1.137,1.215,1.053 +2020-04-21,1.140,1.221,1.059 +2020-04-22,1.146,1.225,1.062 +2020-04-23,1.156,1.231,1.075 +2020-04-24,1.160,1.242,1.075 +2020-04-25,1.166,1.249,1.082 +2020-04-26,1.171,1.251,1.085 +2020-04-27,1.172,1.262,1.087 +2020-04-28,1.176,1.249,1.070 +2020-04-29,1.179,1.263,1.081 +2020-04-30,1.182,1.263,1.089 +2020-05-01,1.183,1.280,1.097 +2020-05-02,1.183,1.279,1.107 +2020-05-03,1.184,1.261,1.096 +2020-05-04,1.182,1.267,1.091 +2020-05-05,1.182,1.270,1.095 +2020-05-06,1.182,1.264,1.095 +2020-05-07,1.177,1.255,1.088 +2020-05-08,1.177,1.263,1.092 +2020-05-09,1.173,1.251,1.081 +2020-05-10,1.170,1.263,1.094 +2020-05-11,1.166,1.269,1.096 +2020-05-12,1.167,1.249,1.078 +2020-05-13,1.168,1.242,1.079 +2020-05-14,1.165,1.252,1.086 +2020-05-15,1.161,1.254,1.082 +2020-05-16,1.160,1.237,1.069 +2020-05-17,1.158,1.241,1.076 +2020-05-18,1.159,1.238,1.065 +2020-05-19,1.157,1.235,1.067 +2020-05-20,1.156,1.236,1.066 +2020-05-21,1.154,1.250,1.075 +2020-05-22,1.154,1.238,1.061 +2020-05-23,1.152,1.241,1.064 +2020-05-24,1.160,1.243,1.067 +2020-05-25,1.163,1.264,1.088 +2020-05-26,1.164,1.260,1.082 +2020-05-27,1.171,1.263,1.088 +2020-05-28,1.177,1.253,1.084 +2020-05-29,1.177,1.253,1.085 +2020-05-30,1.176,1.263,1.098 +2020-05-31,1.183,1.264,1.100 +2020-06-01,1.184,1.266,1.102 +2020-06-02,1.184,1.272,1.102 +2020-06-03,1.187,1.268,1.104 +2020-06-04,1.188,1.268,1.096 +2020-06-05,1.188,1.279,1.114 +2020-06-06,1.194,1.266,1.100 +2020-06-07,1.192,1.279,1.104 +2020-06-08,1.194,1.285,1.112 +2020-06-09,1.193,1.291,1.109 +2020-06-10,1.193,1.298,1.110 +2020-06-11,1.195,1.283,1.093 +2020-06-12,1.193,1.289,1.087 +2020-06-13,1.196,1.294,1.088 +2020-06-14,1.202,1.304,1.085 +2020-06-15,1.199,1.323,1.100 +2020-06-16,1.195,1.316,1.083 +2020-06-17,1.191,1.330,1.092 +2020-06-18,1.189,1.304,1.063 +2020-06-19,1.191,1.300,1.030 +2020-06-20,1.188,1.325,1.046 +2020-06-21,1.186,1.332,1.037 +2020-06-22,1.191,1.344,1.030 +2020-06-23,1.185,1.353,1.023 +2020-06-24,1.185,1.373,1.027 +2020-06-25,1.190,1.348,0.984 +2020-06-26,1.185,1.351,0.973 +2020-06-27,1.187,1.379,0.984 +2020-06-28,1.184,1.386,0.977 +2020-06-29,1.188,1.388,0.957 +2020-06-30,1.184,1.393,0.959 +2020-07-01,1.176,1.406,0.965 +2020-07-02,1.182,1.394,0.943 +2020-07-03,1.190,1.430,0.960 +2020-07-04,1.190,1.440,0.949 +2020-07-05,1.195,1.447,0.943 diff --git a/notebooks/covid-model/LICENSE b/notebooks/covid-model/LICENSE new file mode 100644 index 000000000..a29646616 --- /dev/null +++ b/notebooks/covid-model/LICENSE @@ -0,0 +1,13 @@ +Copyright 2020 Kevin Systrom, rt.live + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/notebooks/covid-model/covid/__init__.py b/notebooks/covid-model/covid/__init__.py new file mode 100644 index 000000000..3dc1f76bc --- /dev/null +++ b/notebooks/covid-model/covid/__init__.py @@ -0,0 +1 @@ +__version__ = "0.1.0" diff --git a/notebooks/covid-model/covid/data.py b/notebooks/covid-model/covid/data.py new file mode 100644 index 000000000..cbd843ab1 --- /dev/null +++ b/notebooks/covid-model/covid/data.py @@ -0,0 +1,123 @@ +import requests +import pandas as pd +import numpy as np +import arviz as az + +idx = pd.IndexSlice + + +def get_raw_covidtracking_data(): + """ Gets the current daily CSV from COVIDTracking """ + url = "https://covidtracking.com/api/v1/states/daily.csv" + data = pd.read_csv(url) + return data + + +def process_covidtracking_data(data: pd.DataFrame, run_date: pd.Timestamp): + """ Processes raw COVIDTracking data to be in a form for the GenerativeModel. + In many cases, we need to correct data errors or obvious outliers.""" + data = data.rename(columns={"state": "region"}) + data["date"] = pd.to_datetime(data["date"], format="%Y%m%d") + data = data.set_index(["region", "date"]).sort_index() + data = data.loc[idx[:, :run_date], ["positive", "total"]] + + # Too little data or unreliable reporting in the data source. + data = data.drop(["MP", "GU", "AS", "PR", "VI"]) + + # On Jun 5 Covidtracking started counting probable cases too + # which increases the amount by 5014. + # https://covidtracking.com/screenshots/MI/MI-20200605-184320.png + data.loc[idx["MI", pd.Timestamp("2020-06-05") :], "positive"] -= 5014 + + # From CT: On June 19th, LDH removed 1666 duplicate and non resident cases + # after implementing a new de-duplicaton process. + data.loc[idx["LA", pd.Timestamp("2020-06-19") :], :] += 1666 + + # Now work with daily counts + data = data.diff().dropna().clip(0, None) + + # Michigan missed 6/18 totals and lumped them into 6/19 so we've + # divided the totals in two and equally distributed to both days. + data.loc[idx["MI", pd.Timestamp("2020-06-18")], "total"] = 14871 + data.loc[idx["MI", pd.Timestamp("2020-06-19")], "total"] = 14871 + + # Note that when we set total to zero, the model ignores that date. See + # the likelihood function in GenerativeModel.build + + # Huge outlier in NJ causing sampling issues. + data.loc[idx["NJ", pd.Timestamp("2020-05-11")], :] = 0 + + # Huge outlier in CA causing sampling issues. + data.loc[idx["CA", pd.Timestamp("2020-04-22")], :] = 0 + + # Huge outlier in CA causing sampling issues. + # TODO: generally should handle when # tests == # positives and that + # is not an indication of positive rate. + data.loc[idx["SC", pd.Timestamp("2020-06-26")], :] = 0 + + # Two days of no new data then lumped sum on third day with lack of new total tests + data.loc[idx["OR", pd.Timestamp("2020-06-26") : pd.Timestamp("2020-06-28")], 'positive'] = 174 + data.loc[idx["OR", pd.Timestamp("2020-06-26") : pd.Timestamp("2020-06-28")], 'total'] = 3296 + + + #https://twitter.com/OHdeptofhealth/status/1278768987292209154 + data.loc[idx["OH", pd.Timestamp("2020-07-01")], :] = 0 + + # A bunch of incorrect values for WA data so nulling them out. + data.loc[idx["WA", pd.Timestamp("2020-06-05") : pd.Timestamp("2020-06-07")], :] = 0 + data.loc[idx["WA", pd.Timestamp("2020-06-20") : pd.Timestamp("2020-06-21")], :] = 0 + + # Outlier dates in PA + data.loc[ + idx[ + "PA", + [ + pd.Timestamp("2020-06-03"), + pd.Timestamp("2020-04-21"), + pd.Timestamp("2020-05-20"), + ], + ], + :, + ] = 0 + + return data + + +def get_and_process_covidtracking_data(run_date: pd.Timestamp): + """ Helper function for getting and processing COVIDTracking data at once """ + data = get_raw_covidtracking_data() + data = process_covidtracking_data(data, run_date) + return data + + +def summarize_inference_data(inference_data: az.InferenceData): + """ Summarizes an inference_data object into the form that we publish on + rt.live """ + posterior = inference_data.posterior + hdi_mass = 80 + hpdi = az.hdi(posterior.r_t, hdi_prob=hdi_mass / 100).r_t + + observed_positive = inference_data.constant_data.observed_positive.to_series() + scale_to_positives = lambda data: observed_positive.mean() / np.mean(data) * data + tests = inference_data.constant_data.tests.to_series() + normalized_positive = observed_positive / tests.clip(0.1 * tests.max()) + + summary = pd.DataFrame( + data={ + "mean": posterior.r_t.mean(["draw", "chain"]), + "median": posterior.r_t.median(["chain", "draw"]), + f"lower_{hdi_mass}": hpdi[:, 0], + f"upper_{hdi_mass}": hpdi[:, 1], + "infections": scale_to_positives( + posterior.infections.mean(["draw", "chain"]) + ), + "test_adjusted_positive": scale_to_positives( + posterior.test_adjusted_positive.mean(["draw", "chain"]) + ), + "test_adjusted_positive_raw": scale_to_positives(normalized_positive), + "positive": observed_positive, + "tests": tests, + }, + index=pd.Index(posterior.date.values, name="date"), + ) + return summary diff --git a/notebooks/covid-model/covid/models/__init__.py b/notebooks/covid-model/covid/models/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/notebooks/covid-model/covid/models/generative.py b/notebooks/covid-model/covid/models/generative.py new file mode 100644 index 000000000..b22e33e47 --- /dev/null +++ b/notebooks/covid-model/covid/models/generative.py @@ -0,0 +1,231 @@ +import warnings + +warnings.simplefilter(action="ignore", category=FutureWarning) + +import pymc3 as pm +import arviz as az +import numpy as np +import pandas as pd +from scipy import stats as sps + +import theano +import theano.tensor as tt +from theano.tensor.signal.conv import conv2d + +from covid.patients import get_delay_distribution + + +class GenerativeModel: + version = "1.0.0" + + def __init__(self, region: str, observed: pd.DataFrame, buffer_days=10): + """ Takes a region (ie State) name and observed new positive and + total test counts per day. buffer_days is the default number of + blank days we pad on the leading edge of the time series because + infections occur long before reports and we need to infer values + on those days """ + + first_index = observed.positive.ne(0).argmax() + observed = observed.iloc[first_index:] + new_index = pd.date_range( + start=observed.index[0] - pd.Timedelta(days=buffer_days), + end=observed.index[-1], + freq="D", + ) + observed = observed.reindex(new_index, fill_value=0) + + self._trace = None + self._inference_data = None + self.model = None + self.observed = observed + self.region = region + + @property + def n_divergences(self): + """ Returns the number of divergences from the current trace """ + assert self.trace != None, "Must run sample() first!" + return self.trace["diverging"].nonzero()[0].size + + @property + def inference_data(self): + """ Returns an Arviz InferenceData object """ + assert self.trace, "Must run sample() first!" + + coords, dimensions = self._get_coords_and_dimensions() + + with self.model: + posterior_predictive = pm.sample_posterior_predictive(self.trace) + + _inference_data = az.from_pymc3( + trace=self.trace, + posterior_predictive=posterior_predictive, + coords=coords, + dims=dimensions, + ) + _inference_data.posterior.attrs["model_version"] = self.version + + return _inference_data + + @property + def trace(self): + """ Returns the trace from a sample() call. """ + assert self._trace, "Must run sample() first!" + return self._trace + + def _scale_to_positives(self, data): + """ Scales a time series to have the same mean as the observed positives + time series. This is useful because many of the series we infer are + relative to their true values so we make them comparable by putting + them on the same scale. """ + scale_factor = self.observed.positive.mean() / np.mean(data) + return scale_factor * data + + def _get_coords_and_dimensions(self): + """ Returns coordinates and dimensions when converting a trace to an + Arviz InferenceData object. """ + coordinates = { + "date": self.observed.index.values, + } + dimensions = { + "r_t": ["date"], + "log_r_t": ["date"], + "infections": ["date"], + "test_adjusted_positive": ["date"], + "positive": ["date"], + "tests": ["date"], + "exposure": ["date"], + "observed_positive": ["date"], + } + return coordinates, dimensions + + def _get_generation_time_interval(self): + """ Create a discrete P(Generation Interval) + Source: https://www.ijidonline.com/article/S1201-9712(20)30119-3/pdf """ + mean_si = 4.7 + std_si = 2.9 + mu_si = np.log(mean_si ** 2 / np.sqrt(std_si ** 2 + mean_si ** 2)) + sigma_si = np.sqrt(np.log(std_si ** 2 / mean_si ** 2 + 1)) + dist = sps.lognorm(scale=np.exp(mu_si), s=sigma_si) + + # Discretize the Generation Interval up to 20 days max + g_range = np.arange(0, 20) + gt = pd.Series(dist.cdf(g_range), index=g_range) + gt = gt.diff().fillna(0) + gt /= gt.sum() + gt = gt.values + return gt + + def _get_convolution_ready_gt(self, len_observed): + """ Speeds up theano.scan by pre-computing the generation time interval + vector. Thank you to Junpeng Lao for this optimization. + Please see the outbreak simulation math here: + https://staff.math.su.se/hoehle/blog/2020/04/15/effectiveR0.html """ + gt = self._get_generation_time_interval() + convolution_ready_gt = np.zeros((len_observed - 1, len_observed)) + for t in range(1, len_observed): + begin = np.maximum(0, t - len(gt) + 1) + slice_update = gt[1 : t - begin + 1][::-1] + convolution_ready_gt[ + t - 1, begin : begin + len(slice_update) + ] = slice_update + convolution_ready_gt = theano.shared(convolution_ready_gt) + return convolution_ready_gt + + def build(self): + """ Builds and returns the Generative model. Also sets self.model """ + + p_delay = get_delay_distribution() + nonzero_days = self.observed.total.gt(0) + len_observed = len(self.observed) + convolution_ready_gt = self._get_convolution_ready_gt(len_observed) + x = np.arange(len_observed)[:, None] + + with pm.Model() as self.model: + + # Let log_r_t walk randomly with a fixed prior of ~0.035. Think + # of this number as how quickly r_t can react. + log_r_t = pm.GaussianRandomWalk("log_r_t", sigma=0.035, shape=len_observed) + r_t = pm.Deterministic("r_t", pm.math.exp(log_r_t)) + + # For a given seed population and R_t curve, we calculate the + # implied infection curve by simulating an outbreak. While this may + # look daunting, it's simply a way to recreate the outbreak + # simulation math inside the model: + # https://staff.math.su.se/hoehle/blog/2020/04/15/effectiveR0.html + seed = pm.Exponential("seed", 1 / 0.02) + y0 = tt.zeros(len_observed) + y0 = tt.set_subtensor(y0[0], seed) + outputs, _ = theano.scan( + fn=lambda t, gt, y, r_t: tt.set_subtensor(y[t], tt.sum(r_t * y * gt)), + sequences=[tt.arange(1, len_observed), convolution_ready_gt], + outputs_info=y0, + non_sequences=r_t, + n_steps=len_observed - 1, + ) + infections = pm.Deterministic("infections", outputs[-1]) + + # Convolve infections to confirmed positive reports based on a known + # p_delay distribution. See patients.py for details on how we calculate + # this distribution. + test_adjusted_positive = pm.Deterministic( + "test_adjusted_positive", + conv2d( + tt.reshape(infections, (1, len_observed)), + tt.reshape(p_delay, (1, len(p_delay))), + border_mode="full", + )[0, :len_observed], + ) + + # Picking an exposure with a prior that exposure never goes below + # 0.1 * max_tests. The 0.1 only affects early values of Rt when + # testing was minimal or when data errors cause underreporting + # of tests. + tests = pm.Data("tests", self.observed.total.values) + exposure = pm.Deterministic( + "exposure", pm.math.clip(tests, self.observed.total.max() * 0.1, 1e9) + ) + + # Test-volume adjust reported cases based on an assumed exposure + # Note: this is similar to the exposure parameter in a Poisson + # regression. + positive = pm.Deterministic("positive", exposure * test_adjusted_positive) + + # Save data as part of trace so we can access in inference_data + observed_positive = pm.Data( + "observed_positive", self.observed.positive.values + ) + + positive_nonzero = pm.NegativeBinomial( + "nonzero_positive", + mu=positive[nonzero_days.values], + alpha=pm.Gamma("alpha", mu=6, sigma=1), + observed=self.observed.positive[nonzero_days.values].values, + ) + + return self.model + + def sample( + self, + cores=4, + chains=4, + tune=700, + draws=200, + target_accept=0.95, + init="jitter+adapt_diag", + ): + """ Runs the PyMC3 model and stores the trace result in self.trace """ + + if self.model is None: + self.build() + + with self.model: + self._trace = pm.sample( + draws=draws, + cores=cores, + chains=chains, + target_accept=target_accept, + tune=tune, + init=init, + ) + + return self diff --git a/notebooks/covid-model/covid/patients.py b/notebooks/covid-model/covid/patients.py new file mode 100644 index 000000000..e613d222f --- /dev/null +++ b/notebooks/covid-model/covid/patients.py @@ -0,0 +1,102 @@ +import os +from scipy import stats as sps +import numpy as np +import pandas as pd +import requests + + +def download_patient_data(file_path=None): + """ Downloads patient data to data directory + from: https://stackoverflow.com/questions/16694907/ """ + if not file_path: + file_path = os.path.join(os.path.dirname(__file__), "../data/patients.tar.gz") + url = "https://github.com/beoutbreakprepared/nCoV2019/raw/master/latest_data/latestdata.tar.gz" + with requests.get(url, stream=True) as r: + r.raise_for_status() + with open(file_path, "wb") as f: + for chunk in r.iter_content(chunk_size=8192): + if chunk: # filter out keep-alive new chunks + f.write(chunk) + + +def get_patient_data(file_path=None, max_delay=60): + """ Finds every valid delay between symptom onset and report confirmation + from the patient line list and returns all the delay samples. """ + if not file_path: + file_path = os.path.join(os.path.dirname(__file__), "../data/patients.tar.gz") + patients = pd.read_csv( + file_path, + parse_dates=False, + usecols=["country", "date_onset_symptoms", "date_confirmation"], + low_memory=False, + ) + + patients.columns = ["Country", "Onset", "Confirmed"] + patients.Country = patients.Country.astype("category") + + # There's an errant reversed date + patients = patients.replace("01.31.2020", "31.01.2020") + patients = patients.replace("31.04.2020", "01.05.2020") + + # Only keep if both values are present + patients = patients.dropna() + + # Must have strings that look like individual dates + # "2020.03.09" is 10 chars long + is_ten_char = lambda x: x.str.len().eq(10) + patients = patients[is_ten_char(patients.Confirmed) & is_ten_char(patients.Onset)] + + # Convert both to datetimes + patients.Confirmed = pd.to_datetime( + patients.Confirmed, format="%d.%m.%Y", errors="coerce" + ) + patients.Onset = pd.to_datetime(patients.Onset, format="%d.%m.%Y", errors="coerce") + + # Only keep records where confirmed > onset + patients = patients[patients.Confirmed > patients.Onset] + + # Mexico has many cases that are all confirmed on the same day regardless + # of onset date, so we filter it out. + patients = patients[patients.Country.ne("Mexico")] + + # Remove any onset dates from the last two weeks to account for all the + # people who haven't been confirmed yet. + patients = patients[patients.Onset < patients.Onset.max() - pd.Timedelta(days=14)] + + return patients + + +def get_delays_from_patient_data(file_path=None, max_delay=60): + patients = get_patient_data(file_path=file_path, max_delay=max_delay) + delays = (patients.Confirmed - patients.Onset).dt.days + delays = delays.reset_index(drop=True) + delays = delays[delays.le(max_delay)] + return delays + + +def get_delay_distribution(): + """ Returns the empirical delay distribution between symptom onset and + confirmed positive case. """ + + # The literature suggests roughly 5 days of incubation before becoming + # having symptoms. See: + # https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7081172/ + INCUBATION_DAYS = 5 + + try: + p_delay_path = os.path.join(os.path.dirname(__file__), "../data/p_delay.csv") + p_delay = pd.read_csv(p_delay_path, squeeze=True) + except FileNotFoundError: + delays = get_delays_from_patient_data() + p_delay = delays.value_counts().sort_index() + new_range = np.arange(0, p_delay.index.max() + 1) + p_delay = p_delay.reindex(new_range, fill_value=0) + p_delay /= p_delay.sum() + p_delay = ( + pd.Series(np.zeros(INCUBATION_DAYS)) + .append(p_delay, ignore_index=True) + .rename("p_delay") + ) + p_delay.to_csv("data/p_delay.csv", index=False) + + return p_delay diff --git a/notebooks/covid-model/covid/storage.py b/notebooks/covid-model/covid/storage.py new file mode 100644 index 000000000..dfa46c1f0 --- /dev/null +++ b/notebooks/covid-model/covid/storage.py @@ -0,0 +1,23 @@ +def get_inference_data_key(run_date, region, country="us"): + date_str = run_date.strftime("%Y%m%d") + return f"{country}/{date_str}/inference_data/{region}.nc" + + +def get_state_output_key(run_date, region, country="us"): + date_str = run_date.strftime("%Y%m%d") + return f"{country}/{date_str}/stateoutput/{region}.csv" + + +def get_overall_output_key(run_date, country="us"): + date_str = run_date.strftime("%Y%m%d") + return f"{country}/{date_str}/joined.csv" + + +def get_processed_covidtracking_key(run_date, country="us"): + date_str = run_date.strftime("%Y%m%d") + return f"{country}/{date_str}/covidtracking_processed.csv" + + +def get_covidtracking_csv_key(run_date, country="us"): + date_str = run_date.strftime("%Y%m%d") + return f"{country}/{date_str}/covidtracking.csv" diff --git a/notebooks/covid-model/covid/tasks.py b/notebooks/covid-model/covid/tasks.py new file mode 100644 index 000000000..9471163c5 --- /dev/null +++ b/notebooks/covid-model/covid/tasks.py @@ -0,0 +1,121 @@ +import boto3 +from io import BytesIO +import arviz as az +import os +import pandas as pd +import requests +import s3fs +import tempfile +import numpy as np +from covid.storage import ( + get_covidtracking_csv_key, + get_processed_covidtracking_key, + get_overall_output_key, + get_inference_data_key, + get_state_output_key, +) +from covid.data import ( + get_raw_covidtracking_data, + process_covidtracking_data, + summarize_inference_data, +) +from covid.models.generative import GenerativeModel + + +s3 = boto3.Session( + aws_access_key_id=os.environ.get("S3_ACCESS_KEY", None), + aws_secret_access_key=os.environ.get("S3_SECRET_KEY", None), +).resource(service_name="s3", endpoint_url=os.environ.get("S3_URL", None)) +fs = s3fs.S3FileSystem( + anon=False, + key=os.environ.get("S3_ACCESS_KEY", None), + secret=os.environ.get("S3_SECRET_KEY", None), + client_kwargs=dict(endpoint_url=os.environ.get("S3_URL", None)), +) +S3_BUCKET = os.environ.get("RTLIVE_S3_BUCKET") + + +def task_get_covidtracking_data(run_date: pd.Timestamp): + """ Cache COVIDTracking daily data to s3 """ + data = get_raw_covidtracking_data() + key = get_covidtracking_csv_key(run_date) + with fs.open(f"{S3_BUCKET}/{key}", "w") as file: + data.to_csv(file) + + +def task_process_covidtracking_data(run_date: pd.Timestamp): + """ Process the COVIDTracking daily data into a form that works with our + model. """ + key = get_covidtracking_csv_key(run_date) + with fs.open(f"{S3_BUCKET}/{key}") as file: + data = pd.read_csv(file, parse_dates=["date"]) + data = process_covidtracking_data(data, run_date) + key = get_processed_covidtracking_key(run_date) + with fs.open(f"{S3_BUCKET}/{key}", "w") as file: + data.to_csv(file) + + +def task_run_model(country: str, region: str, run_date: pd.Timestamp): + """ Run the Generative model for a given region on a given date, store + inference data into S3. """ + key = get_processed_covidtracking_key(run_date) + with fs.open(f"{S3_BUCKET}/{key}") as file: + df = pd.read_csv(file, index_col=["region", "date"], parse_dates=["date"]) + + model_input = df.xs(region) + gm = GenerativeModel(region, model_input) + gm.sample() + + inference_data = gm.inference_data + + # Ensure no divergences + assert ( + gm.n_divergences == 0 + ), f"Model {region} had {gm.n_divergences} divergences, failing." + + # Ensure convergence + R_HAT_LIMIT = 1.1 + r_hat = az.rhat(inference_data).to_dataframe().fillna(1.0) + assert r_hat.le(R_HAT_LIMIT).all().all(), f"r_hat exceeded threshold, failing." + + with tempfile.NamedTemporaryFile() as fp: + inference_data.to_netcdf(fp.name) + fp.seek(0) + s3.Bucket(S3_BUCKET).upload_fileobj( + fp, get_inference_data_key(run_date, region, country=country) + ) + return {"country": country, "region": region, "r_hat": r_hat} + + +def task_render_region_result(country: str, region: str, run_date: pd.Timestamp): + """ Render a CSV with summary output for a given region """ + az.rcParams["data.load"] = "eager" + + with tempfile.NamedTemporaryFile() as fp: + s3.Bucket(S3_BUCKET).download_file( + get_inference_data_key(run_date, region, country=country), fp.name + ) + fp.seek(0) + inference_data = az.from_netcdf(fp.name) + + summary = summarize_inference_data(inference_data) + key = get_state_output_key(run_date, region, country=country) + with fs.open(f"{S3_BUCKET}/{key}", "w") as file: + summary.to_csv(file) + + +def task_gather_region_results(country: str, regions: [str], run_date: pd.Timestamp): + """ Collects all regions results and outputs them as a single file """ + dfs = [] + for region in regions: + key = get_state_output_key(run_date, region, country=country) + with fs.open(f"{S3_BUCKET}/{key}") as file: + df = pd.read_csv(file) + multi_index = pd.MultiIndex.from_product([[region], df.index]) + multi_index.set_names(["region", "index"], inplace=True) + df.index = multi_index + dfs.append(df) + all_regions = pd.concat(dfs) + all_key = get_overall_output_key(run_date, country=country) + with fs.open(f"{S3_BUCKET}/{all_key}", "w") as file: + all_regions.to_csv(file) diff --git a/notebooks/covid-model/data/p_delay.csv b/notebooks/covid-model/data/p_delay.csv new file mode 100644 index 000000000..518af725b --- /dev/null +++ b/notebooks/covid-model/data/p_delay.csv @@ -0,0 +1,67 @@ +p_delay +0.0 +0.0 +0.0 +0.0 +0.0 +0.0 +0.0633490385102518 +0.09782081623495524 +0.10961779244559278 +0.10578196582495604 +0.09976767918014634 +0.08663901976536321 +0.08093594169543536 +0.06468795912311556 +0.05237712689348706 +0.04610229353482279 +0.03522446823139443 +0.02853710257579376 +0.02229121885200223 +0.020822024882211174 +0.015596615787683378 +0.011825925845510274 +0.009090185350037272 +0.007251883535618907 +0.005688603252491478 +0.005305020590427804 +0.0044510063616822635 +0.0032278842883094135 +0.0022363592939184055 +0.0020771363021183896 +0.0017948773621092704 +0.0017948773621092704 +0.0012882587518364924 +0.0012593091169637624 +0.0010856113077273813 +0.001186935029781937 +0.0010277120379819208 +0.0010711364902910162 +0.0009191509072091829 +0.0008902012723364526 +0.0007165034631000717 +0.0006803164195091589 +0.0006224171497636986 +0.000774402732845532 +0.0005428056538636907 +0.00042700711437276996 +0.000347395618472762 +0.00040529488821822233 +0.0002750215312909366 +0.0002460718964182064 +0.0001881726266727461 +0.00015198558308183337 +0.00019541003539092863 +0.00014474817436365084 +0.00013027335692728575 +0.00010132372205455558 +0.00018093521795456354 +0.00010856113077273813 +7.961149590000795e-05 +9.408631333637305e-05 +2.8949634872730166e-05 +7.237408718182542e-05 +0.00010132372205455558 +0.00011579853949092066 +7.961149590000795e-05 +0.00016646040051819847 diff --git a/notebooks/covid-model/requirements.txt b/notebooks/covid-model/requirements.txt new file mode 100644 index 000000000..f792e341d --- /dev/null +++ b/notebooks/covid-model/requirements.txt @@ -0,0 +1,11 @@ +pymc3 +pandas +jupyterlab +numpy +scipy +mkl +conda-build +mkl-service +boto3 +paramiko +s3fs diff --git a/notebooks/covid-model/rtlive-model-za.ipynb b/notebooks/covid-model/rtlive-model-za.ipynb new file mode 100644 index 000000000..f41042c9a --- /dev/null +++ b/notebooks/covid-model/rtlive-model-za.ipynb @@ -0,0 +1,2213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Rt Live Model\n", + "\n", + "Based on [Rt.live](https://Rt.live) model, original source code on [Github](https://github.com/rtcovidlive/covid-model).\n", + "\n", + "Adapted for South Africa - Schalk van Heerden 7 July 2020 - Review required" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import pymc3 as pm\n", + "import pandas as pd\n", + "import numpy as np\n", + "import arviz as az\n", + "from matplotlib import pyplot as plt\n", + "from covid.models.generative import GenerativeModel\n", + "from covid.data import summarize_inference_data\n", + "%config InlineBackend.figure_format = 'retina'\n", + "\n", + "from covid.data import get_and_process_covidtracking_data, summarize_inference_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "Change paramter to **False** when running on your own local machine, but do not commit this change! Leave as **True** for Github Action `rtlive-model.yaml` to run remotely." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "remote_run = False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Troubleshooting\n", + "\n", + "1. Ensure that all modules are installed with pip or conda from `requirments.txt`\n", + "1. How to solve Theano library warnings on some OS platforms: [SO](https://stackoverflow.com/questions/53423610/how-to-update-scan-cython-code-in-theano)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Baseline model with US data\n", + "\n", + "While testing, run US model first to baseline the latest model files. For the latest stable model, checkout commit from 2 July 2020." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fetch data and select the state's data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "df = get_and_process_covidtracking_data(run_date=pd.Timestamp.today()-pd.Timedelta(days=1))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "region = \"OR\"\n", + "model_data = df.loc[region]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + "
positivetotal
date
2020-07-02363.07694.0
2020-07-030.00.0
2020-07-04636.03972.0
2020-07-05300.09175.0
2020-07-06165.03520.0
\n", + "
" + ], + "text/plain": [ + " positive total\n", + "date \n", + "2020-07-02 363.0 7694.0\n", + "2020-07-03 0.0 0.0\n", + "2020-07-04 636.0 3972.0\n", + "2020-07-05 300.0 9175.0\n", + "2020-07-06 165.0 3520.0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_data.tail()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the model instance and sample" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Only 200 samples in chain.\n", + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [alpha, seed, log_r_t]\n", + "Sampling 4 chains, 0 divergences: 100%|██████████| 3600/3600 [10:02<00:00, 5.97draws/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gm = GenerativeModel(region, model_data)\n", + "gm.sample()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summarize Model Output" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 800/800 [00:01<00:00, 410.14it/s]\n" + ] + } + ], + "source": [ + "result = summarize_inference_data(gm.inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "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", + "
meanmedianlower_80upper_80infectionstest_adjusted_positivetest_adjusted_positive_rawpositivetests
date
2020-06-271.1437781.1401760.9187241.310589157.098828143.904406153.140198174.03296.0
2020-06-281.1446551.1376670.9168951.320284161.791209147.704632153.140198174.03296.0
2020-06-291.1466561.1479930.9210931.328614166.737075151.62298723.544370144.017742.0
2020-06-301.1442141.1408170.9201621.341416171.990481155.670378198.339666171.02501.0
2020-07-011.1473381.1410630.9267811.363498177.580927159.858748139.318410275.05726.0
2020-07-021.1477211.1442870.9094891.367381183.489902164.203551136.861597363.07694.0
2020-07-031.1456631.1412670.9259591.386021189.765565168.7201360.0000000.00.0
2020-07-041.1448711.1363850.9024191.363998196.468770173.420765464.488573636.03972.0
2020-07-051.1483021.1417330.8985421.379811203.558465178.32047394.851093300.09175.0
2020-07-061.1513221.1444290.8946501.383691211.047099183.439768135.977934165.03520.0
\n", + "
" + ], + "text/plain": [ + " mean median lower_80 upper_80 infections \\\n", + "date \n", + "2020-06-27 1.143778 1.140176 0.918724 1.310589 157.098828 \n", + "2020-06-28 1.144655 1.137667 0.916895 1.320284 161.791209 \n", + "2020-06-29 1.146656 1.147993 0.921093 1.328614 166.737075 \n", + "2020-06-30 1.144214 1.140817 0.920162 1.341416 171.990481 \n", + "2020-07-01 1.147338 1.141063 0.926781 1.363498 177.580927 \n", + "2020-07-02 1.147721 1.144287 0.909489 1.367381 183.489902 \n", + "2020-07-03 1.145663 1.141267 0.925959 1.386021 189.765565 \n", + "2020-07-04 1.144871 1.136385 0.902419 1.363998 196.468770 \n", + "2020-07-05 1.148302 1.141733 0.898542 1.379811 203.558465 \n", + "2020-07-06 1.151322 1.144429 0.894650 1.383691 211.047099 \n", + "\n", + " test_adjusted_positive test_adjusted_positive_raw positive \\\n", + "date \n", + "2020-06-27 143.904406 153.140198 174.0 \n", + "2020-06-28 147.704632 153.140198 174.0 \n", + "2020-06-29 151.622987 23.544370 144.0 \n", + "2020-06-30 155.670378 198.339666 171.0 \n", + "2020-07-01 159.858748 139.318410 275.0 \n", + "2020-07-02 164.203551 136.861597 363.0 \n", + "2020-07-03 168.720136 0.000000 0.0 \n", + "2020-07-04 173.420765 464.488573 636.0 \n", + "2020-07-05 178.320473 94.851093 300.0 \n", + "2020-07-06 183.439768 135.977934 165.0 \n", + "\n", + " tests \n", + "date \n", + "2020-06-27 3296.0 \n", + "2020-06-28 3296.0 \n", + "2020-06-29 17742.0 \n", + "2020-06-30 2501.0 \n", + "2020-07-01 5726.0 \n", + "2020-07-02 7694.0 \n", + "2020-07-03 0.0 \n", + "2020-07-04 3972.0 \n", + "2020-07-05 9175.0 \n", + "2020-07-06 3520.0 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.tail(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Model Output" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 327, + "width": 598 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_results():\n", + " fig, ax = plt.subplots(figsize=(10,5))\n", + " result.test_adjusted_positive.plot(c=\"g\", label=\"Test-adjusted\")\n", + " result.test_adjusted_positive_raw.plot(c=\"g\", alpha=.5, label=\"Test-adjusted (raw)\", style=\"--\")\n", + " result.infections.plot(c=\"b\", label=\"Infections\")\n", + " gm.observed.positive.plot(c='r', alpha=.7, label=\"Reported Positives\")\n", + " fig.set_facecolor('w')\n", + " ax.legend();\n", + " \n", + "plot_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 343, + "width": 601 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_rt():\n", + " fig, ax = plt.subplots(figsize=(10,5))\n", + "\n", + " ax.set_title(f\"{region} $R_t$\")\n", + " samples = gm.trace['r_t']\n", + " x=result.index\n", + " cmap = plt.get_cmap(\"Reds\")\n", + " percs = np.linspace(51, 99, 40)\n", + " colors = (percs - np.min(percs)) / (np.max(percs) - np.min(percs))\n", + " samples = samples.T\n", + "\n", + " result[\"median\"].plot(c=\"k\", ls='-')\n", + "\n", + " for i, p in enumerate(percs[::-1]):\n", + " upper = np.percentile(samples, p, axis=1)\n", + " lower = np.percentile(samples, 100-p, axis=1)\n", + " color_val = colors[i]\n", + " ax.fill_between(x, upper, lower, color=cmap(color_val), alpha=.8)\n", + "\n", + " ax.axhline(1.0, c=\"k\", lw=1, linestyle=\"--\")\n", + " fig.set_facecolor('w')\n", + " \n", + "plot_rt()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# South African Results" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "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", + "
YYYYMMDDECFSGPKZNLPMPNCNWWCUNKNOWNtotalsource
date
2020-07-022020070230603.01886.049937.011669.01286.01478.0573.04788.065841.00.0168061https://twitter.com/DrZweliMkhize/status/12787...
2020-07-032020070332157.02130.054331.012757.01408.01611.0626.05168.066936.00.0177124https://twitter.com/nicd_sa/status/12791261637...
2020-07-042020070434161.02376.059373.013984.01559.01818.0686.05644.068376.00.0187977https://twitter.com/nicd_sa/status/12795389507...
2020-07-052020070535648.02553.063404.015146.01706.01965.0734.06063.069531.00.0196750https://twitter.com/nicd_sa/status/12798466117...
2020-07-062020070638081.02804.066891.015819.01785.02173.0820.06410.070938.00.0205721https://twitter.com/COVID_19_ZA/status/1280252...
\n", + "
" + ], + "text/plain": [ + " YYYYMMDD EC FS GP KZN LP MP \\\n", + "date \n", + "2020-07-02 20200702 30603.0 1886.0 49937.0 11669.0 1286.0 1478.0 \n", + "2020-07-03 20200703 32157.0 2130.0 54331.0 12757.0 1408.0 1611.0 \n", + "2020-07-04 20200704 34161.0 2376.0 59373.0 13984.0 1559.0 1818.0 \n", + "2020-07-05 20200705 35648.0 2553.0 63404.0 15146.0 1706.0 1965.0 \n", + "2020-07-06 20200706 38081.0 2804.0 66891.0 15819.0 1785.0 2173.0 \n", + "\n", + " NC NW WC UNKNOWN total \\\n", + "date \n", + "2020-07-02 573.0 4788.0 65841.0 0.0 168061 \n", + "2020-07-03 626.0 5168.0 66936.0 0.0 177124 \n", + "2020-07-04 686.0 5644.0 68376.0 0.0 187977 \n", + "2020-07-05 734.0 6063.0 69531.0 0.0 196750 \n", + "2020-07-06 820.0 6410.0 70938.0 0.0 205721 \n", + "\n", + " source \n", + "date \n", + "2020-07-02 https://twitter.com/DrZweliMkhize/status/12787... \n", + "2020-07-03 https://twitter.com/nicd_sa/status/12791261637... \n", + "2020-07-04 https://twitter.com/nicd_sa/status/12795389507... \n", + "2020-07-05 https://twitter.com/nicd_sa/status/12798466117... \n", + "2020-07-06 https://twitter.com/COVID_19_ZA/status/1280252... " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "url = 'https://raw.githubusercontent.com/dsfsi/covid19za/master/data/covid19za_provincial_cumulative_timeline_confirmed.csv'\n", + "states_cases = pd.read_csv(url, parse_dates=['date'], dayfirst=True, index_col=0)\n", + "states_cases.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + "
YYYYMMDDcumulative_testsrecoveredhospitalisationcritical_icuventilationdeathscontacts_identifiedcontacts_tracedscanned_travellerspassengers_elevated_temperaturecovid_suspected_criteriasource
date
2020-07-02202007021706127.081999NaNNaNNaN2844NaNNaNNaNNaNNaNhttps://sacoronavirus.co.za/2020/07/02/update-...
2020-07-03202007031745153.086298NaNNaNNaN2952NaNNaNNaNNaNNaNhttps://sacoronavirus.co.za/2020/07/03/update-...
2020-07-04202007041792078.091227NaNNaNNaN3026NaNNaNNaNNaNNaNhttps://sacoronavirus.co.za/2020/07/04/update-...
2020-07-05202007051830161.093315NaNNaNNaN3199NaNNaNNaNNaNNaNhttps://sacoronavirus.co.za/2020/07/05/update-...
2020-07-06202007061864111.097848NaNNaNNaN3310NaNNaNNaNNaNNaNhttps://sacoronavirus.co.za/2020/07/06/update-...
\n", + "
" + ], + "text/plain": [ + " YYYYMMDD cumulative_tests recovered hospitalisation \\\n", + "date \n", + "2020-07-02 20200702 1706127.0 81999 NaN \n", + "2020-07-03 20200703 1745153.0 86298 NaN \n", + "2020-07-04 20200704 1792078.0 91227 NaN \n", + "2020-07-05 20200705 1830161.0 93315 NaN \n", + "2020-07-06 20200706 1864111.0 97848 NaN \n", + "\n", + " critical_icu ventilation deaths contacts_identified \\\n", + "date \n", + "2020-07-02 NaN NaN 2844 NaN \n", + "2020-07-03 NaN NaN 2952 NaN \n", + "2020-07-04 NaN NaN 3026 NaN \n", + "2020-07-05 NaN NaN 3199 NaN \n", + "2020-07-06 NaN NaN 3310 NaN \n", + "\n", + " contacts_traced scanned_travellers \\\n", + "date \n", + "2020-07-02 NaN NaN \n", + "2020-07-03 NaN NaN \n", + "2020-07-04 NaN NaN \n", + "2020-07-05 NaN NaN \n", + "2020-07-06 NaN NaN \n", + "\n", + " passengers_elevated_temperature covid_suspected_criteria \\\n", + "date \n", + "2020-07-02 NaN NaN \n", + "2020-07-03 NaN NaN \n", + "2020-07-04 NaN NaN \n", + "2020-07-05 NaN NaN \n", + "2020-07-06 NaN NaN \n", + "\n", + " source \n", + "date \n", + "2020-07-02 https://sacoronavirus.co.za/2020/07/02/update-... \n", + "2020-07-03 https://sacoronavirus.co.za/2020/07/03/update-... \n", + "2020-07-04 https://sacoronavirus.co.za/2020/07/04/update-... \n", + "2020-07-05 https://sacoronavirus.co.za/2020/07/05/update-... \n", + "2020-07-06 https://sacoronavirus.co.za/2020/07/06/update-... " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#url = 'https://raw.githubusercontent.com/dsfsi/covid19za/master/data/covid19za_provincial_cumulative_timeline_testing.csv'\n", + "url = 'https://raw.githubusercontent.com/dsfsi/covid19za/master/data/covid19za_timeline_testing.csv'\n", + "states_tests = pd.read_csv(url, parse_dates=['date'], dayfirst=True, index_col=0)\n", + "states_tests.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date\n", + "2020-03-05 1\n", + "2020-03-07 2\n", + "2020-03-08 3\n", + "2020-03-09 7\n", + "2020-03-11 13\n", + " ... \n", + "2020-07-02 168061\n", + "2020-07-03 177124\n", + "2020-07-04 187977\n", + "2020-07-05 196750\n", + "2020-07-06 205721\n", + "Name: cases, Length: 122, dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cases = pd.Series(states_cases['total'], index=states_cases.index, name='cases')\n", + "cases" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Timestamp('2020-03-05 00:00:00'), Timestamp('2020-07-06 00:00:00'))" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "casezero = states_cases.index[0]\n", + "caselast = states_cases.index[-1]\n", + "casezero, caselast" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "idx = pd.date_range(casezero, caselast)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date\n", + "2020-02-11 61.0\n", + "2020-02-13 67.0\n", + "2020-02-14 71.0\n", + "2020-02-19 95.0\n", + "2020-02-20 106.0\n", + " ... \n", + "2020-07-02 1706127.0\n", + "2020-07-03 1745153.0\n", + "2020-07-04 1792078.0\n", + "2020-07-05 1830161.0\n", + "2020-07-06 1864111.0\n", + "Name: tests, Length: 129, dtype: float64" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tests_all = pd.Series(states_tests['cumulative_tests'], index=states_tests.index, name='tests')\n", + "tests_all" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "date\n", + "2020-03-06 200.0\n", + "2020-03-07 241.0\n", + "2020-03-11 645.0\n", + "2020-03-12 848.0\n", + "2020-03-13 924.0\n", + " ... \n", + "2020-07-02 1706127.0\n", + "2020-07-03 1745153.0\n", + "2020-07-04 1792078.0\n", + "2020-07-05 1830161.0\n", + "2020-07-06 1864111.0\n", + "Name: tests, Length: 120, dtype: float64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tests = tests_all.loc[casezero:caselast]\n", + "tests" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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", + "
casestests
date
2020-03-051.0NaN
2020-03-06NaN200.0
2020-03-072.0241.0
2020-03-083.0NaN
2020-03-097.0NaN
.........
2020-07-02168061.01706127.0
2020-07-03177124.01745153.0
2020-07-04187977.01792078.0
2020-07-05196750.01830161.0
2020-07-06205721.01864111.0
\n", + "

123 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " cases tests\n", + "date \n", + "2020-03-05 1.0 NaN\n", + "2020-03-06 NaN 200.0\n", + "2020-03-07 2.0 241.0\n", + "2020-03-08 3.0 NaN\n", + "2020-03-09 7.0 NaN\n", + "... ... ...\n", + "2020-07-02 168061.0 1706127.0\n", + "2020-07-03 177124.0 1745153.0\n", + "2020-07-04 187977.0 1792078.0\n", + "2020-07-05 196750.0 1830161.0\n", + "2020-07-06 205721.0 1864111.0\n", + "\n", + "[123 rows x 2 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined_model = pd.concat([cases, tests], axis=1)\n", + "combined_model" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Assume previous day testing result for missing data point\n", + "combined_model.loc[casezero,'tests'] = 163" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "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", + "
casestests
2020-03-051.0163.0
2020-03-06NaN200.0
2020-03-072.0241.0
2020-03-083.0NaN
2020-03-097.0NaN
.........
2020-07-02168061.01706127.0
2020-07-03177124.01745153.0
2020-07-04187977.01792078.0
2020-07-05196750.01830161.0
2020-07-06205721.01864111.0
\n", + "

124 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " cases tests\n", + "2020-03-05 1.0 163.0\n", + "2020-03-06 NaN 200.0\n", + "2020-03-07 2.0 241.0\n", + "2020-03-08 3.0 NaN\n", + "2020-03-09 7.0 NaN\n", + "... ... ...\n", + "2020-07-02 168061.0 1706127.0\n", + "2020-07-03 177124.0 1745153.0\n", + "2020-07-04 187977.0 1792078.0\n", + "2020-07-05 196750.0 1830161.0\n", + "2020-07-06 205721.0 1864111.0\n", + "\n", + "[124 rows x 2 columns]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Reindex complete date range\n", + "filled_model = combined_model.reindex(idx, method='ffill')\n", + "filled_model" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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", + "
casestests
2020-03-051.0163.0
2020-03-061.0200.0
2020-03-072.0241.0
2020-03-083.0241.0
2020-03-097.0241.0
.........
2020-07-02168061.01706127.0
2020-07-03177124.01745153.0
2020-07-04187977.01792078.0
2020-07-05196750.01830161.0
2020-07-06205721.01864111.0
\n", + "

124 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " cases tests\n", + "2020-03-05 1.0 163.0\n", + "2020-03-06 1.0 200.0\n", + "2020-03-07 2.0 241.0\n", + "2020-03-08 3.0 241.0\n", + "2020-03-09 7.0 241.0\n", + "... ... ...\n", + "2020-07-02 168061.0 1706127.0\n", + "2020-07-03 177124.0 1745153.0\n", + "2020-07-04 187977.0 1792078.0\n", + "2020-07-05 196750.0 1830161.0\n", + "2020-07-06 205721.0 1864111.0\n", + "\n", + "[124 rows x 2 columns]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Do a final clean up, assume previous day results for missing data points\n", + "final_filled_model = filled_model.ffill(axis=0)\n", + "final_filled_model" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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", + "
casestestspositivetotal
2020-03-051.0163.0NaNNaN
2020-03-061.0200.00.037.0
2020-03-072.0241.01.041.0
2020-03-083.0241.01.00.0
2020-03-097.0241.04.00.0
...............
2020-07-02168061.01706127.08728.039188.0
2020-07-03177124.01745153.09063.039026.0
2020-07-04187977.01792078.010853.046925.0
2020-07-05196750.01830161.08773.038083.0
2020-07-06205721.01864111.08971.033950.0
\n", + "

124 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " cases tests positive total\n", + "2020-03-05 1.0 163.0 NaN NaN\n", + "2020-03-06 1.0 200.0 0.0 37.0\n", + "2020-03-07 2.0 241.0 1.0 41.0\n", + "2020-03-08 3.0 241.0 1.0 0.0\n", + "2020-03-09 7.0 241.0 4.0 0.0\n", + "... ... ... ... ...\n", + "2020-07-02 168061.0 1706127.0 8728.0 39188.0\n", + "2020-07-03 177124.0 1745153.0 9063.0 39026.0\n", + "2020-07-04 187977.0 1792078.0 10853.0 46925.0\n", + "2020-07-05 196750.0 1830161.0 8773.0 38083.0\n", + "2020-07-06 205721.0 1864111.0 8971.0 33950.0\n", + "\n", + "[124 rows x 4 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_filled_model['positive'] = final_filled_model['cases'].diff()\n", + "final_filled_model['total'] = final_filled_model['tests'].diff()\n", + "final_filled_model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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", + "
casestestspositivetotal
2020-03-061.0200.00.037.0
2020-03-072.0241.01.041.0
2020-03-083.0241.01.00.0
2020-03-097.0241.04.00.0
2020-03-107.0241.00.00.0
...............
2020-07-01159333.01666939.08124.036931.0
2020-07-02168061.01706127.08728.039188.0
2020-07-03177124.01745153.09063.039026.0
2020-07-04187977.01792078.010853.046925.0
2020-07-05196750.01830161.08773.038083.0
\n", + "

122 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " cases tests positive total\n", + "2020-03-06 1.0 200.0 0.0 37.0\n", + "2020-03-07 2.0 241.0 1.0 41.0\n", + "2020-03-08 3.0 241.0 1.0 0.0\n", + "2020-03-09 7.0 241.0 4.0 0.0\n", + "2020-03-10 7.0 241.0 0.0 0.0\n", + "... ... ... ... ...\n", + "2020-07-01 159333.0 1666939.0 8124.0 36931.0\n", + "2020-07-02 168061.0 1706127.0 8728.0 39188.0\n", + "2020-07-03 177124.0 1745153.0 9063.0 39026.0\n", + "2020-07-04 187977.0 1792078.0 10853.0 46925.0\n", + "2020-07-05 196750.0 1830161.0 8773.0 38083.0\n", + "\n", + "[122 rows x 4 columns]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_model = final_filled_model.iloc[1:-1]\n", + "df_model" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "region = 'Total RSA'" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Only 200 samples in chain.\n", + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [alpha, seed, log_r_t]\n", + "Sampling 4 chains, 0 divergences: 100%|██████████| 3600/3600 [09:37<00:00, 6.23draws/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gm = GenerativeModel(region, df_model)\n", + "gm.sample()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 800/800 [00:02<00:00, 390.07it/s]\n" + ] + } + ], + "source": [ + "result = summarize_inference_data(gm.inference_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "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", + "
meanmedianlower_80upper_80infectionstest_adjusted_positivetest_adjusted_positive_rawpositivetests
date
2020-06-261.1992871.1852380.9734681.3507494773.5761324679.6731294954.2141106215.033092.0
2020-06-271.1986501.1867290.9835861.3790024960.9614094849.1770635297.0855647210.035905.0
2020-06-281.2007271.1844180.9765381.3864435159.9109725025.2794284388.2847606334.038075.0
2020-06-291.1990521.1878430.9566441.3878525370.1059095208.2836175406.1264076130.029911.0
2020-06-301.1998291.1842050.9594941.3929485593.3009725398.7366825549.3729486945.033013.0
2020-07-011.1988611.1764560.9646161.4056065830.3762155597.2941125802.7719348124.036931.0
2020-07-021.1988351.1815290.9429211.3935706082.0406155804.5592135875.1409858728.039188.0
2020-07-031.2012491.1899430.9602711.4300906348.9391356021.2647086125.9661739063.039026.0
2020-07-041.2037191.1904600.9493511.4395646632.2127866248.3185836101.01617310853.046925.0
2020-07-051.2039151.1952530.9427481.4474446935.9476236486.6570006076.7816448773.038083.0
\n", + "
" + ], + "text/plain": [ + " mean median lower_80 upper_80 infections \\\n", + "date \n", + "2020-06-26 1.199287 1.185238 0.973468 1.350749 4773.576132 \n", + "2020-06-27 1.198650 1.186729 0.983586 1.379002 4960.961409 \n", + "2020-06-28 1.200727 1.184418 0.976538 1.386443 5159.910972 \n", + "2020-06-29 1.199052 1.187843 0.956644 1.387852 5370.105909 \n", + "2020-06-30 1.199829 1.184205 0.959494 1.392948 5593.300972 \n", + "2020-07-01 1.198861 1.176456 0.964616 1.405606 5830.376215 \n", + "2020-07-02 1.198835 1.181529 0.942921 1.393570 6082.040615 \n", + "2020-07-03 1.201249 1.189943 0.960271 1.430090 6348.939135 \n", + "2020-07-04 1.203719 1.190460 0.949351 1.439564 6632.212786 \n", + "2020-07-05 1.203915 1.195253 0.942748 1.447444 6935.947623 \n", + "\n", + " test_adjusted_positive test_adjusted_positive_raw positive \\\n", + "date \n", + "2020-06-26 4679.673129 4954.214110 6215.0 \n", + "2020-06-27 4849.177063 5297.085564 7210.0 \n", + "2020-06-28 5025.279428 4388.284760 6334.0 \n", + "2020-06-29 5208.283617 5406.126407 6130.0 \n", + "2020-06-30 5398.736682 5549.372948 6945.0 \n", + "2020-07-01 5597.294112 5802.771934 8124.0 \n", + "2020-07-02 5804.559213 5875.140985 8728.0 \n", + "2020-07-03 6021.264708 6125.966173 9063.0 \n", + "2020-07-04 6248.318583 6101.016173 10853.0 \n", + "2020-07-05 6486.657000 6076.781644 8773.0 \n", + "\n", + " tests \n", + "date \n", + "2020-06-26 33092.0 \n", + "2020-06-27 35905.0 \n", + "2020-06-28 38075.0 \n", + "2020-06-29 29911.0 \n", + "2020-06-30 33013.0 \n", + "2020-07-01 36931.0 \n", + "2020-07-02 39188.0 \n", + "2020-07-03 39026.0 \n", + "2020-07-04 46925.0 \n", + "2020-07-05 38083.0 " + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.tail(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 327, + "width": 611 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_results()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 343, + "width": 595 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_rt()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "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", + "
MedianHigh_80Low_80
date
2020-07-011.1764561.4056060.964616
2020-07-021.1815291.3935700.942921
2020-07-031.1899431.4300900.960271
2020-07-041.1904601.4395640.949351
2020-07-051.1952531.4474440.942748
\n", + "
" + ], + "text/plain": [ + " Median High_80 Low_80\n", + "date \n", + "2020-07-01 1.176456 1.405606 0.964616\n", + "2020-07-02 1.181529 1.393570 0.942921\n", + "2020-07-03 1.189943 1.430090 0.960271\n", + "2020-07-04 1.190460 1.439564 0.949351\n", + "2020-07-05 1.195253 1.447444 0.942748" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "export_results = result[['median','upper_80','lower_80']]\n", + "export_results = export_results.rename(columns={'median':'Median','upper_80':'High_80','lower_80':'Low_80'})\n", + "export_results.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "if remote_run:\n", + " # Used by GitHub Action, TODO complete the action!\n", + " # The path needs to be linked directly, TODO find out why relative path does not work\n", + " # Action instance path /home/runner/work/covid19za/covid19za\n", + " export_results.to_csv('data/calc/calculated_rt_sa_mcmc.csv', float_format='%.3f')\n", + "\n", + "else:\n", + " export_results.to_csv('../../data/calc/calculated_rt_sa_mcmc.csv', float_format='%.3f')" + ] + }, + { + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From ed260cdce6b4c2cbaf70e44147d72867aa1e4928 Mon Sep 17 00:00:00 2001 From: heerden Date: Tue, 7 Jul 2020 21:30:31 +0000 Subject: [PATCH 2/2] RT action run --- .../calculated_rt_gp_district_cumulative.csv | 525 +++++++++--------- ...calculated_rt_sa_provincial_cumulative.csv | 70 ++- 2 files changed, 310 insertions(+), 285 deletions(-) diff --git a/data/calc/calculated_rt_gp_district_cumulative.csv b/data/calc/calculated_rt_gp_district_cumulative.csv index 51281efc1..2ada42450 100644 --- a/data/calc/calculated_rt_gp_district_cumulative.csv +++ b/data/calc/calculated_rt_gp_district_cumulative.csv @@ -1,264 +1,279 @@ state,date,ML,High_90,Low_90 Ekurhuleni,2020-05-16,1.67,4.34,0.00 -Ekurhuleni,2020-05-17,1.33,3.25,0.00 -Ekurhuleni,2020-05-18,1.22,2.79,0.00 -Ekurhuleni,2020-05-19,1.00,2.40,0.00 +Ekurhuleni,2020-05-17,1.32,3.25,0.00 +Ekurhuleni,2020-05-18,1.21,2.79,0.00 +Ekurhuleni,2020-05-19,1.00,2.41,0.00 Ekurhuleni,2020-05-20,1.00,2.26,0.00 -Ekurhuleni,2020-05-21,1.11,2.24,0.01 -Ekurhuleni,2020-05-22,1.37,2.46,0.14 -Ekurhuleni,2020-05-23,1.46,2.52,0.28 -Ekurhuleni,2020-05-24,1.58,2.57,0.44 -Ekurhuleni,2020-05-25,1.60,2.55,0.57 -Ekurhuleni,2020-05-26,1.56,2.43,0.58 -Ekurhuleni,2020-05-27,1.61,2.43,0.70 -Ekurhuleni,2020-05-28,1.67,2.41,0.79 -Ekurhuleni,2020-05-29,1.73,2.46,0.96 -Ekurhuleni,2020-05-30,1.74,2.41,1.01 -Ekurhuleni,2020-05-31,1.69,2.30,0.98 -Ekurhuleni,2020-06-01,1.62,2.20,0.95 -Ekurhuleni,2020-06-02,1.61,2.17,0.99 -Ekurhuleni,2020-06-03,1.62,2.16,1.04 -Ekurhuleni,2020-06-04,1.65,2.14,1.07 -Ekurhuleni,2020-06-05,1.64,2.11,1.09 -Ekurhuleni,2020-06-06,1.59,2.05,1.08 -Ekurhuleni,2020-06-07,1.53,1.98,1.05 -Ekurhuleni,2020-06-08,1.53,1.95,1.05 -Ekurhuleni,2020-06-09,1.61,2.02,1.16 -Ekurhuleni,2020-06-10,1.79,2.17,1.35 -Ekurhuleni,2020-06-11,1.98,2.34,1.57 -Ekurhuleni,2020-06-12,2.08,2.41,1.69 -Ekurhuleni,2020-06-13,2.04,2.35,1.68 -Ekurhuleni,2020-06-14,1.98,2.27,1.64 -Ekurhuleni,2020-06-15,1.87,2.14,1.54 -Ekurhuleni,2020-06-16,1.79,2.05,1.48 -Ekurhuleni,2020-06-17,1.73,1.97,1.42 -Ekurhuleni,2020-06-18,1.68,1.92,1.39 -Ekurhuleni,2020-06-19,1.65,1.89,1.38 -Ekurhuleni,2020-06-20,1.62,1.85,1.35 -Ekurhuleni,2020-06-21,1.60,1.82,1.34 -Ekurhuleni,2020-06-22,1.62,1.83,1.36 -Ekurhuleni,2020-06-23,1.65,1.86,1.40 -Ekurhuleni,2020-06-24,1.69,1.90,1.46 -Ekurhuleni,2020-06-25,1.70,1.89,1.46 -Ekurhuleni,2020-06-26,1.67,1.86,1.44 -Ekurhuleni,2020-06-27,1.63,1.82,1.42 -Ekurhuleni,2020-06-28,1.56,1.74,1.35 -Ekurhuleni,2020-06-29,1.53,1.69,1.30 -Ekurhuleni,2020-06-30,1.53,1.69,1.31 -Ekurhuleni,2020-07-01,1.52,1.69,1.32 -Ekurhuleni,2020-07-02,1.51,1.68,1.32 -Ekurhuleni,2020-07-03,1.50,1.65,1.29 -Johannesburg,2020-04-11,0.08,2.35,0.00 -Johannesburg,2020-04-12,0.65,1.90,0.00 -Johannesburg,2020-04-13,0.60,1.64,0.00 -Johannesburg,2020-04-15,0.70,1.58,0.00 -Johannesburg,2020-04-16,0.81,1.57,0.00 -Johannesburg,2020-04-17,0.84,1.55,0.03 -Johannesburg,2020-04-18,0.86,1.53,0.05 -Johannesburg,2020-04-19,0.85,1.48,0.06 -Johannesburg,2020-04-20,0.75,1.35,0.04 -Johannesburg,2020-04-21,0.66,1.23,0.01 -Johannesburg,2020-04-22,0.60,1.16,0.00 -Johannesburg,2020-04-23,0.60,1.15,0.00 -Johannesburg,2020-04-24,0.62,1.15,0.00 -Johannesburg,2020-04-25,0.62,1.14,0.00 -Johannesburg,2020-04-26,0.63,1.15,0.01 -Johannesburg,2020-04-27,0.63,1.13,0.00 -Johannesburg,2020-04-28,0.66,1.17,0.02 -Johannesburg,2020-04-29,0.76,1.28,0.08 -Johannesburg,2020-04-30,0.83,1.37,0.16 -Johannesburg,2020-05-01,0.90,1.44,0.24 -Johannesburg,2020-05-02,0.94,1.50,0.33 -Johannesburg,2020-05-03,0.91,1.44,0.29 -Johannesburg,2020-05-04,0.88,1.40,0.27 -Johannesburg,2020-05-05,0.85,1.38,0.27 -Johannesburg,2020-05-06,0.84,1.36,0.26 -Johannesburg,2020-05-07,0.88,1.39,0.30 -Johannesburg,2020-05-08,0.89,1.39,0.31 -Johannesburg,2020-05-09,0.89,1.39,0.32 -Johannesburg,2020-05-10,0.88,1.37,0.31 -Johannesburg,2020-05-11,0.87,1.36,0.31 -Johannesburg,2020-05-12,0.89,1.39,0.35 -Johannesburg,2020-05-13,0.90,1.37,0.33 -Johannesburg,2020-05-14,0.91,1.39,0.36 -Johannesburg,2020-05-15,0.94,1.41,0.39 -Johannesburg,2020-05-16,0.92,1.39,0.38 -Johannesburg,2020-05-17,0.90,1.39,0.39 -Johannesburg,2020-05-18,0.90,1.37,0.37 -Johannesburg,2020-05-19,0.94,1.42,0.43 -Johannesburg,2020-05-20,0.99,1.44,0.45 -Johannesburg,2020-05-21,1.04,1.51,0.54 -Johannesburg,2020-05-22,1.10,1.55,0.59 -Johannesburg,2020-05-23,1.13,1.58,0.64 -Johannesburg,2020-05-24,1.13,1.56,0.63 -Johannesburg,2020-05-25,1.14,1.57,0.66 -Johannesburg,2020-05-26,1.18,1.59,0.69 -Johannesburg,2020-05-27,1.26,1.66,0.78 -Johannesburg,2020-05-28,1.35,1.73,0.87 -Johannesburg,2020-05-29,1.43,1.82,0.99 -Johannesburg,2020-05-30,1.47,1.84,1.04 -Johannesburg,2020-05-31,1.48,1.86,1.09 -Johannesburg,2020-06-01,1.48,1.83,1.08 -Johannesburg,2020-06-02,1.52,1.86,1.14 -Johannesburg,2020-06-03,1.59,1.91,1.21 -Johannesburg,2020-06-04,1.63,1.94,1.27 -Johannesburg,2020-06-05,1.62,1.91,1.26 -Johannesburg,2020-06-06,1.57,1.87,1.25 -Johannesburg,2020-06-07,1.55,1.84,1.24 -Johannesburg,2020-06-08,1.58,1.86,1.28 -Johannesburg,2020-06-09,1.66,1.91,1.34 -Johannesburg,2020-06-10,1.79,2.05,1.51 -Johannesburg,2020-06-11,1.94,2.19,1.68 -Johannesburg,2020-06-12,1.99,2.21,1.72 -Johannesburg,2020-06-13,1.95,2.16,1.70 -Johannesburg,2020-06-14,1.86,2.06,1.62 -Johannesburg,2020-06-15,1.77,1.96,1.54 -Johannesburg,2020-06-16,1.68,1.87,1.46 -Johannesburg,2020-06-17,1.62,1.79,1.39 -Johannesburg,2020-06-18,1.60,1.78,1.39 -Johannesburg,2020-06-19,1.59,1.76,1.38 -Johannesburg,2020-06-20,1.57,1.74,1.37 -Johannesburg,2020-06-21,1.52,1.70,1.34 -Johannesburg,2020-06-22,1.52,1.68,1.32 -Johannesburg,2020-06-23,1.52,1.68,1.33 -Johannesburg,2020-06-24,1.54,1.70,1.36 -Johannesburg,2020-06-25,1.54,1.70,1.37 -Johannesburg,2020-06-26,1.56,1.70,1.37 -Johannesburg,2020-06-27,1.52,1.67,1.35 -Johannesburg,2020-06-28,1.48,1.62,1.31 -Johannesburg,2020-06-29,1.44,1.57,1.26 -Johannesburg,2020-06-30,1.45,1.59,1.29 -Johannesburg,2020-07-01,1.43,1.56,1.26 -Johannesburg,2020-07-02,1.42,1.56,1.27 -Johannesburg,2020-07-03,1.40,1.53,1.24 -Sedibeng,2020-06-10,3.17,5.55,0.36 -Sedibeng,2020-06-11,3.28,5.02,1.21 -Sedibeng,2020-06-12,3.16,4.50,1.61 -Sedibeng,2020-06-13,2.87,3.95,1.61 -Sedibeng,2020-06-14,2.65,3.58,1.61 -Sedibeng,2020-06-15,2.44,3.22,1.50 -Sedibeng,2020-06-16,2.28,3.01,1.49 -Sedibeng,2020-06-17,2.10,2.75,1.37 -Sedibeng,2020-06-18,1.98,2.56,1.29 -Sedibeng,2020-06-19,1.86,2.41,1.23 -Sedibeng,2020-06-20,1.79,2.32,1.22 -Sedibeng,2020-06-21,1.69,2.18,1.14 -Sedibeng,2020-06-22,1.67,2.13,1.14 -Sedibeng,2020-06-23,1.69,2.13,1.19 -Sedibeng,2020-06-24,1.71,2.14,1.25 -Sedibeng,2020-06-25,1.74,2.13,1.28 -Sedibeng,2020-06-26,1.77,2.13,1.32 -Sedibeng,2020-06-27,1.76,2.11,1.34 -Sedibeng,2020-06-28,1.73,2.07,1.34 -Sedibeng,2020-06-29,1.67,2.00,1.30 -Sedibeng,2020-06-30,1.65,1.97,1.30 -Sedibeng,2020-07-01,1.62,1.91,1.26 -Sedibeng,2020-07-02,1.59,1.87,1.24 -Sedibeng,2020-07-03,1.57,1.85,1.24 +Ekurhuleni,2020-05-21,1.11,2.24,0.00 +Ekurhuleni,2020-05-22,1.37,2.43,0.09 +Ekurhuleni,2020-05-23,1.47,2.52,0.25 +Ekurhuleni,2020-05-24,1.59,2.64,0.47 +Ekurhuleni,2020-05-25,1.61,2.54,0.50 +Ekurhuleni,2020-05-26,1.57,2.45,0.54 +Ekurhuleni,2020-05-27,1.61,2.48,0.69 +Ekurhuleni,2020-05-28,1.68,2.48,0.80 +Ekurhuleni,2020-05-29,1.74,2.47,0.89 +Ekurhuleni,2020-05-30,1.75,2.44,0.96 +Ekurhuleni,2020-05-31,1.69,2.34,0.94 +Ekurhuleni,2020-06-01,1.62,2.26,0.93 +Ekurhuleni,2020-06-02,1.60,2.19,0.91 +Ekurhuleni,2020-06-03,1.62,2.19,0.96 +Ekurhuleni,2020-06-04,1.65,2.19,1.01 +Ekurhuleni,2020-06-05,1.64,2.17,1.04 +Ekurhuleni,2020-06-06,1.58,2.10,1.01 +Ekurhuleni,2020-06-07,1.50,2.00,0.94 +Ekurhuleni,2020-06-08,1.51,2.01,0.98 +Ekurhuleni,2020-06-09,1.61,2.07,1.06 +Ekurhuleni,2020-06-10,1.87,2.33,1.37 +Ekurhuleni,2020-06-11,2.11,2.53,1.62 +Ekurhuleni,2020-06-12,2.22,2.60,1.75 +Ekurhuleni,2020-06-13,2.13,2.50,1.71 +Ekurhuleni,2020-06-14,2.03,2.37,1.62 +Ekurhuleni,2020-06-15,1.86,2.20,1.49 +Ekurhuleni,2020-06-16,1.74,2.06,1.37 +Ekurhuleni,2020-06-17,1.66,1.98,1.31 +Ekurhuleni,2020-06-18,1.61,1.91,1.25 +Ekurhuleni,2020-06-19,1.58,1.87,1.22 +Ekurhuleni,2020-06-20,1.55,1.85,1.22 +Ekurhuleni,2020-06-21,1.52,1.81,1.19 +Ekurhuleni,2020-06-22,1.58,1.85,1.24 +Ekurhuleni,2020-06-23,1.65,1.92,1.33 +Ekurhuleni,2020-06-24,1.71,1.98,1.41 +Ekurhuleni,2020-06-25,1.72,1.98,1.43 +Ekurhuleni,2020-06-26,1.67,1.91,1.37 +Ekurhuleni,2020-06-27,1.60,1.84,1.32 +Ekurhuleni,2020-06-28,1.48,1.72,1.21 +Ekurhuleni,2020-06-29,1.46,1.69,1.19 +Ekurhuleni,2020-06-30,1.48,1.72,1.23 +Ekurhuleni,2020-07-01,1.58,1.81,1.33 +Ekurhuleni,2020-07-02,1.63,1.84,1.37 +Ekurhuleni,2020-07-03,1.57,1.79,1.34 +Ekurhuleni,2020-07-04,1.44,1.64,1.19 +Ekurhuleni,2020-07-05,1.30,1.50,1.06 +Ekurhuleni,2020-07-06,1.11,1.32,0.88 +Johannesburg,2020-04-11,0.17,2.35,0.00 +Johannesburg,2020-04-12,0.65,1.91,0.00 +Johannesburg,2020-04-13,0.59,1.64,0.00 +Johannesburg,2020-04-15,0.69,1.58,0.00 +Johannesburg,2020-04-16,0.81,1.59,0.01 +Johannesburg,2020-04-17,0.84,1.56,0.02 +Johannesburg,2020-04-18,0.86,1.55,0.05 +Johannesburg,2020-04-19,0.84,1.50,0.05 +Johannesburg,2020-04-20,0.73,1.35,0.01 +Johannesburg,2020-04-21,0.62,1.24,0.00 +Johannesburg,2020-04-22,0.55,1.18,0.00 +Johannesburg,2020-04-23,0.54,1.17,0.00 +Johannesburg,2020-04-24,0.57,1.19,0.00 +Johannesburg,2020-04-25,0.56,1.18,0.00 +Johannesburg,2020-04-26,0.58,1.19,0.00 +Johannesburg,2020-04-27,0.57,1.18,0.00 +Johannesburg,2020-04-28,0.62,1.23,0.01 +Johannesburg,2020-04-29,0.77,1.38,0.06 +Johannesburg,2020-04-30,0.87,1.47,0.09 +Johannesburg,2020-05-01,0.96,1.59,0.19 +Johannesburg,2020-05-02,1.02,1.65,0.26 +Johannesburg,2020-05-03,0.96,1.58,0.22 +Johannesburg,2020-05-04,0.92,1.51,0.17 +Johannesburg,2020-05-05,0.87,1.45,0.13 +Johannesburg,2020-05-06,0.86,1.43,0.12 +Johannesburg,2020-05-07,0.91,1.52,0.20 +Johannesburg,2020-05-08,0.92,1.51,0.19 +Johannesburg,2020-05-09,0.92,1.51,0.19 +Johannesburg,2020-05-10,0.90,1.49,0.18 +Johannesburg,2020-05-11,0.89,1.48,0.18 +Johannesburg,2020-05-12,0.92,1.51,0.20 +Johannesburg,2020-05-13,0.92,1.51,0.20 +Johannesburg,2020-05-14,0.95,1.55,0.24 +Johannesburg,2020-05-15,1.00,1.60,0.29 +Johannesburg,2020-05-16,0.95,1.55,0.25 +Johannesburg,2020-05-17,0.91,1.51,0.22 +Johannesburg,2020-05-18,0.91,1.49,0.19 +Johannesburg,2020-05-19,0.99,1.61,0.31 +Johannesburg,2020-05-20,1.07,1.68,0.38 +Johannesburg,2020-05-21,1.15,1.76,0.48 +Johannesburg,2020-05-22,1.24,1.82,0.56 +Johannesburg,2020-05-23,1.28,1.85,0.62 +Johannesburg,2020-05-24,1.27,1.84,0.64 +Johannesburg,2020-05-25,1.26,1.81,0.63 +Johannesburg,2020-05-26,1.32,1.85,0.69 +Johannesburg,2020-05-27,1.43,1.96,0.83 +Johannesburg,2020-05-28,1.55,2.07,0.98 +Johannesburg,2020-05-29,1.66,2.16,1.11 +Johannesburg,2020-05-30,1.68,2.14,1.13 +Johannesburg,2020-05-31,1.67,2.12,1.15 +Johannesburg,2020-06-01,1.64,2.09,1.16 +Johannesburg,2020-06-02,1.66,2.09,1.19 +Johannesburg,2020-06-03,1.75,2.15,1.28 +Johannesburg,2020-06-04,1.78,2.18,1.35 +Johannesburg,2020-06-05,1.74,2.12,1.32 +Johannesburg,2020-06-06,1.64,1.99,1.21 +Johannesburg,2020-06-07,1.59,1.94,1.18 +Johannesburg,2020-06-08,1.63,1.96,1.22 +Johannesburg,2020-06-09,1.75,2.09,1.38 +Johannesburg,2020-06-10,1.94,2.27,1.59 +Johannesburg,2020-06-11,2.13,2.42,1.77 +Johannesburg,2020-06-12,2.16,2.43,1.82 +Johannesburg,2020-06-13,2.04,2.31,1.74 +Johannesburg,2020-06-14,1.87,2.12,1.57 +Johannesburg,2020-06-15,1.72,1.97,1.44 +Johannesburg,2020-06-16,1.60,1.84,1.32 +Johannesburg,2020-06-17,1.51,1.75,1.24 +Johannesburg,2020-06-18,1.52,1.74,1.23 +Johannesburg,2020-06-19,1.52,1.74,1.24 +Johannesburg,2020-06-20,1.52,1.73,1.24 +Johannesburg,2020-06-21,1.46,1.67,1.19 +Johannesburg,2020-06-22,1.48,1.68,1.21 +Johannesburg,2020-06-23,1.49,1.69,1.23 +Johannesburg,2020-06-24,1.53,1.73,1.28 +Johannesburg,2020-06-25,1.54,1.73,1.29 +Johannesburg,2020-06-26,1.57,1.77,1.35 +Johannesburg,2020-06-27,1.51,1.70,1.29 +Johannesburg,2020-06-28,1.43,1.61,1.20 +Johannesburg,2020-06-29,1.39,1.57,1.17 +Johannesburg,2020-06-30,1.42,1.61,1.22 +Johannesburg,2020-07-01,1.50,1.68,1.30 +Johannesburg,2020-07-02,1.52,1.70,1.33 +Johannesburg,2020-07-03,1.43,1.59,1.22 +Johannesburg,2020-07-04,1.31,1.47,1.11 +Johannesburg,2020-07-05,1.15,1.31,0.95 +Johannesburg,2020-07-06,0.99,1.16,0.80 +Sedibeng,2020-06-10,3.17,5.56,0.37 +Sedibeng,2020-06-11,3.28,5.03,1.22 +Sedibeng,2020-06-12,3.16,4.54,1.65 +Sedibeng,2020-06-13,2.87,3.95,1.60 +Sedibeng,2020-06-14,2.64,3.56,1.57 +Sedibeng,2020-06-15,2.43,3.23,1.49 +Sedibeng,2020-06-16,2.26,3.01,1.46 +Sedibeng,2020-06-17,2.08,2.74,1.32 +Sedibeng,2020-06-18,1.95,2.55,1.23 +Sedibeng,2020-06-19,1.83,2.40,1.16 +Sedibeng,2020-06-20,1.75,2.31,1.14 +Sedibeng,2020-06-21,1.64,2.18,1.06 +Sedibeng,2020-06-22,1.62,2.14,1.06 +Sedibeng,2020-06-23,1.65,2.16,1.12 +Sedibeng,2020-06-24,1.69,2.15,1.14 +Sedibeng,2020-06-25,1.73,2.17,1.20 +Sedibeng,2020-06-26,1.77,2.20,1.27 +Sedibeng,2020-06-27,1.76,2.18,1.29 +Sedibeng,2020-06-28,1.71,2.11,1.25 +Sedibeng,2020-06-29,1.64,2.04,1.21 +Sedibeng,2020-06-30,1.61,1.99,1.18 +Sedibeng,2020-07-01,1.61,1.98,1.19 +Sedibeng,2020-07-02,1.58,1.94,1.17 +Sedibeng,2020-07-03,1.56,1.92,1.17 +Sedibeng,2020-07-04,1.52,1.85,1.11 +Sedibeng,2020-07-05,1.46,1.81,1.09 +Sedibeng,2020-07-06,1.39,1.73,1.02 Tshwane,2020-04-30,2.28,4.74,0.00 Tshwane,2020-05-01,1.61,3.41,0.00 Tshwane,2020-05-02,1.20,2.73,0.00 Tshwane,2020-05-03,1.15,2.49,0.00 Tshwane,2020-05-04,1.12,2.32,0.00 -Tshwane,2020-05-05,1.21,2.28,0.01 -Tshwane,2020-05-06,1.35,2.37,0.10 -Tshwane,2020-05-07,1.29,2.30,0.17 -Tshwane,2020-05-08,1.19,2.13,0.14 -Tshwane,2020-05-09,1.05,1.88,0.03 -Tshwane,2020-05-10,0.89,1.69,0.01 -Tshwane,2020-05-11,0.79,1.58,0.00 -Tshwane,2020-05-12,0.80,1.57,0.00 -Tshwane,2020-05-13,0.80,1.57,0.01 -Tshwane,2020-05-14,0.86,1.61,0.02 -Tshwane,2020-05-15,0.87,1.60,0.02 -Tshwane,2020-05-16,0.78,1.50,0.00 -Tshwane,2020-05-17,0.75,1.46,0.00 -Tshwane,2020-05-18,0.71,1.43,0.00 -Tshwane,2020-05-19,0.71,1.43,0.00 -Tshwane,2020-05-20,0.80,1.50,0.00 -Tshwane,2020-05-21,0.89,1.61,0.06 -Tshwane,2020-05-22,0.97,1.67,0.07 -Tshwane,2020-05-23,1.05,1.77,0.16 -Tshwane,2020-05-24,1.08,1.81,0.22 -Tshwane,2020-05-25,1.11,1.86,0.30 -Tshwane,2020-05-26,1.10,1.82,0.29 -Tshwane,2020-05-27,1.13,1.84,0.34 -Tshwane,2020-05-28,1.15,1.84,0.37 -Tshwane,2020-05-29,1.17,1.84,0.40 -Tshwane,2020-05-30,1.21,1.89,0.49 -Tshwane,2020-05-31,1.24,1.87,0.50 -Tshwane,2020-06-01,1.32,1.95,0.63 -Tshwane,2020-06-02,1.38,1.97,0.69 -Tshwane,2020-06-03,1.47,2.03,0.80 -Tshwane,2020-06-04,1.53,2.09,0.92 -Tshwane,2020-06-05,1.55,2.08,0.96 -Tshwane,2020-06-06,1.55,2.07,1.00 -Tshwane,2020-06-07,1.57,2.04,1.01 -Tshwane,2020-06-08,1.61,2.08,1.10 -Tshwane,2020-06-09,1.70,2.13,1.19 -Tshwane,2020-06-10,1.81,2.22,1.33 -Tshwane,2020-06-11,1.90,2.31,1.48 -Tshwane,2020-06-12,1.93,2.31,1.53 -Tshwane,2020-06-13,1.89,2.23,1.49 -Tshwane,2020-06-14,1.86,2.18,1.48 -Tshwane,2020-06-15,1.83,2.14,1.48 -Tshwane,2020-06-16,1.79,2.09,1.46 -Tshwane,2020-06-17,1.78,2.05,1.44 -Tshwane,2020-06-18,1.76,2.03,1.45 -Tshwane,2020-06-19,1.72,1.97,1.41 -Tshwane,2020-06-20,1.66,1.90,1.36 -Tshwane,2020-06-21,1.60,1.85,1.33 -Tshwane,2020-06-22,1.58,1.81,1.30 -Tshwane,2020-06-23,1.57,1.79,1.29 -Tshwane,2020-06-24,1.60,1.82,1.34 -Tshwane,2020-06-25,1.61,1.82,1.35 -Tshwane,2020-06-26,1.60,1.80,1.34 -Tshwane,2020-06-27,1.56,1.76,1.31 -Tshwane,2020-06-28,1.51,1.70,1.26 -Tshwane,2020-06-29,1.49,1.68,1.25 -Tshwane,2020-06-30,1.52,1.70,1.28 -Tshwane,2020-07-01,1.52,1.70,1.29 -Tshwane,2020-07-02,1.53,1.72,1.32 -Tshwane,2020-07-03,1.53,1.71,1.32 +Tshwane,2020-05-05,1.20,2.28,0.00 +Tshwane,2020-05-06,1.35,2.38,0.10 +Tshwane,2020-05-07,1.29,2.27,0.12 +Tshwane,2020-05-08,1.19,2.10,0.09 +Tshwane,2020-05-09,1.04,1.90,0.04 +Tshwane,2020-05-10,0.86,1.69,0.00 +Tshwane,2020-05-11,0.74,1.59,0.00 +Tshwane,2020-05-12,0.75,1.58,0.00 +Tshwane,2020-05-13,0.76,1.58,0.00 +Tshwane,2020-05-14,0.83,1.63,0.00 +Tshwane,2020-05-15,0.83,1.62,0.00 +Tshwane,2020-05-16,0.72,1.53,0.00 +Tshwane,2020-05-17,0.66,1.49,0.00 +Tshwane,2020-05-18,0.59,1.46,0.00 +Tshwane,2020-05-19,0.60,1.46,0.00 +Tshwane,2020-05-20,0.74,1.56,0.00 +Tshwane,2020-05-21,0.87,1.65,0.00 +Tshwane,2020-05-22,0.98,1.75,0.03 +Tshwane,2020-05-23,1.08,1.85,0.08 +Tshwane,2020-05-24,1.12,1.89,0.12 +Tshwane,2020-05-25,1.15,1.96,0.21 +Tshwane,2020-05-26,1.14,1.92,0.20 +Tshwane,2020-05-27,1.17,1.92,0.21 +Tshwane,2020-05-28,1.19,1.97,0.29 +Tshwane,2020-05-29,1.21,1.99,0.34 +Tshwane,2020-05-30,1.26,2.03,0.41 +Tshwane,2020-05-31,1.31,2.07,0.49 +Tshwane,2020-06-01,1.40,2.11,0.57 +Tshwane,2020-06-02,1.47,2.17,0.69 +Tshwane,2020-06-03,1.58,2.24,0.82 +Tshwane,2020-06-04,1.65,2.28,0.92 +Tshwane,2020-06-05,1.66,2.25,0.95 +Tshwane,2020-06-06,1.65,2.23,0.99 +Tshwane,2020-06-07,1.65,2.21,1.02 +Tshwane,2020-06-08,1.70,2.24,1.10 +Tshwane,2020-06-09,1.80,2.32,1.23 +Tshwane,2020-06-10,1.94,2.44,1.41 +Tshwane,2020-06-11,2.04,2.51,1.54 +Tshwane,2020-06-12,2.05,2.46,1.54 +Tshwane,2020-06-13,1.97,2.37,1.50 +Tshwane,2020-06-14,1.91,2.31,1.49 +Tshwane,2020-06-15,1.85,2.22,1.43 +Tshwane,2020-06-16,1.79,2.15,1.39 +Tshwane,2020-06-17,1.78,2.12,1.38 +Tshwane,2020-06-18,1.76,2.09,1.38 +Tshwane,2020-06-19,1.68,2.00,1.31 +Tshwane,2020-06-20,1.60,1.92,1.25 +Tshwane,2020-06-21,1.53,1.83,1.17 +Tshwane,2020-06-22,1.50,1.80,1.15 +Tshwane,2020-06-23,1.51,1.80,1.16 +Tshwane,2020-06-24,1.57,1.87,1.25 +Tshwane,2020-06-25,1.60,1.87,1.26 +Tshwane,2020-06-26,1.58,1.85,1.26 +Tshwane,2020-06-27,1.52,1.78,1.20 +Tshwane,2020-06-28,1.44,1.70,1.13 +Tshwane,2020-06-29,1.44,1.69,1.13 +Tshwane,2020-06-30,1.49,1.74,1.19 +Tshwane,2020-07-01,1.54,1.78,1.24 +Tshwane,2020-07-02,1.59,1.83,1.31 +Tshwane,2020-07-03,1.50,1.73,1.22 +Tshwane,2020-07-04,1.36,1.59,1.09 +Tshwane,2020-07-05,1.20,1.42,0.92 +Tshwane,2020-07-06,1.04,1.27,0.77 West Rand,2020-05-23,4.58,6.54,2.32 -West Rand,2020-05-24,3.74,5.05,2.31 -West Rand,2020-05-25,2.85,3.85,1.70 -West Rand,2020-05-26,2.10,2.96,1.11 -West Rand,2020-05-27,1.45,2.23,0.54 -West Rand,2020-05-28,1.09,1.81,0.25 -West Rand,2020-05-29,0.79,1.42,0.03 -West Rand,2020-05-30,0.90,1.57,0.14 -West Rand,2020-05-31,0.99,1.64,0.20 -West Rand,2020-06-01,1.04,1.70,0.29 -West Rand,2020-06-02,1.07,1.72,0.35 -West Rand,2020-06-03,1.13,1.75,0.41 -West Rand,2020-06-04,1.19,1.80,0.51 -West Rand,2020-06-05,1.23,1.81,0.56 -West Rand,2020-06-06,1.23,1.82,0.62 -West Rand,2020-06-07,1.23,1.77,0.60 -West Rand,2020-06-08,1.23,1.76,0.63 -West Rand,2020-06-09,1.24,1.75,0.65 -West Rand,2020-06-10,1.30,1.80,0.74 -West Rand,2020-06-11,1.36,1.83,0.80 -West Rand,2020-06-12,1.40,1.87,0.88 -West Rand,2020-06-13,1.40,1.84,0.88 -West Rand,2020-06-14,1.41,1.85,0.93 -West Rand,2020-06-15,1.41,1.83,0.94 -West Rand,2020-06-16,1.43,1.82,0.95 -West Rand,2020-06-17,1.46,1.84,1.00 -West Rand,2020-06-18,1.49,1.87,1.06 -West Rand,2020-06-19,1.51,1.87,1.09 -West Rand,2020-06-20,1.50,1.84,1.08 -West Rand,2020-06-21,1.47,1.81,1.08 -West Rand,2020-06-22,1.46,1.80,1.09 -West Rand,2020-06-23,1.47,1.79,1.10 -West Rand,2020-06-24,1.48,1.80,1.13 -West Rand,2020-06-25,1.49,1.81,1.16 -West Rand,2020-06-26,1.49,1.78,1.14 -West Rand,2020-06-27,1.49,1.77,1.15 -West Rand,2020-06-28,1.45,1.75,1.15 -West Rand,2020-06-29,1.45,1.72,1.13 -West Rand,2020-06-30,1.45,1.71,1.13 -West Rand,2020-07-01,1.45,1.70,1.13 -West Rand,2020-07-02,1.45,1.71,1.16 -West Rand,2020-07-03,1.43,1.68,1.14 +West Rand,2020-05-24,3.74,5.00,2.25 +West Rand,2020-05-25,2.85,3.88,1.73 +West Rand,2020-05-26,2.09,2.96,1.10 +West Rand,2020-05-27,1.42,2.22,0.51 +West Rand,2020-05-28,1.05,1.79,0.21 +West Rand,2020-05-29,0.73,1.37,0.00 +West Rand,2020-05-30,0.85,1.49,0.04 +West Rand,2020-05-31,0.96,1.61,0.11 +West Rand,2020-06-01,1.02,1.70,0.20 +West Rand,2020-06-02,1.05,1.74,0.26 +West Rand,2020-06-03,1.13,1.79,0.32 +West Rand,2020-06-04,1.20,1.87,0.44 +West Rand,2020-06-05,1.25,1.91,0.52 +West Rand,2020-06-06,1.25,1.89,0.54 +West Rand,2020-06-07,1.25,1.86,0.54 +West Rand,2020-06-08,1.24,1.84,0.55 +West Rand,2020-06-09,1.26,1.85,0.59 +West Rand,2020-06-10,1.33,1.90,0.67 +West Rand,2020-06-11,1.41,1.99,0.80 +West Rand,2020-06-12,1.46,2.00,0.84 +West Rand,2020-06-13,1.45,1.99,0.87 +West Rand,2020-06-14,1.46,1.97,0.88 +West Rand,2020-06-15,1.44,1.95,0.89 +West Rand,2020-06-16,1.47,1.95,0.91 +West Rand,2020-06-17,1.51,1.98,0.97 +West Rand,2020-06-18,1.55,2.01,1.03 +West Rand,2020-06-19,1.57,2.01,1.06 +West Rand,2020-06-20,1.54,1.98,1.06 +West Rand,2020-06-21,1.49,1.91,1.01 +West Rand,2020-06-22,1.48,1.89,1.01 +West Rand,2020-06-23,1.48,1.89,1.03 +West Rand,2020-06-24,1.51,1.91,1.07 +West Rand,2020-06-25,1.52,1.91,1.09 +West Rand,2020-06-26,1.51,1.90,1.10 +West Rand,2020-06-27,1.50,1.86,1.07 +West Rand,2020-06-28,1.44,1.80,1.03 +West Rand,2020-06-29,1.44,1.79,1.03 +West Rand,2020-06-30,1.44,1.80,1.06 +West Rand,2020-07-01,1.51,1.85,1.12 +West Rand,2020-07-02,1.54,1.88,1.17 +West Rand,2020-07-03,1.58,1.91,1.22 +West Rand,2020-07-04,1.55,1.85,1.17 +West Rand,2020-07-05,1.52,1.82,1.16 +West Rand,2020-07-06,1.45,1.74,1.09 diff --git a/data/calc/calculated_rt_sa_provincial_cumulative.csv b/data/calc/calculated_rt_sa_provincial_cumulative.csv index 19085a260..0b877fcd4 100644 --- a/data/calc/calculated_rt_sa_provincial_cumulative.csv +++ b/data/calc/calculated_rt_sa_provincial_cumulative.csv @@ -82,9 +82,10 @@ EC,2020-06-29,1.05,1.26,0.81 EC,2020-06-30,1.03,1.24,0.79 EC,2020-07-01,1.12,1.33,0.88 EC,2020-07-02,1.19,1.39,0.94 -EC,2020-07-03,1.24,1.44,1.00 -EC,2020-07-04,1.19,1.38,0.94 -EC,2020-07-05,1.12,1.33,0.90 +EC,2020-07-03,1.39,1.59,1.15 +EC,2020-07-04,1.38,1.57,1.14 +EC,2020-07-05,1.37,1.56,1.14 +EC,2020-07-06,1.40,1.59,1.18 FS,2020-05-29,2.28,4.74,0.00 FS,2020-05-30,2.17,3.90,0.10 FS,2020-05-31,1.91,3.38,0.20 @@ -120,9 +121,10 @@ FS,2020-06-29,1.82,2.30,1.28 FS,2020-06-30,1.90,2.36,1.38 FS,2020-07-01,1.97,2.43,1.50 FS,2020-07-02,1.91,2.33,1.44 -FS,2020-07-03,1.82,2.21,1.35 -FS,2020-07-04,1.65,2.05,1.22 -FS,2020-07-05,1.47,1.86,1.04 +FS,2020-07-03,1.85,2.24,1.38 +FS,2020-07-04,1.68,2.07,1.24 +FS,2020-07-05,1.52,1.89,1.07 +FS,2020-07-06,1.38,1.75,0.94 GP,2020-03-17,2.84,5.17,0.05 GP,2020-03-18,2.62,4.47,0.50 GP,2020-03-19,2.30,3.83,0.59 @@ -231,9 +233,10 @@ GP,2020-06-29,1.34,1.50,1.15 GP,2020-06-30,1.45,1.61,1.27 GP,2020-07-01,1.60,1.75,1.42 GP,2020-07-02,1.63,1.77,1.45 -GP,2020-07-03,1.52,1.66,1.35 -GP,2020-07-04,1.38,1.52,1.22 -GP,2020-07-05,1.24,1.38,1.08 +GP,2020-07-03,1.46,1.60,1.29 +GP,2020-07-04,1.28,1.41,1.10 +GP,2020-07-05,1.09,1.23,0.92 +GP,2020-07-06,0.90,1.04,0.73 KZN,2020-03-23,3.62,6.09,0.75 KZN,2020-03-24,3.01,4.74,0.96 KZN,2020-03-25,2.58,3.97,0.97 @@ -336,9 +339,10 @@ KZN,2020-06-29,1.65,1.92,1.34 KZN,2020-06-30,1.70,1.97,1.41 KZN,2020-07-01,1.76,2.02,1.48 KZN,2020-07-02,1.77,2.01,1.49 -KZN,2020-07-03,1.66,1.89,1.38 -KZN,2020-07-04,1.52,1.75,1.26 -KZN,2020-07-05,1.34,1.56,1.07 +KZN,2020-07-03,1.57,1.80,1.29 +KZN,2020-07-04,1.36,1.59,1.09 +KZN,2020-07-05,1.11,1.34,0.84 +KZN,2020-07-06,0.91,1.14,0.63 LP,2020-06-10,2.28,4.74,0.00 LP,2020-06-11,1.89,3.64,0.03 LP,2020-06-12,2.11,3.62,0.31 @@ -362,9 +366,10 @@ LP,2020-06-29,1.65,2.19,1.04 LP,2020-06-30,1.62,2.14,1.02 LP,2020-07-01,1.64,2.14,1.05 LP,2020-07-02,1.68,2.16,1.10 -LP,2020-07-03,1.68,2.17,1.15 -LP,2020-07-04,1.64,2.12,1.13 -LP,2020-07-05,1.64,2.08,1.11 +LP,2020-07-03,1.64,2.11,1.08 +LP,2020-07-04,1.56,2.03,1.03 +LP,2020-07-05,1.48,1.94,0.96 +LP,2020-07-06,1.34,1.79,0.82 MP,2020-06-11,2.88,5.02,0.20 MP,2020-06-12,2.65,4.31,0.69 MP,2020-06-13,2.25,3.62,0.71 @@ -387,9 +392,10 @@ MP,2020-06-29,1.67,2.20,1.10 MP,2020-06-30,1.73,2.22,1.15 MP,2020-07-01,1.81,2.28,1.25 MP,2020-07-02,1.82,2.29,1.31 -MP,2020-07-03,1.75,2.19,1.24 -MP,2020-07-04,1.65,2.08,1.16 -MP,2020-07-05,1.54,1.96,1.06 +MP,2020-07-03,1.80,2.23,1.28 +MP,2020-07-04,1.71,2.15,1.24 +MP,2020-07-05,1.61,2.02,1.13 +MP,2020-07-06,1.49,1.91,1.04 NC,2020-06-14,2.00,4.23,0.00 NC,2020-06-15,1.48,3.10,0.00 NC,2020-06-16,0.99,2.40,0.00 @@ -409,9 +415,10 @@ NC,2020-06-29,1.67,2.46,0.80 NC,2020-06-30,1.82,2.57,1.01 NC,2020-07-01,1.87,2.56,1.09 NC,2020-07-02,1.80,2.46,1.07 -NC,2020-07-03,1.72,2.35,1.02 -NC,2020-07-04,1.59,2.22,0.94 -NC,2020-07-05,1.49,2.09,0.84 +NC,2020-07-03,1.77,2.39,1.06 +NC,2020-07-04,1.67,2.26,0.98 +NC,2020-07-05,1.61,2.18,0.94 +NC,2020-07-06,1.54,2.09,0.88 NW,2020-05-27,0.26,3.96,0.00 NW,2020-05-28,1.34,3.32,0.00 NW,2020-05-29,1.22,2.83,0.00 @@ -449,9 +456,10 @@ NW,2020-06-29,1.20,1.59,0.81 NW,2020-06-30,1.30,1.65,0.87 NW,2020-07-01,1.47,1.83,1.07 NW,2020-07-02,1.60,1.94,1.20 -NW,2020-07-03,1.61,1.93,1.21 -NW,2020-07-04,1.57,1.88,1.18 -NW,2020-07-05,1.51,1.82,1.14 +NW,2020-07-03,1.59,1.92,1.20 +NW,2020-07-04,1.53,1.85,1.15 +NW,2020-07-05,1.41,1.74,1.06 +NW,2020-07-06,1.23,1.54,0.86 WC,2020-03-20,2.17,4.55,0.00 WC,2020-03-21,1.82,3.51,0.03 WC,2020-03-22,2.18,3.69,0.44 @@ -557,9 +565,10 @@ WC,2020-06-29,0.95,1.17,0.69 WC,2020-06-30,1.13,1.34,0.86 WC,2020-07-01,1.22,1.42,0.95 WC,2020-07-02,1.16,1.37,0.91 -WC,2020-07-03,1.06,1.27,0.81 -WC,2020-07-04,0.95,1.16,0.70 -WC,2020-07-05,0.79,1.00,0.53 +WC,2020-07-03,1.07,1.28,0.82 +WC,2020-07-04,0.97,1.18,0.72 +WC,2020-07-05,0.87,1.07,0.60 +WC,2020-07-06,0.93,1.14,0.67 Total RSA,2020-03-19,2.11,3.70,0.22 Total RSA,2020-03-20,2.50,3.73,1.09 Total RSA,2020-03-21,2.75,3.71,1.67 @@ -666,6 +675,7 @@ Total RSA,2020-06-29,1.25,1.36,1.09 Total RSA,2020-06-30,1.40,1.52,1.26 Total RSA,2020-07-01,1.54,1.66,1.41 Total RSA,2020-07-02,1.51,1.63,1.39 -Total RSA,2020-07-03,1.40,1.50,1.26 -Total RSA,2020-07-04,1.25,1.36,1.13 -Total RSA,2020-07-05,1.12,1.22,0.99 +Total RSA,2020-07-03,1.39,1.50,1.26 +Total RSA,2020-07-04,1.22,1.31,1.07 +Total RSA,2020-07-05,1.07,1.17,0.94 +Total RSA,2020-07-06,0.98,1.09,0.86