diff --git a/bass model_covid_analysis.ipynb b/bass model_covid_analysis.ipynb new file mode 100644 index 0000000..9354b2b --- /dev/null +++ b/bass model_covid_analysis.ipynb @@ -0,0 +1,1093 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 532, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-11T19:50:27.986601Z", + "start_time": "2020-05-11T19:50:27.965931Z" + } + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import glob\n", + "from datetime import datetime,date,timedelta\n", + "from scipy.optimize import curve_fit\n", + "import matplotlib.dates as mdates\n", + "from functools import partial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T20:21:16.821932Z", + "start_time": "2020-05-08T20:21:16.678433Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/soujanyasamineni/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:9: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n", + "of pandas will change to not sort by default.\n", + "\n", + "To accept the future behavior, pass 'sort=False'.\n", + "\n", + "To retain the current behavior and silence the warning, pass 'sort=True'.\n", + "\n", + " if __name__ == '__main__':\n" + ] + } + ], + "source": [ + "path = '/Users/soujanyasamineni/Desktop/COVID-19/csse_covid_19_data/csse_covid_19_time_series/'\n", + "all_files = glob.glob(path + \"*.csv\")\n", + "file = []\n", + "\n", + "for filename in all_files:\n", + " df = pd.read_csv(filename, index_col=None, header=0)\n", + " file.append(df)\n", + "\n", + "data = pd.concat(file, axis=0, ignore_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 528, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-11T06:46:35.884616Z", + "start_time": "2020-05-11T06:46:35.879366Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/soujanyasamineni/Desktop/COVID-19/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv'" + ] + }, + "execution_count": 528, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_files[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 529, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-11T19:44:06.372792Z", + "start_time": "2020-05-11T19:44:06.060396Z" + } + }, + "outputs": [], + "source": [ + "data = pd.read_csv(all_files[0], index_col=None, header=0)\n", + "\n", + "data2 = data.drop(['Lat', 'Long','Province/State'],axis=1)\n", + "\n", + "melted_data = data2.melt(id_vars=\"Country/Region\",var_name='date',value_name='Confirmed')\n", + "melted_data['date'] = pd.to_datetime(melted_data['date'])\n", + "\n", + "melted_data.sort_values(by=['Country/Region','date'],inplace=True)\n", + "\n", + "pivoted_data = melted_data.pivot_table(index='Country/Region',columns='date',values='Confirmed',aggfunc=np.sum)\n", + "\n", + "data_china=melted_data[melted_data['Country/Region']=='China']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-----------------------------------------------------------------------------------------------------------------\n", + "- **The Bass Model principle is** f(t)/(1-F(t)) = p + q/M (A(t)) \n", + "> \"The portion of the potential market that adopts at t given that they have not yet adopted is equal to a linear function of previous adopters.\" \n", + "- *In the above equation, t represents time from product launch and is assumed to be non-negative*. \n", + "- The three Bass Model parameters (coefficients) that define the Bass Model for a specific product are:\n", + "- M -- the potential market (the ultimate number of adopters),\n", + "- p -- coefficient of innovation and\n", + "- q -- coefficient of imitation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> - M = (-beta(1) +- sqrt(beta(1)*2-4beta(0)beta(2)/(2beta(2))\n", + "- p = beta0/m\n", + "- q = beta1 + beta0/m\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:12.684359Z", + "start_time": "2020-05-08T23:13:12.677268Z" + } + }, + "outputs": [], + "source": [ + "def transition(curve_type,dmax,time_to_max,time_in_lag,launch,time,interval):\n", + " \"\"\"\n", + " Design a transition curve with given choice of inputs; playing with the parameters p,q\n", + " For more info https://businessperspectives.org/journals/Parametric analysis of the Bass model - Business Perspectives.pdf\n", + " \n", + " :return: transition\n", + " \n", + " \"\"\"\n", + " scurve=0\n", + " srapidcurve=0\n", + " time_lag=0\n", + "#Limit curve type from 0-10\n", + " if curve_type<0:\n", + " curve_type=0\n", + " elif curve_type>10:\n", + " curve_type=10\n", + " else:\n", + " curve_type=curve_type\n", + "#Test for pure S curve using lag parameter\n", + " if time_in_lag==0:\n", + " time_lag=time_to_max/4\n", + " else:\n", + " time_lag=time_in_lag\n", + "#Calculate weight of curve type\n", + " scurve=1-(curve_type/10)\n", + " srapidcurve=1-scurve\n", + " if time_to_max<0:\n", + " transition=0\n", + " else:\n", + " transition=scurve*S_shape_curve(dmax,time_to_max,time_lag,launch,time,interval)+\\\n", + " srapidcurve*rapid_curve(dmax,time_to_max,launch,time,interval)\n", + " return transition" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:14.021295Z", + "start_time": "2020-05-08T23:13:14.011391Z" + } + }, + "outputs": [], + "source": [ + "def S_shape_curve(dmax,time_to_max,time_lag,launch,time,interval):\n", + " \"\"\"\n", + " Design sigmoid curve with given choice of inputs; \n", + " \n", + " :return: S curve\n", + " \n", + " \"\"\"\n", + " con,slo=0,0\n", + " lower,upper=0,0\n", + " lower_limit,upper_limit=0,0\n", + " launch=time_index(launch)\n", + " time=time_index(time)\n", + " if time_to_max==time_lag or time_to_max==0:\n", + " if time_to_max<0:\n", + " time_to_max=0\n", + " S_shape_curve=step_func(0,dmax,launch+time_to_max,time,interval)\n", + " \n", + " if interval!=0:\n", + " lower=max(time,launch)\n", + " upper=max(time+interval,launch)\n", + " con=1/(1-time_lag/time_to_max)*np.log((1/0.15-1)/((1/0.98 - 1)**(time_lag/time_to_max)))\n", + " slo=1/time_to_max*(np.log(1/0.98 -1)-con)\n", + " lower_limit=dmax/slo *((con+slo*(lower-launch))-np.log(1+np.exp(con+slo*(lower-launch))))\n", + " upper_limit=dmax/slo *((con+slo*(upper-launch))-np.log(1+np.exp(con+slo*(upper-launch))))\n", + " S_shape_curve=(upper_limit-lower_limit)/interval\n", + " return S_shape_curve" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:14.820708Z", + "start_time": "2020-05-08T23:13:14.811372Z" + } + }, + "outputs": [], + "source": [ + "def rapid_curve(dmax,time_to_max,launch,time,interval):\n", + " \"\"\"\n", + " Design exponential curve with given choice of inputs; \n", + " \n", + " :return: Exponential curve\n", + " \n", + " \"\"\"\n", + " launch=time_index(launch)\n", + " time=time_index(time)\n", + " if time_to_max<=0:\n", + " rapid_curve=step_function(0,dmax,launch,time,interval)\n", + " if interval!=0:\n", + " lower=max(time,launch)\n", + " upper=max(time+interval,launch)\n", + " slo=np.log(1-0.98)*-1/time_to_max\n", + " lower_limit=dmax *(lower+1/slo*np.exp(-(slo*(lower-launch))))\n", + " upper_limit=dmax *(upper+1/slo*np.exp(-(slo*(upper-launch))))\n", + " rapid_curve=(upper_limit-lower_limit)/interval\n", + " return rapid_curve" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:15.567332Z", + "start_time": "2020-05-08T23:13:15.562372Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:16.200429Z", + "start_time": "2020-05-08T23:13:16.194483Z" + } + }, + "outputs": [], + "source": [ + "def time_index(time):\n", + " \"\"\"\n", + " Date in a index format generated by splitting date into year, month and day\n", + " \n", + " :return: time index\n", + " \n", + " \"\"\"\n", + "\n", + " if isinstance(time,date):\n", + " time_index=(time.year+(time.month-1)/12 + (time.day-1)/365)\n", + " else:\n", + " if time.isnumeric():\n", + " time_index=time\n", + " else:\n", + " time_index=1/0\n", + " return time_index " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:13:16.790530Z", + "start_time": "2020-05-08T23:13:16.784473Z" + } + }, + "outputs": [], + "source": [ + "def step_function(start,end,launch,time,interval):\n", + " \"\"\"\n", + " To model piece-wise constant curve \n", + " \n", + " :return: step function\n", + " \n", + " \"\"\"\n", + " if time+interval<=launch:\n", + " step_function=start*interval\n", + " elif time>=launch:\n", + " step_function=end*interval\n", + " else:\n", + " weight=(launch-time)/interval\n", + " step_function=weight*start+(1-weight)*end" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:19:35.066090Z", + "start_time": "2020-05-08T23:19:35.061589Z" + } + }, + "outputs": [], + "source": [ + "datelist = pd.date_range('2019-12-01',end= '2020-12-01',freq='M',name='str').date.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-08T23:19:35.609639Z", + "start_time": "2020-05-08T23:19:35.605303Z" + } + }, + "outputs": [], + "source": [ + "def transition_curve(datelist, initial_val,final_val, ct,t2p,tlag,tstart):\n", + " \"\"\"\n", + " transition for set of dates\n", + " \n", + " :return: transition curve\n", + " \n", + " \"\"\"\n", + " transition_values = []\n", + " for dt in datelist:\n", + " tr_value = initial_val + transition(ct,final_val-initial_val,t2p,tlag,tstart,dt,1/365)\n", + " transition_values.append(tr_value)\n", + " return transition_values" + ] + }, + { + "cell_type": "code", + "execution_count": 531, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-11T19:50:11.292846Z", + "start_time": "2020-05-11T19:50:11.075631Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(transition_curve(datelist,0,1,0,11/12,0,datelist[0]))\n", + "plt.plot(transition_curve(datelist,0,1,5,11/12,0,datelist[0]))\n", + "plt.plot(transition_curve(datelist,0,1,10, 11/12,0,datelist[0]))\n", + "plt.legend(['Slow uptake : λ = 1','Linear uptake : λ = 0.5','Fast uptake : λ = 0'])\n", + "plt.title(\"Variation of uptakes with respect to curve type\")\n", + "plt.xlabel(\"Time(in Months)\")\n", + "plt.grid(b=True,which='major')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 496, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:24:59.385233Z", + "start_time": "2020-05-09T23:24:59.376533Z" + } + }, + "outputs": [], + "source": [ + "china_data = pivoted_data.loc['China',:]\n", + "korea_data=pivoted_data.loc['Korea, South',:]\n", + "italy_data=pivoted_data.loc['Italy',:]" + ] + }, + { + "cell_type": "code", + "execution_count": 497, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:00.754516Z", + "start_time": "2020-05-09T23:25:00.750706Z" + } + }, + "outputs": [], + "source": [ + "xdata = china_data.index\n", + "xdata_korea = korea_data.index\n", + "xdata_italy = italy_data.index" + ] + }, + { + "cell_type": "code", + "execution_count": 498, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:01.884067Z", + "start_time": "2020-05-09T23:25:01.878744Z" + } + }, + "outputs": [], + "source": [ + "ydata = china_data.values\n", + "ydata_korea = korea_data.values\n", + "ydata_italy = italy_data.values" + ] + }, + { + "cell_type": "code", + "execution_count": 500, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:04.329251Z", + "start_time": "2020-05-09T23:25:04.324897Z" + } + }, + "outputs": [], + "source": [ + "part_transition = partial(transition_curve,tstart=xdata[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 501, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:05.598869Z", + "start_time": "2020-05-09T23:25:05.580839Z" + } + }, + "outputs": [], + "source": [ + "china_1=china_data.loc[:'2020-02-18']# slope 1\n", + "china_2=china_data.loc['2020-02-18':]#slope 2" + ] + }, + { + "cell_type": "code", + "execution_count": 502, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:06.848848Z", + "start_time": "2020-05-09T23:25:06.844240Z" + } + }, + "outputs": [], + "source": [ + "x1=china_1.index\n", + "y1=china_1.values\n", + "x2=china_2.index\n", + "y2=china_2.values" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-27T10:08:28.190799Z", + "start_time": "2020-04-27T10:08:28.187232Z" + } + }, + "source": [ + "# Optimization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**China**" + ] + }, + { + "cell_type": "code", + "execution_count": 503, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:09.172344Z", + "start_time": "2020-05-09T23:25:08.907486Z" + } + }, + "outputs": [], + "source": [ + "# transition_curve(t, initial_val,final_val, ct,t2p,tlag,tstart,freq='M')\n", + "popt1, pcov1 = curve_fit(part_transition, x1, y1, bounds=([0,100000,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + " p0=[0,200000,0,1/12,0],maxfev=5000)\n", + "popt2, pcov2 = curve_fit(part_transition, x2, y2, bounds=([0,0,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + " p0=[0,83403,5,1/12,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 504, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:11.286534Z", + "start_time": "2020-05-09T23:25:11.284030Z" + } + }, + "outputs": [], + "source": [ + "#Change x1 \n", + "x1=china_data.index" + ] + }, + { + "cell_type": "code", + "execution_count": 505, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:25:13.124130Z", + "start_time": "2020-05-09T23:25:12.775105Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(figsize=(20,10))\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(x1, part_transition(x1, *popt1), 'g--')\n", + "plt.plot(x2, part_transition(x2, *popt2), 'b--')\n", + "myFmt = mdates.DateFormatter('%m-%d')\n", + "ax.xaxis.set_major_formatter(myFmt)\n", + "plt.xlabel('Date')\n", + "plt.ylabel(\"COVID-19 confirmed cases\")\n", + "plt.plot(xdata,ydata)\n", + "plt.grid(which='both')\n", + "# for xy in zip(xdata, ydata): \n", + "# ax.annotate('(%s, %s)' % xy, xy=xy, textcoords='data') \n", + "plt.title('Curve fit for China')\n", + "plt.xticks(rotation=45)\n", + "ax.legend([\"Cases without mitigation\",\"Cases after mitigation\",\"Confirmed Cases\"],prop={'size': 14})\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 507, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:26:16.807114Z", + "start_time": "2020-05-09T23:26:16.800914Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.72513436e-01, 8.31065809e+04, 9.99999990e+00, 1.34500813e-01,\n", + " 5.07793992e-17])" + ] + }, + "execution_count": 507, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "popt2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **Italy**" + ] + }, + { + "cell_type": "code", + "execution_count": 508, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:04.147377Z", + "start_time": "2020-05-09T23:27:04.144036Z" + } + }, + "outputs": [], + "source": [ + "#2020-04-22\n", + "italy_1=italy_data\n", + "# italy_2=italy_data.loc['2020-03-19':]\n", + "# fig=plt.figure(figsize=(30,20))\n", + "# ax = fig.add_subplot(111)\n", + "# plt.plot(xdata_italy,ydata_italy)\n", + "# for xy in zip(xdata_italy, ydata_italy): \n", + "# ax.annotate('(%s, %s)' % xy, xy=xy, textcoords='data') " + ] + }, + { + "cell_type": "code", + "execution_count": 509, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:05.631763Z", + "start_time": "2020-05-09T23:27:05.626876Z" + } + }, + "outputs": [], + "source": [ + "x_italy1=italy_1.index\n", + "y_italy1=italy_1.values\n", + "# x_italy2=italy_2.index\n", + "# y_italy2=italy_2.values" + ] + }, + { + "cell_type": "code", + "execution_count": 510, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:06.887773Z", + "start_time": "2020-05-09T23:27:06.883843Z" + } + }, + "outputs": [], + "source": [ + "part_transition_italy = partial(transition_curve,tstart=xdata_italy[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 511, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:08.405513Z", + "start_time": "2020-05-09T23:27:08.399168Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "215858" + ] + }, + "execution_count": 511, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(italy_1)" + ] + }, + { + "cell_type": "code", + "execution_count": 512, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:09.757182Z", + "start_time": "2020-05-09T23:27:09.545768Z" + } + }, + "outputs": [], + "source": [ + "popt_italy1, pcov_italy1 = curve_fit(part_transition_italy, x_italy1, y_italy1, bounds=([0,0,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + " p0=[0,215858,0,1/12,0])\n", + "# popt_italy2, pcov_italy2 = curve_fit(part_transition_italy, x_italy2, y_italy2, bounds=([0,0,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + "# p0=[0,215858,5,1/12,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 513, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:10.886745Z", + "start_time": "2020-05-09T23:27:10.882935Z" + } + }, + "outputs": [], + "source": [ + "x_italy1=italy_data.index" + ] + }, + { + "cell_type": "code", + "execution_count": 514, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:12.243444Z", + "start_time": "2020-05-09T23:27:12.000884Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(figsize=(20,10))\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(x_italy1, part_transition(x_italy1, *popt_italy1), 'g--')\n", + "\n", + "# plt.plot(x_italy2, part_transition(x_italy2, *popt_italy2), 'b--')\n", + "\n", + "plt.plot(xdata_italy,ydata_italy)\n", + "plt.grid(which='both')\n", + "myFmt = mdates.DateFormatter('%m-%d')\n", + "ax.xaxis.set_major_formatter(myFmt)\n", + "plt.xlabel('Date')\n", + "plt.ylabel(\"COVID-19 confirmed cases\")\n", + "plt.title('Curve fit for Italy')\n", + "ax.legend([\"Cases after mitigation\",\"Confirmed Cases\"],prop={'size': 14})\n", + "plt.xticks(rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 515, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:13.487653Z", + "start_time": "2020-05-09T23:27:13.481840Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2.06834245e-10, 2.11211628e+05, 1.22852156e-13, 2.92003358e-01,\n", + " 1.51279507e-01])" + ] + }, + "execution_count": 515, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "popt_italy1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Korea**" + ] + }, + { + "cell_type": "code", + "execution_count": 516, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:53.447865Z", + "start_time": "2020-05-09T23:27:53.442744Z" + } + }, + "outputs": [], + "source": [ + "korea_1=korea_data.loc[:'2020-03-09']\n", + "korea_2=korea_data.loc['2020-03-09':]\n", + "# fig=plt.figure(figsize=(30,20))\n", + "# ax = fig.add_subplot(111)\n", + "# plt.plot(xdata_korea,ydata_korea)\n", + "# for xy in zip(xdata_korea, ydata_korea): \n", + "# ax.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')" + ] + }, + { + "cell_type": "code", + "execution_count": 517, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:54.813363Z", + "start_time": "2020-05-09T23:27:54.803217Z" + } + }, + "outputs": [], + "source": [ + "x_korea1=korea_1.index\n", + "y_korea1=korea_1.values\n", + "x_korea2=korea_2.index\n", + "y_korea2=korea_2.values" + ] + }, + { + "cell_type": "code", + "execution_count": 518, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:54.822306Z", + "start_time": "2020-05-09T23:27:54.817072Z" + } + }, + "outputs": [], + "source": [ + "part_transition_korea = partial(transition_curve,tstart=xdata_korea[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 519, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:57.380609Z", + "start_time": "2020-05-09T23:27:57.372765Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "10822" + ] + }, + "execution_count": 519, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "max(korea_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 520, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:27:58.916076Z", + "start_time": "2020-05-09T23:27:58.640303Z" + } + }, + "outputs": [], + "source": [ + "popt_korea1, pcov_korea1 = curve_fit(part_transition_korea, x_korea1, y_korea1, bounds=([0,15000,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + " p0=[0,15000,0,11/12,1/12])\n", + "popt_korea2, pcov_korea2 = curve_fit(part_transition_korea, x_korea2, y_korea2, bounds=([0,0,0,0,0], [99999,9999999, 10.,2.,1.8]),\n", + " p0=[0,10822,5,1/12,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 521, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:28:00.022702Z", + "start_time": "2020-05-09T23:28:00.018830Z" + } + }, + "outputs": [], + "source": [ + "x_korea1=korea_data.index" + ] + }, + { + "cell_type": "code", + "execution_count": 522, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:28:01.138607Z", + "start_time": "2020-05-09T23:28:01.135108Z" + } + }, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 523, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:28:02.692417Z", + "start_time": "2020-05-09T23:28:02.439116Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig=plt.figure(figsize=(20,10))\n", + "ax = fig.add_subplot(111)\n", + "plt.plot(x_korea1, part_transition(x_korea1, *popt_korea1), 'g--')\n", + "plt.plot(x_korea2, part_transition(x_korea2, *popt_korea2), 'b--')\n", + "myFmt = mdates.DateFormatter('%m-%d')\n", + "ax.xaxis.set_major_formatter(myFmt)\n", + "plt.plot(xdata_korea,ydata_korea)\n", + "plt.grid(which='both')\n", + "plt.xlabel(\"Date\")\n", + "plt.ylabel(\"COVID-19 confirmed cases\")\n", + "plt.title('Curve fit for Korea')\n", + "ax.legend([\"Cases without mitigation\",\"Cases after mitigation\",\"Confirmed Cases\"],prop={'size': 14})\n", + "plt.xticks(rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 526, + "metadata": { + "ExecuteTime": { + "end_time": "2020-05-09T23:28:59.530644Z", + "start_time": "2020-05-09T23:28:59.525201Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4.98737190e-01, 1.09065753e+04, 7.65877440e+00, 2.47087666e-01,\n", + " 1.40861752e-01])" + ] + }, + "execution_count": 526, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "popt_korea2\n" + ] + }, + { + "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.3" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "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": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "position": { + "height": "370px", + "left": "1072px", + "right": "20px", + "top": "121px", + "width": "319px" + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}