From e8224d88fe4ed47dd199dbb2b5ad7ac56db578ff Mon Sep 17 00:00:00 2001 From: stijnvanhoey Date: Mon, 8 Jun 2020 22:45:08 +0200 Subject: [PATCH 1/5] Add refactored sse function --- .../optimization/objective_fcns.py | 77 ++++++++++++++++++- 1 file changed, 74 insertions(+), 3 deletions(-) diff --git a/src/covid19model/optimization/objective_fcns.py b/src/covid19model/optimization/objective_fcns.py index 16b286d98..fa7a61d47 100644 --- a/src/covid19model/optimization/objective_fcns.py +++ b/src/covid19model/optimization/objective_fcns.py @@ -1,5 +1,76 @@ import numpy as np + +def sse(theta, model, data, model_parameters, lag_time=None): + """Calculate the sum of squared errors from data and model instance + + The function assumes the number of values in the theta array corresponds + to the number of defined parameters, but can be extended with a lag_time + parameters to make this adjustable as well by an optimization algorithm. + + + Parameters + ---------- + theta : np.array + Array with N (if lag_time is defined) or N+1 (if lag_time is not + defined) values. + model : covidmodel.model instance + Covid model instance + data : xarray.DataArray + Xarray DataArray with time as a dimension and the name corresponding + to an existing model output state. + model_parameters : list of str + Parameter names of the model parameters to adjust in order to get the + SSE. + lag_time : int + Warming up period before comparing the data with the model output. + e.g. if 40; comparison of data only starts after 40 days. + + + Notes + ----- + Assumes daily time step(!) # TODO: need to generalize this + + Examples + -------- + >>> data_to_fit = xr.DataArray([ 54, 79, 100, 131, 165, 228, 290], + coords={"time": range(1, 8)}, name="ICU", + dims=['time']) + >>> sse([1.6, 0.025, 42], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=None) + >>> # previous is equivalent to + >>> sse([1.6, 0.025], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=42) + >>> # but the latter will use a fixed lag_time, + >>> # whereas the first one can be used inside optimization + """ + + if data_to_fit.name not in sir_model.state_names: + raise Exception("Data variable to fit is not available as model output") + + # define new parameters in model + for i, parameter in enumerate(model_parameters): + model.parameters.update({parameter: theta[i]}) + + # extract additional parameter # TODO - check alternatives for generalisation here + if not lag_time: + lag_time = int(round(theta[-1])) + else: + lag_time = int(round(lag_time)) + + # run model + time = len(data.time) + lag_time # at least this length + output = model.sim(time) + + # extract the variable of interest + subset_output = output.sum(dim="stratification")[data.name] + # adjust to fix lag time to extract start of comparison + output_to_compare = subset_output.sel(time=slice(lag_time, lag_time - 1 + len(data))) + + # calculate sse -> we could maybe enable more function options on this level? + sse = np.sum((data.values - output_to_compare.values)**2) + + return sse + + def SSE(thetas,BaseModel,data,states,parNames,weights,checkpoints=None): """ @@ -30,7 +101,7 @@ def SSE(thetas,BaseModel,data,states,parNames,weights,checkpoints=None): ----------- SSE = SSE(model,thetas,data,parNames,positions,weights) """ - + # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # assign estimates to correct variable # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -46,7 +117,7 @@ def SSE(thetas,BaseModel,data,states,parNames,weights,checkpoints=None): # Run simulation # ~~~~~~~~~~~~~~ # number of dataseries - n = len(data) + n = len(data) # Compute simulation time data_length =[] for i in range(n): @@ -129,7 +200,7 @@ def MLE(thetas,BaseModel,data,states,parNames,checkpoints=None): # Run simulation # ~~~~~~~~~~~~~~ # number of dataseries - n = len(data) + n = len(data) # Compute simulation time data_length =[] for i in range(n): From 7d6fde227f0345ccccc8e2ac796e1eacf14c569b Mon Sep 17 00:00:00 2001 From: stijnvanhoey Date: Mon, 8 Jun 2020 23:03:56 +0200 Subject: [PATCH 2/5] Switch name and add refactored fit function --- .../optimization/{MCMC.py => optimize.py} | 57 ++++++++++++++++++- 1 file changed, 55 insertions(+), 2 deletions(-) rename src/covid19model/optimization/{MCMC.py => optimize.py} (50%) diff --git a/src/covid19model/optimization/MCMC.py b/src/covid19model/optimization/optimize.py similarity index 50% rename from src/covid19model/optimization/MCMC.py rename to src/covid19model/optimization/optimize.py index c11c2f8f9..c98f2eee3 100644 --- a/src/covid19model/optimization/MCMC.py +++ b/src/covid19model/optimization/optimize.py @@ -3,6 +3,59 @@ from covid19model.optimization import objective_fcns from covid19model.optimization import pso + +def fit(func, model, data, model_parameters, bounds, + disp=True, maxiter=30, popsize=10): + """Fit a model using a defined SSE function + + Parameters + ---------- + func : objective function + The arguments ``model``, ``data`` + and ``model_parameters`` should be the + other arguments of the optimization func + model : covidmodel.model instance + Covid19model instance + data : xarray.DataArray + Xarray DataArray with time as a dimension and the name corresponding + to an existing model output state. + model_parameters : list of str + Parameter names of the model parameters to adjust in order to get the + SSE. + bounds : list of (min, max) + For each parameter (model parameter or others), define the min and + max boundaries as tuples. If func has non-model parameters to + optimize as well, len(bounds) > len(model_parameters). + disp: boolean + display the pso output stream + maxiter: float or int + maximum number of pso iterations + popsize: float or int + population size of particle swarm + increasing this variable lowers the chance of finding local minima but slows down calculations + """ + # TODO - add checks on inputs,... + + original_parameters = model.parameters.copy() + + (theta_hat, obj_fun_val, pars_final_swarm, + obj_fun_val_final_swarm) = pso.optim(func, + bounds, + args=(model, data, model_parameters), + swarmsize=popsize, + maxiter=maxiter, + processes=mp.cpu_count()-1, + minfunc=1e-9, + minstep=1e-9, + debug=True, + particle_output=True) + + # reset the model parameters to original values + model.parameters = original_parameters + + return theta_hat + + def fit_pso(BaseModel,data,parNames,states,bounds,checkpoints=None,disp=True,maxiter=30,popsize=10): """ A function to compute the mimimum of the absolute value of the maximum likelihood estimator using a particle swarm optimization @@ -12,7 +65,7 @@ def fit_pso(BaseModel,data,parNames,states,bounds,checkpoints=None,disp=True,max BaseModel: model object correctly initialised model to be fitted to the dataset data: array - list containing dataseries + list containing dataseries parNames: array list containing the names of the parameters to be fitted states: array @@ -38,7 +91,7 @@ def fit_pso(BaseModel,data,parNames,states,bounds,checkpoints=None,disp=True,max Notes ----------- - Use all available cores minus one by default (optimal number of processors for 2-,4- or 6-core PC's with an OS). + Use all available cores minus one by default (optimal number of processors for 2-,4- or 6-core PC's with an OS). Example use ----------- From a75168061eebabd277b7122e0eb1c638c0454f66 Mon Sep 17 00:00:00 2001 From: stijnvanhoey Date: Mon, 8 Jun 2020 23:20:51 +0200 Subject: [PATCH 3/5] Fix path handling data functions --- src/covid19model/data/parameters.py | 11 +++++++---- src/covid19model/data/polymod.py | 28 +++++++++++++++------------- 2 files changed, 22 insertions(+), 17 deletions(-) diff --git a/src/covid19model/data/parameters.py b/src/covid19model/data/parameters.py index f1997b5e9..8dbb4c15c 100644 --- a/src/covid19model/data/parameters.py +++ b/src/covid19model/data/parameters.py @@ -54,27 +54,30 @@ def get_COVID19_SEIRD_parameters(): ----------- parameters = get_COVID19_SEIRD_parameters() """ + abs_dir = os.path.dirname(__file__) + rel_dir = os.path.join(abs_dir, "../../../data/raw/model_parameters") + # Initialize parameters dictionary parameters = {} # Assign Nc_total from the Polymod study to the parameters dictionary initN, Nc_home, Nc_work, Nc_schools, Nc_transport, Nc_leisure, Nc_others, Nc_total = polymod.get_interaction_matrices() parameters['Nc'] = Nc_total - + # Verity_etal - df = pd.read_csv("../../data/raw/model_parameters/verity_etal.csv", sep=',',header='infer') + df = pd.read_csv(os.path.join(rel_dir, "verity_etal.csv"), sep=',',header='infer') parameters['h'] = np.array(df.loc[:,'symptomatic_hospitalized'].astype(float).tolist())/100 parameters['icu'] = np.array(df.loc[:,'hospitalized_ICU'].astype(float).tolist())/100 parameters['c'] = 1-parameters['icu'] parameters['m0'] = np.array(df.loc[:,'CFR'].astype(float).tolist())/100/parameters['h']/parameters['icu'] # Abrams_etal - df_asymp = pd.read_csv("../../data/raw/model_parameters/abrams_etal.csv", sep=',',header='infer') + df_asymp = pd.read_csv(os.path.join(rel_dir, "wu_etal.csv"), sep=',',header='infer') parameters['a'] = np.array(df_asymp.loc[:,'fraction asymptomatic'].astype(float).tolist()) parameters['m'] = 1-parameters['a'] # Other parameters - df_other_pars = pd.read_csv("../../data/raw/model_parameters/others.csv", sep=',',header='infer') + df_other_pars = pd.read_csv(os.path.join(rel_dir, "others.csv"), sep=',',header='infer') parameters.update(df_other_pars.T.to_dict()[0]) # Fitted parameters diff --git a/src/covid19model/data/polymod.py b/src/covid19model/data/polymod.py index 6bac67058..a6fe7dae9 100644 --- a/src/covid19model/data/polymod.py +++ b/src/covid19model/data/polymod.py @@ -4,7 +4,7 @@ import numpy as np def get_interaction_matrices(): - """Extract interaction matrices and demographic data from `data/raw/polymod` folder + """Extract interaction matrices and demographic data from `data/raw/polymod` folder This function returns the total number of individuals in ten year age bins in the Belgian population and the interaction matrices Nc at home, at work, in schools, on public transport, during leisure activities and during other activities. @@ -15,15 +15,15 @@ def get_interaction_matrices(): Nc_home : np.array (9x9) number of daily contacts at home of individuals in age group X with individuals in age group Y Nc_work : np.array (9x9) - number of daily contacts in the workplace of individuals in age group X with individuals in age group Y + number of daily contacts in the workplace of individuals in age group X with individuals in age group Y Nc_schools : np.array (9x9) - number of daily contacts in schools of individuals in age group X with individuals in age group Y + number of daily contacts in schools of individuals in age group X with individuals in age group Y Nc_transport : np.array (9x9) - number of daily contacts on public transport of individuals in age group X with individuals in age group Y + number of daily contacts on public transport of individuals in age group X with individuals in age group Y Nc_leisure : np.array (9x9) number of daily contacts during leisure activities of individuals in age group X with individuals in age group Y Nc_others : np.array (9x9) - number of daily contacts in other places of individuals in age group X with individuals in age group Y + number of daily contacts in other places of individuals in age group X with individuals in age group Y Nc_total : np.array (9x9) total number of daily contacts of individuals in age group X with individuals in age group Y, calculated as the sum of all the above interaction @@ -36,15 +36,17 @@ def get_interaction_matrices(): ----------- initN, Nc_home, Nc_work, Nc_schools, Nc_transport, Nc_leisure, Nc_others, Nc_total = get_interaction_matrices() """ + abs_dir = os.path.dirname(__file__) + rel_dir = os.path.join(abs_dir, "../../../data/raw/polymod/interaction_matrices/Belgium") # Data source - Nc_home = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELhome.txt", dtype='f', delimiter='\t') - Nc_work = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELwork.txt", dtype='f', delimiter='\t') - Nc_schools = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELschools.txt", dtype='f', delimiter='\t') - Nc_transport = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELtransport.txt", dtype='f', delimiter='\t') - Nc_leisure = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELleisure.txt", dtype='f', delimiter='\t') - Nc_others = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELothers.txt", dtype='f', delimiter='\t') - Nc_total = np.loadtxt("../../data/raw/polymod/interaction_matrices/Belgium/BELtotal.txt", dtype='f', delimiter='\t') - initN = np.loadtxt("../../data/raw/polymod/demographic/BELagedist_10year.txt", dtype='f', delimiter='\t') + Nc_home = np.loadtxt(os.path.join(rel_dir, "BELhome.txt"), dtype='f', delimiter='\t') + Nc_work = np.loadtxt(os.path.join(rel_dir, "BELwork.txt"), dtype='f', delimiter='\t') + Nc_schools = np.loadtxt(os.path.join(rel_dir, "BELschools.txt"), dtype='f', delimiter='\t') + Nc_transport = np.loadtxt(os.path.join(rel_dir, "BELtransport.txt"), dtype='f', delimiter='\t') + Nc_leisure = np.loadtxt(os.path.join(rel_dir, "BELleisure.txt"), dtype='f', delimiter='\t') + Nc_others = np.loadtxt(os.path.join(rel_dir, "BELothers.txt"), dtype='f', delimiter='\t') + Nc_total = np.loadtxt(os.path.join(rel_dir, "BELtotal.txt"), dtype='f', delimiter='\t') + initN = np.loadtxt(os.path.join(abs_dir, "../../../data/raw/polymod/demographic/BELagedist_10year.txt"), dtype='f', delimiter='\t') return initN, Nc_home, Nc_work, Nc_schools, Nc_transport, Nc_leisure, Nc_others, Nc_total From de6b74cf1eb429edec403f5ddd974ac4361e0a3f Mon Sep 17 00:00:00 2001 From: stijnvanhoey Date: Mon, 8 Jun 2020 23:21:18 +0200 Subject: [PATCH 4/5] Fix object names --- src/covid19model/optimization/objective_fcns.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/covid19model/optimization/objective_fcns.py b/src/covid19model/optimization/objective_fcns.py index fa7a61d47..03ab4aab7 100644 --- a/src/covid19model/optimization/objective_fcns.py +++ b/src/covid19model/optimization/objective_fcns.py @@ -43,7 +43,7 @@ def sse(theta, model, data, model_parameters, lag_time=None): >>> # whereas the first one can be used inside optimization """ - if data_to_fit.name not in sir_model.state_names: + if data.name not in model.state_names: raise Exception("Data variable to fit is not available as model output") # define new parameters in model From b6866f9d86f465838e079cf457af8a2f37c37dff Mon Sep 17 00:00:00 2001 From: stijnvanhoey Date: Mon, 8 Jun 2020 23:21:54 +0200 Subject: [PATCH 5/5] Add example of refactored optimization --- ...2-stijnvanhoey-refactor-optimization.ipynb | 1033 +++++++++++++++++ 1 file changed, 1033 insertions(+) create mode 100644 notebooks/0.2-stijnvanhoey-refactor-optimization.ipynb diff --git a/notebooks/0.2-stijnvanhoey-refactor-optimization.ipynb b/notebooks/0.2-stijnvanhoey-refactor-optimization.ipynb new file mode 100644 index 000000000..44fdc25d1 --- /dev/null +++ b/notebooks/0.2-stijnvanhoey-refactor-optimization.ipynb @@ -0,0 +1,1033 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:18.467181Z", + "start_time": "2020-06-03T07:21:17.408492Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from scipy.integrate import solve_ivp\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import itertools" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# OPTIONAL: Load the \"autoreload\" extension so that package code can change\n", + "%load_ext autoreload\n", + "# OPTIONAL: always reload modules so that as you change code in src, it gets loaded\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Age based SEIRS" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:35.683658Z", + "start_time": "2020-06-03T07:21:33.312826Z" + } + }, + "outputs": [], + "source": [ + "from covid19model.models import models\n", + "from covid19model.data import google\n", + "from covid19model.data import sciensano\n", + "from covid19model.data import polymod\n", + "from covid19model.data import parameters\n", + "from covid19model.visualization.output import population_status, infected" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "### Define model locally" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "initN, Nc_home, Nc_work, Nc_schools, Nc_transport, Nc_leisure, Nc_others, Nc_total = polymod.get_interaction_matrices()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:30.050406Z", + "start_time": "2020-06-03T07:21:30.041794Z" + } + }, + "outputs": [], + "source": [ + "h = np.array([0.0205,0.0205,0.1755,0.1755,0.2115,0.2503,0.3066,0.4033,0.4770])\n", + "icu = np.array([0,0,0.0310,0.0310,0.055,0.077,0.107,0.1685,0.1895])\n", + "r = icu/h" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:30.550918Z", + "start_time": "2020-06-03T07:21:30.544110Z" + } + }, + "outputs": [], + "source": [ + "# ... parameters and initial conditions\n", + "levels = initN.size\n", + "nc = Nc_total\n", + "params = parameters.get_COVID19_SEIRD_parameters()\n", + "\n", + "initial_states = {'S': initN, 'E': np.ones(levels)}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:36.603310Z", + "start_time": "2020-06-03T07:21:36.480161Z" + } + }, + "outputs": [], + "source": [ + "# -> user initiates the model\n", + "sir_model = models.COVID19_SEIRD(initial_states, params)\n", + "\n", + "# -> user runs a simulation for a defined time period\n", + "time = [0, 200]\n", + "output = sir_model.sim(time)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:25:36.445570Z", + "start_time": "2020-06-03T07:25:36.190335Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "infected(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:21:53.877975Z", + "start_time": "2020-06-03T07:21:53.658738Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "population_status(output)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-06-03T07:26:37.433173Z", + "start_time": "2020-06-03T07:26:37.213467Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(output.coords['time'], output['S'].sum(dim=\"stratification\"), label=\"S\")\n", + "plt.plot(output.coords['time'], output['E'].sum(dim=\"stratification\"), label=\"E\")\n", + "\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from covid19model.data import sciensano" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + "
H_totICU_totH_inH_outH_tot_cumsum
DATE
2020-03-1526654711853
2020-03-16370799014129
2020-03-1749710012331221
2020-03-1865013118348356
2020-03-1984416521249519
\n", + "
" + ], + "text/plain": [ + " H_tot ICU_tot H_in H_out H_tot_cumsum\n", + "DATE \n", + "2020-03-15 266 54 71 18 53\n", + "2020-03-16 370 79 90 14 129\n", + "2020-03-17 497 100 123 31 221\n", + "2020-03-18 650 131 183 48 356\n", + "2020-03-19 844 165 212 49 519" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_sciensano = sciensano.get_sciensano_COVID19_data(update=False)\n", + "df_sciensano.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Convert the data to a xarray DataArray (can be later extended towards xarray Dataset if multiple states are compared" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "Show/Hide data repr\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Show/Hide attributes\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
xarray.DataArray
'ICU'
  • time: 7
  • 54 79 100 131 165 228 290
    array([ 54,  79, 100, 131, 165, 228, 290])
    • time
      (time)
      int64
      1 2 3 4 5 6 7
      array([1, 2, 3, 4, 5, 6, 7])
" + ], + "text/plain": [ + "\n", + "array([ 54, 79, 100, 131, 165, 228, 290])\n", + "Coordinates:\n", + " * time (time) int64 1 2 3 4 5 6 7" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_to_fit = xr.DataArray([ 54, 79, 100, 131, 165, 228, 290], \n", + " coords={\"time\": range(1, 8)}, name=\"ICU\",\n", + " dims=['time'])\n", + "data_to_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 54, 79, 100, 131, 165, 228, 290])" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_to_fit.values" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from covid19model.optimization.objective_fcns import sse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Try out the sse function:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "122202.00118319865" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sse([0.3, 0.04, 12], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6437.4700475273885" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sse([1.6, 0.025, 42], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Due to the setup of the function, this is similar to" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6437.4700475273885" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sse([1.6, 0.025], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Apply with fixed lag time:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "13328.779260868365" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sse([1.6, 0.025], sir_model, data_to_fit, ['sigma', 'beta'], lag_time=40)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Apply the optimization pso functionality:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import multiprocessing as mp\n", + "from covid19model.optimization import pso" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "from covid19model.optimization.optimize import fit" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "bounds=[(1, 100), (0.02, 0.06), (20, 80)]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No constraints given.\n", + "New best for swarm at iteration 1: [ 1. 0.03304964 24.70556363] 10807.146214163115\n", + "Best after iteration 1: [ 1. 0.03304964 24.70556363] 10807.146214163115\n", + "Best after iteration 2: [ 1. 0.03304964 24.70556363] 10807.146214163115\n", + "Best after iteration 3: [ 1. 0.03304964 24.70556363] 10807.146214163115\n", + "Best after iteration 4: [ 1. 0.03304964 24.70556363] 10807.146214163115\n", + "New best for swarm at iteration 5: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 5: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 6: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 7: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 8: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 9: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 10: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "Best after iteration 11: [ 1. 0.03285257 25.5069565 ] 1016.6487860669702\n", + "New best for swarm at iteration 12: [ 1. 0.03281443 25.61753133] 968.2384358003329\n", + "Best after iteration 12: [ 1. 0.03281443 25.61753133] 968.2384358003329\n", + "Best after iteration 13: [ 1. 0.03281443 25.61753133] 968.2384358003329\n", + "New best for swarm at iteration 14: [ 1. 0.0328097 25.73390775] 965.4411400238192\n", + "Best after iteration 14: [ 1. 0.0328097 25.73390775] 965.4411400238192\n", + "Best after iteration 15: [ 1. 0.0328097 25.73390775] 965.4411400238192\n", + "New best for swarm at iteration 16: [ 1. 0.03278046 25.80294168] 963.6008804391676\n", + "Best after iteration 16: [ 1. 0.03278046 25.80294168] 963.6008804391676\n", + "New best for swarm at iteration 17: [ 1. 0.03278706 25.73100244] 961.7118511730044\n", + "Best after iteration 17: [ 1. 0.03278706 25.73100244] 961.7118511730044\n", + "New best for swarm at iteration 18: [ 1. 0.03279043 25.73246628] 961.263391696539\n", + "Best after iteration 18: [ 1. 0.03279043 25.73246628] 961.263391696539\n", + "New best for swarm at iteration 19: [ 1. 0.03279278 25.79734207] 961.1574566149003\n", + "Best after iteration 19: [ 1. 0.03279278 25.79734207] 961.1574566149003\n", + "New best for swarm at iteration 20: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 20: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 21: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 22: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 23: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 24: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 25: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "Best after iteration 26: [ 1. 0.03279307 25.75317367] 961.1561728429244\n", + "New best for swarm at iteration 27: [ 1. 0.03279307 25.75214352] 961.1561725663297\n", + "Best after iteration 27: [ 1. 0.03279307 25.75214352] 961.1561725663297\n", + "Best after iteration 28: [ 1. 0.03279307 25.75214352] 961.1561725663297\n", + "Best after iteration 29: [ 1. 0.03279307 25.75214352] 961.1561725663297\n", + "Best after iteration 30: [ 1. 0.03279307 25.75214352] 961.1561725663297\n", + "Stopping search: maximum iterations reached --> 30\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 1. , 0.03279307, 25.75214352])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fit(sse, sir_model, data_to_fit, ['sigma', 'beta'], bounds)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:COVID_MODEL]", + "language": "python", + "name": "conda-env-COVID_MODEL-py" + }, + "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" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}