Forecasting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary:\n",
    "\n",
    "**1. Data Preparation**  --> Once the Final file Generated. Don't need to run this code again.\n",
    "</br>\n",
    "\n",
    "**2. Data Analysis**  --> Plotted some Graphs. ***Key Insights*** is 9th date of every month there is very high revenue generated rather than other dates.\n",
    "</br>\n",
    "\n",
    "**3. Modelling** \n",
    "*  EMD Model \n",
    "  * **mpe**: 117.290244194 \n",
    "  * **mape**:   126.539314872 \n",
    "  * **mae**:  39010137.2227\n",
    "        \n",
    "* Prophet Model\n",
    " * **mpe**:   61.1619676113  \n",
    " * **mape**:   61.2407430813 \n",
    " * **mae**:  42841916.9993\n",
    "        \n",
    "* LSTM(Deep Learning) Model\n",
    " * **mpe**:   45.7350405349  \n",
    " * **mape**:  45.8274334903 \n",
    " * **mae**:   29793772.7105\n",
    "        \n",
    "* Custom Random Forest Regressor with Different Feature Engineering\n",
    "  * **mpe**:  30.328136442  \n",
    "\n",
    "  * **mape**:  30.6254096109\n",
    "  * **mae**:  14928620.3867\n",
    "        \n",
    "#### As we can see from the results of the model the **Custom Random Forest Regressor Model** works much better than any other model so used this model to make predictions for next year.\n",
    "\n",
    "**4. Prediction for Length of Stay**\n",
    "* Less than 1 Day:       \n",
    "  * **MPE->** 0.15909904799  \n",
    "  * **MAPE->** 0.515981181311  \n",
    "  * **MAE->** 2.10404200022\n",
    "   \n",
    "* Less than 10 Days:       \n",
    "  * **MPE->** 0.450843222122   \n",
    "  * **MAPE->** 0.675255548102  \n",
    "  * **MAE->** 12.6044372163\n",
    "  \n",
    "* Less than 20 Days:       \n",
    "  * **MPE->** 0.591580956366  \n",
    "  * **MAPE->** 0.785539388386  \n",
    "  * **MAE->** 14.9153958869\n",
    "   \n",
    "* Less than 30 Days:       \n",
    "  * **MPE->** 0.636744441865 \n",
    "  * **MAPE->** 0.82959026377 \n",
    "  * **MAE->** 16.6874487945\n",
    "   \n",
    "* Greater than 30 Days:       \n",
    "  * **MPE->** 0.717420815754 \n",
    "  * **MAPE->** 0.761713991757  \n",
    "  * **MAE->** 1.91196302931\n",
    "\n",
    "**5. Prediction for next Year**\n",
    "\n",
    "#### Improvements will be using other data like quanatity, types of diseases, Length of Stay and other such factors taking into account for deep learning model. It is time consuming process but it may or maynot improve the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from os import listdir\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from IPython.display import clear_output\n",
    "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
    "\n",
    "from PyEMD import EMD\n",
    "\n",
    "np.random.seed(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['charge_Jan_FEB_2017.csv', 'ICD_2017.csv', 'charge_Nov_dec_2017.csv', 'charge_Jul_Aug_2017.csv', 'charge_mar_apr_2017.csv', 'charge_Sep_oct_2017.csv', 'charge_May_Jun_2017.csv'] ['charge_Jan_Feb_Mar_2016.csv', 'DRG 2015-2018 FEB.csv', 'charge_Dec_2016.csv', 'ICD_2015_2016.csv', 'charge_Oct_Nov_Dec_2015.csv', 'charge_Apr_May_Jun_2016.csv', 'charge_Oct_Nov_2016.csv', 'charge_Jan_Feb_March_2015.csv', 'charge_Jul_Aug_Sep_2015.csv', 'charge_Jul_Aug_Sep_2016.csv', 'charge_Apr_May_Jun_2015.csv']\n",
      "charge_Jan_FEB_2017.csv\n",
      "ICD_2017.csv\n",
      "charge_Nov_dec_2017.csv\n",
      "charge_Jul_Aug_2017.csv\n",
      "charge_mar_apr_2017.csv\n",
      "charge_Sep_oct_2017.csv\n",
      "charge_May_Jun_2017.csv\n",
      "charge_Jan_Feb_Mar_2016.csv\n",
      "DRG 2015-2018 FEB.csv\n",
      "charge_Dec_2016.csv\n",
      "ICD_2015_2016.csv\n",
      "charge_Oct_Nov_Dec_2015.csv\n",
      "charge_Apr_May_Jun_2016.csv\n",
      "charge_Oct_Nov_2016.csv\n",
      "charge_Jan_Feb_March_2015.csv\n",
      "charge_Jul_Aug_Sep_2015.csv\n",
      "charge_Jul_Aug_Sep_2016.csv\n",
      "charge_Apr_May_Jun_2015.csv\n",
      "WARNING *** file size (8402215) not 512 + multiple of sector size (512)\n",
      "WARNING *** file size (1385899) not 512 + multiple of sector size (512)\n",
      "WARNING *** file size (2484943) not 512 + multiple of sector size (512)\n",
      "WARNING *** file size (2140214) not 512 + multiple of sector size (512)\n",
      "WARNING *** file size (4508427) not 512 + multiple of sector size (512)\n"
     ]
    }
   ],
   "source": [
    "# t_df = t_df[['FIN','QTY','PRICE','TOTAL_RRVENUE','TRANS_DATE']]\n",
    "\n",
    "path = '/home/hennestech/FIN/'\n",
    "path1 = '/home/hennestech/FIN_2015_2016/Fin 2015_1016/'\n",
    "file_extension = '.csv'\n",
    "\n",
    "\n",
    "file_name_list = [f for f in listdir(path) if f.endswith(file_extension)] \n",
    "file_name_list1 =  [f for f in listdir(path1) if f.endswith(file_extension)]\n",
    "print(file_name_list,file_name_list1)\n",
    "\n",
    "dfs = []\n",
    "\n",
    "for i in range(len(file_name_list)):\n",
    "    print(file_name_list[i])\n",
    "    if i == 0:\n",
    "        t_df = pd.read_csv(path+file_name_list[i],sep=',')\n",
    "    else:\n",
    "        t_df = t_df.append(pd.read_csv(path+file_name_list[i], sep=',',  header = None,names=list(t_df)))\n",
    "            \n",
    "            \n",
    "for i in range(len(file_name_list1)):\n",
    "    print(file_name_list1[i])\n",
    "    if file_name_list1[i]!= 'DRG 2015-2018 FEB.csv':\n",
    "        t_df = t_df.append(pd.read_csv(path1+file_name_list1[i], sep=',',  header = None,names=list(t_df)))\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "path = '/home/hennestech/FIN/'\n",
    "path1 = '/home/hennestech/FIN_2015_2016/Fin 2015_1016/'\n",
    "\n",
    "\n",
    "df_enc = pd.read_excel(path+'Encounter_2017.xls')\n",
    "df_enc = df_enc.append(pd.read_excel(path+'Encounter_2017_Jan_FEB.xls'))\n",
    "df_enc = df_enc.append(pd.read_excel(path1+'Encounter_2015_2016.xls'))\n",
    "\n",
    "df_icd = pd.read_csv(path+'ICD_2017.csv')\n",
    "df_icd = df_icd.append(pd.read_excel(path+'ICD_2017_Jan_FEB.xls'))\n",
    "df_icd = df_icd.append(pd.read_csv(path1+'ICD_2015_2016.csv'))\n",
    "\n",
    "\n",
    "\n",
    "path2 = '/home/hennestech/DRG_2Q/'\n",
    "df_enc = df_enc.append(pd.read_excel(path2+'DRG ENC 2st Q 2018.xls'))\n",
    "df_icd = df_icd.append(pd.read_excel(path2+'DRG ICD 2st Q 2018.xls'))\n",
    "t_df =   t_df.append(pd.read_csv(path2+'DRG Charg 2st Q 2018.csv',sep=',', header = None,names=list(t_df)))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# calculation of length of stay\n",
    "df_enc['length of stay'] = pd.to_datetime(df_enc['DISCHARGE_DATE']) - pd.to_datetime(df_enc['ADMISSION_DATE'])\n",
    "\n",
    "\n",
    "# filter data\n",
    "t_df = t_df[['FIN','QTY','PRICE','TOTAL_RRVENUE','TRANS_DATE']]\n",
    "df_enc = df_enc[['FIN', 'MRN','ENCOUNTER_TYPE','length of stay']]\n",
    "df_icd = df_icd[['FIN','PRIORITY','ICD_CODE']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING *** file size (460772) not 512 + multiple of sector size (512)\n"
     ]
    }
   ],
   "source": [
    "path = '/home/hennestech/FIN_2015_2016/Fin 2015_1016/DRG 2015-2018 FEB.csv'# Full Path of DRG file\n",
    "path1 = '/home/hennestech/DRG_2Q/DRG 2st Q 2018.xls'\n",
    "df = pd.read_csv(path)\n",
    "df = df.append(pd.read_excel(path1,usecols=[0,1],names=['DRG','FIN']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index(['FIN', 'MRN', 'ENCOUNTER_TYPE', 'length of stay'], dtype='object'),\n",
       " Index(['FIN', 'PRIORITY', 'ICD_CODE'], dtype='object'),\n",
       " Index(['FIN', 'QTY', 'PRICE', 'TOTAL_RRVENUE', 'TRANS_DATE'], dtype='object'))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_enc.columns,df_icd.columns,t_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_enc = pd.merge(df_enc,df,on='FIN')\n",
    "df_icd = pd.merge(df_icd,df,on='FIN')\n",
    "t_df = pd.merge(t_df,df,on='FIN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# DATA MERGE\n",
    "import gc\n",
    "gc.enable()\n",
    "gc.collect()\n",
    "\n",
    "df_com = df_enc.merge(df_icd, on='FIN')\n",
    "df_com['FIN'] = df_com['FIN'].astype('object')\n",
    "del df_enc,df_icd\n",
    "df_com = df_com.merge(t_df, on='FIN')\n",
    "del t_df\n",
    "gc.enable()\n",
    "gc.collect()\n",
    "#df_com = pd.concat([df_com,t_df])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_com['REVENUE'] = df_com['TOTAL_RRVENUE'] / df_com['QTY']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa456d764a8>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_com['ICD_CODE'].value_counts()[:20].plot(kind='bar',figsize=(14,7),title='Top 20 most sold diseases')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = df_com['REVENUE'].groupby([df_com['ICD_CODE']]).mean().sort_values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k.sort_values()[-22:-2].plot(kind='bar',figsize=(14,7),title='Top 20 most costly diseases')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k.sort_values()[:20].plot(kind='bar',figsize=(14,7),title='Top 20 most cheap diseases')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = df_com['REVENUE'].groupby([df_com['ICD_CODE']]).sum().sort_values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2QAAAHUCAYAAABVveuUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XmYZVV5/v3vDQ2CA4PQiAICKiqIE7aEaBwCEXCIoBHFEUcc45TXiEEFx6CJYkgcgoJAXgIiDqCCiCBqTFBaQWakRYUWhEYGURwAn98fe5UciuqpuqrWQb6f66qrzll7emrXqVPn3nvttVNVSJIkSZLm3mq9C5AkSZKkOysDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZK0SpI8OMnNy5j+iyR/NQvbXStJJdm0PT8syT/O9HYkaTYZyCRpCkl+PfL1xyS/HXn+/Bne1kFJfpzkhiTnJ3nupOmPTnJWkhuTfC/JtjO5/ZWV5FVJvr6ceU5P8ru2v5YkOSbJ/LmqcS4kuUuSdye5uP1uFif5cpIde9e2spIckORTvetYVVX14qr6YO86JGllGMgkaQpVdfeJL+BS4G9H2o6c4c39CngysC6wN/CJJI8CSLI2cBxwMLA+8FngC0nmzXANs+Hlbf89CNgIOKBzPTMmSYDjgZ2B5zL87u4PfBx4asfSbucO8lqRpDstA5kkTUOStZN8NMkV7czIvyRZo03bNcmiJO9Kck2SS5LssbR1VdXbq+pHVfXHqvof4LvADm3yk4DfVdXHqur3wIeAewBTdv9qZ6b2b2fSfp3k80k2aGeoftWmbzoy/xOS/CDJ9W3ao0emvSLJT9uZu0uS7JHkkcBHgCe29f9iefuqqq5hCC+PGFn36kne0dZ7dZIjk6zXpp2W5OWTfq6LkjylPd42yalJrk1yQZLdR+Y7OslHkpzU6v5Oks3btNt1q2s/8wtGnr+ybeuaJF9JsslSfqynAo8BdquqhVV1U1X9vqq+UlX/MLK+zZIc137GS5K8amTaAe3nPqrVenaSR6zgso9N8t32e7s8yYETwSu3duN7dZIfA+e29o+31+qv2utjh9a+O/BmYK/2O/1ea79nkiMydDe8LMl+SVZr0+Yl+bckv0yyiOF1ujyPSXJh27cHJ7lLW9eiJH9avtV/fZKtp1pJkn2TXJlkMfCCSdOOTvL29njjJF9Ncl2r89QZ2LerJ/mPDGd9r0/ywyQPatPWbq+9y9o++/eRn3GptUiSgUySpuddwMOAhwKPAp4IjF67sgWwJrAxw1mvw5NsubyVJrk7sB1wXmt6CPDDielV9UeGD9gPWcZqngM8G7hvq+87wEeBewI/A/Zt29oI+BLDmasNgE8AJyRZN8n6wL8AO1XVPYDHAedW1ZnAG4HT2tnCjVfgZ5oP7A4sGml+C8PZpb8CNgVuAg5s0/6b4azTxPKParV/Lck6wMnAIcCGwIuAQ5M8YGTdzwPe1pa5guF3tVxJ9mw/298C9wLOBP7/pcz+N8B3qurKZaxvdeAE4H+B+wC7Av+U5Akjsz0DOBRYDziFIeyuyLI3Aa9rP+PjWs23CbHA0xhem49sz/+P4fWwAcNZ188mWaOqvgh8GDi8/U63b/MfCVwP3A/YnuF3+MI27XXAjm19f8nwmlue57ZlHtRqektrP4LbBqvdgB9V1QWTV9DC42uAJwAPZjizvDRvBS5ieJ3cG9i/rWNV9u3EPr0/wxnr5wHXtmkHMryWH9p+xgcC+yyrFkkCA5kkTdfzgf2q6ur2ofy93PphFeBm4F1V9Yeq+jrwdeBZy1phkgCfAv6nqk5rzXdn+FA86nqGs2RL86mq+mk7M/U14IKq+mZV3Qwcy60f0HcDzqqqY6rq5qo6DFjMbT/kbptkrar6+VQfkJfjP5P8CrgKWBt408i0VwL7VNXlVfU7htD0nLYPjmU4m3LvNu/zgM+2+p/BEAyPrKpbquoMhlD5dyPrPqaqflBVNzGEu0ewYl4JvLedrbyp1fRXSe41xbwbAn86O5jkPu3sx/VJrmvNfwWsVVUfaK+DHwGfBvYcWc+pVXVyVd0C/NdIrctctqq+V1VntH3wY4bXzWjQA3hfVV1XVb9tyxxRVde2n+39DMHsflPtiAxnFR8PvLmqbqyqK4CDRmp/NvCh9vtbAqzIdVv/NjL/P3Nr6D4C2D3JXdvzF7Z9MZVnA5+sqgur6tcsO2zfxBC47tv24bda+6rs25uAdRjCYFXVeVV1VTuD9lLgDW2fX89woGPP5dQiSQYySVpZLTRszHC2acLPgNHubUta0Bidfp/lrPogYHNue7bg1wwfAEetA9ywjPWMnrX57RTP794e34fb/gwTdW5SVdcyhM7XA79Icvyks1Ar4pVVtQ7DGb+N2/Ym9t9mDGfjrmsB5kyG/0kbtCB5MvDs1kXuOQxna2DYP4+fWK4t+3cMZx0mjHajvHHk512ezRmu35tY7xKGYL3pFPP+cnSbLWisBzwWWGtkfVtMqvXNbV8sr9ZlLptkmyQntq57vwLeyRASR102+iTJ2zJ0x7ye4azOWlMsM7ov1gKWjGz/3xjOHMLwuxxd/+TX0VQmz38fgKr6KcPvf7d2NnVH4OilrGNltvs+4HLgG61b5Jtb+6rs2xMZzs7+J3Blko+1s9r3AdYAzhtZ5xcZrp1cVi2SZCCTpJVVVcXwQXrzkeb7Aj8feb5hkrUmTb98aetMcgDDkfsntyP/E84DHj4y32rAttzapXFVXM5tf4aJOn8O0K6H2onhw+alDANWANTKbKR1c/wg8B/tebVt7FhV6418rVVVV7fFjmI4g/IEhlD0v639MuBrk5a7e1W9cQVK+Q2w+sR1Pc1oOLoMePGkda9dVd+fYl2nMJzFm+rs2ej6Lpy0vntU1TNWoNblLftJ4AfA/VvofTeQSev40++pXaP19wxnGNdj6I7325FlJv9OL2M4GLD+yPbXqart2vQrGEL1hPuuwM80ef7Rv4fDGQ5E7Mlw1vCqpaxjhbdbVddX1RuqanOG0P72JI9lFfZtDT5cVY9k6LL8cOANra6b2zIT61y3qjZYTi2SZCCTpGk6Ctgvw4AZGzFclzV6vdEawDuSrJlhGPQnAZ+bakVJ3sXQfXDnqrpu0uSTgbUzDDV/F4Zuf78B/mcGfobjgUcmeVaGQRpexPAB96tJNkny1NaN7PcMH85vactdCWyWNojJCvoUcP8ku7TnnwAOSLIZDNezJfnbkfmPY7hObl/gqBbiYDjr8Mgkz0myRtu/OyR54ArUcDnDWa/nt8EZXsNtz2p+guGD8sQgDesn+bsp1gPwZYbBV45LsmCiFuAvRub5n7aeN2YYqGJekocl2W6qFU6yvGXvAVxfVb9O8hDgFctZ3z0Yus0tYbi28d3ceiYPht/plu3sJVX1E+B04INJ7pFktSRb5dZ7iR0DvCnJvZNsyG2vn1ya14/Mvw/wmZFpxzIckHg1QxfGpTkGeHmSB7YzU+9c2oxJnp5k4me6nuH1ewursG/ba21B66L4G+APwC2tG+ihwL8l2TCDzVoQXlYtkmQgk6RpeidwPsOZqrMYBs4YvY7mpwxHzH/B8EHtJVV1yeSVtJD1ToZreX6SW+919maAdv3PbsCrgOsYziDs3q6nWiU1XPv2dIbQ80uGgQye1kLh6gwDY/yiTXs0wxkWgK+2n++qDCPdrci2fstwhuwdremDDNfVnZrkBoYzYNuNzH8jQ2DcieE6sIn2a4FdgJcwnJW4nOH6veWGw3ad1suB/YCrGc60fH9k+lGtxs+3rmpnsZTRA2sYXOVp7Wf4DMOH7B8DzwSe0ua5qT1+DEPXuiUMZxmX24VyBZZ9E0Mw+TXDgC2fmWo9I74EfKvVeEn7+ZeMTD8auCtwTZKJs5HPZTibdiFwTdvGxBnB/wC+zfD6/y5DUFqeo4FvABcD5zDy91JVN7QaN2H4vU+pqr7AcAuIb7e6TlrG9rYGTmPo3vst4F+r6vRV3LfrAYcx/C1e0pY/qE17I8PrcSHD6+GrwEQ33ylrWUbtku5EcutBR0nSTEiyK/AfVbWy11xJd1pJ3g9sVFWTR4uUpD9r3ixSkiR11QbzeDHD0PqSdKdil0VJktRNktcxdIH9bFV9r3M5kjTn7LIoSZIkSZ14hkySJEmSOjGQSZIkSVInDuoxDRtuuGFtscUWvcuQJEmSNKa+//3vX11V85c3n4FsGrbYYgsWLlzYuwxJkiRJYyrJz1ZkPrssSpIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6mde7AEmSJEmaTaecev8ZW9dOO/54xtYFniGTJEmSpG4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSepkuYEsyaFJrkpy7kjbvyS5MMnZSb6QZL2RaW9LsijJRUl2GWnftbUtSrLPSPuWSb6b5OIkn0myZmu/S3u+qE3fYi63IUmSJEmzbUXOkB0G7Dqp7WRg26p6GPAj4G0ASbYB9gQe0pb5WJLVk6wOfBR4MrAN8Nw2L8AHgAOraivgWuBlrf1lwLVV9QDgwDbfnGxDkiRJkubCcgNZVX0LuGZS29eq6ub29HRg0/Z4N+Doqvp9Vf0EWARs374WVdUlVfUH4GhgtyQBdgSObcsfDuw+sq7D2+NjgZ3a/HOxDUmSJEmadTNxDdlLgRPb402Ay0amLW5tS2vfALhuJNxNtN9mXW369W3+udiGJEmSJM26VQpkSfYFbgaOnGiaYraaRvtMrms627idJHsnWZhk4ZIlS6aaRZIkSZJWyrQDWZK9gKcBz6+qiRCzGNhsZLZNgcuX0X41sF6SeZPab7OuNn1dhq6Tc7GN26mqg6tqQVUtmD9//tQ7RZIkSZJWwrQCWZJdgbcCT6+qG0cmHQ/s2UYv3BLYCvgecAawVRvtcE2GQTmOb0HuG8Cz2vJ7AceNrGuv9vhZwKlt/rnYhiRJkiTNunnLmyHJUcATgQ2TLAb2YxhV8S7AyW0MjNOr6lVVdV6SY4DzGboyvraqbmnreR1wErA6cGhVndc28Vbg6CTvBc4EDmnthwD/lWQRw1mrPQHmYhuSJEmSNBfiCaGVt2DBglq4cGHvMiRJkiStgFNOvf+MrWunHX+8QvMl+X5VLVjefDMxyqIkSZIkaRoMZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUyXIDWZJDk1yV5NyRtnsmOTnJxe37+q09SQ5KsijJ2Um2G1lmrzb/xUn2Gml/VJJz2jIHJUnvbUiSJEnSXFiRM2SHAbtOatsHOKWqtgJOac8Bngxs1b72Bj4OQ/AB9gP+Atge2G8k/Hy8zTux3K5jsA1JkiRJmnXzljdDVX0ryRaTmncDntgeHw6cBry1tR9RVQWcnmS9JPdu855cVdcAJDkZ2DXJacA6VfV/rf0IYHfgxM7bkCRJkrQS9t9//7Fc17ib7jVk96qqKwDa941a+ybAZSPzLW5ty2pfPEV7721IkiRJ0qyb6UE9MkVbTaO99zZuv9Fk7yQLkyxcsmTJyi4uSZIkSbcz3UB2ZesmSPt+VWtfDGw2Mt+mwOXLad90ivbe27idqjq4qhZU1YL58+cvbTZJkiRJWmHTDWTHAxOjGO4FHDfS/qI2EuIOwPWtK+BJwM5J1m8DbewMnNSm3ZBkhzby4YsmravXNiRJkiRp1i13UI8kRzEMfLFhksUMIxkeAByT5GXApcAebfYTgKcAi4AbgZcAVNU1Sd4DnNHme/fE4BvAqxlGclybYaCNE1t7z21IkiRJ0qxbkVEWn7uUSTtNMW8Br13Keg4FDp2ifSGw7RTtv+y1DUmSJEmaCzM9qIckSZIkaQUZyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpk1UKZEnelOS8JOcmOSrJWkm2TPLdJBcn+UySNdu8d2nPF7XpW4ys522t/aIku4y079raFiXZZ6R91rchSZIkSbNt2oEsySbA64EFVbUtsDqwJ/AB4MCq2gq4FnhZW+RlwLVV9QDgwDYfSbZpyz0E2BX4WJLVk6wOfBR4MrAN8Nw2L3O0DUmSJEmaVavaZXEesHaSecBdgSuAHYFj2/TDgd3b493ac9r0nZKktR9dVb+vqp8Ai4Dt29eiqrqkqv4AHA3s1paZ1W2s4j6RJEmSpBUy7UBWVT8H/hW4lCGIXQ98H7iuqm5usy0GNmmPNwEua8ve3ObfYLR90jJLa99gDrZxO0n2TrIwycIlS5YsbbdIkiRJ0gpblS6L6zOcTdoSuA9wN4auf5PVxCJLmTZT7TO5jds3Vh1cVQuqasH8+fOnmkWSJEmSVsqqdFn8G+AnVbWkqm4CPg88BlivdWEE2BS4vD1eDGwG0KavC1wz2j5pmaW1Xz0H25AkSZKkWbcqgexSYIckd23Xae0EnA98A3hWm2cv4Lj2+Pj2nDb91Kqq1r5nGyFxS2Ar4HvAGcBWbUTFNRkG5Ti+LTOr21iFfSJJkiRJK2ze8meZWlV9N8mxwA+Am4EzgYOBrwBHJ3lvazukLXII8F9JFjGctdqzree8JMcwhLmbgddW1S0ASV4HnMQwguOhVXVeW9db52AbkiRJkjSrph3IAKpqP2C/Sc2XMIxeOHne3wF7LGU97wPeN0X7CcAJU7TP+jYkSZIkabat6rD3kiRJkqRpMpBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6WaVAlmS9JMcmuTDJBUn+Msk9k5yc5OL2ff02b5IclGRRkrOTbDeynr3a/Bcn2Wuk/VFJzmnLHJQkrX3WtyFJkiRJs21Vz5D9G/DVqnow8HDgAmAf4JSq2go4pT0HeDKwVfvaG/g4DOEK2A/4C2B7YL+JgNXm2XtkuV1b+1xsQ5IkSZJm1bQDWZJ1gMcDhwBU1R+q6jpgN+DwNtvhwO7t8W7AETU4HVgvyb2BXYCTq+qaqroWOBnYtU1bp6r+r6oKOGLSumZ7G5IkSZI0q1blDNn9gCXAp5OcmeRTSe4G3KuqrgBo3zdq828CXDay/OLWtqz2xVO0M0fbkCRJkqRZtSqBbB6wHfDxqnok8Btu7To4lamuzapptC/LrG0jyd5JFiZZuGTJkuWUIUmSJEnLtyqBbDGwuKq+254fyxDQrmxdAWnfrxqZf7OR5TcFLl9O+6ZTtDNH27iNqjq4qhZU1YL58+dPNYskSZIkrZRpB7Kq+gVwWZIHtaadgPOB44GJUQz3Ao5rj48HXtRGQtwBuL51NzwJ2DnJ+m2gjZ2Bk9q0G5Ls0EY+fNGkdc32NiRJkiRpVs1bxeX/HjgyyZrAJcBLGELeMUleBlwK7NHmPQF4CrAIuLHNS1Vdk+Q9wBltvndX1TXt8auBw4C1gRPbF8ABc7ANSZIkSZpVqxTIquosYMEUk3aaYt4CXruU9RwKHDpF+0Jg2ynafznb25AkSZKk2baq9yGTJEmSJE2TgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUifzehcgSZIkacUs3ufbM7auTQ943IytS9PnGTJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUySoHsiSrJzkzyZfb8y2TfDfJxUk+k2TN1n6X9nxRm77FyDre1tovSrLLSPuurW1Rkn1G2md9G5IkSZI022biDNkbgAtGnn8AOLCqtgKuBV7W2l8GXFtVDwAObPORZBtgT+AhwK7Ax1rIWx34KPBkYBvguW3eudqGJEmSJM2qVQpkSTYFngp8qj0PsCNwbJvlcGD39ni39pw2fac2/27A0VX1+6r6CbAI2L59LaqqS6rqD8DRwG5zsY1V2SeSJEmStKJW9QzZR4B/BP7Ynm8AXFdVN7fni4FN2uNNgMsA2vTr2/x/ap+0zNLa52IbkiRJkjTrph3IkjwNuKqqvj/aPMWstZxpM9U+k9u4nSR7J1mYZOGSJUummkWSJEmSVsqqnCF7LPD0JD9l6Oq3I8MZs/WSzGvzbApc3h4vBjYDaNPXBa4ZbZ+0zNLar56DbdxOVR1cVQuqasH8+fOXtk8kSZIkaYVNO5BV1duqatOq2oJhwIxTq+r5wDeAZ7XZ9gKOa4+Pb89p00+tqmrte7YRErcEtgK+B5wBbNVGVFyzbeP4tsysbmO6+0SSJEmSVsa85c+y0t4KHJ3kvcCZwCGt/RDgv5IsYjhrtSdAVZ2X5BjgfOBm4LVVdQtAktcBJwGrA4dW1XlzuA1JkiRJmlUzEsiq6jTgtPb4EobRCyfP8ztgj6Us/z7gfVO0nwCcMEX7rG9DkiRJkmbbTNyHTJIkSZI0DQYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqZF7vAiRJkqRx8qHnPG3G1vUPn/nyjK1Lf54MZJIkSZpzH33VqTO2rtd+YscZW5c01+yyKEmSJEmdGMgkSZIkqRO7LEqSJP2ZuuDBW8/Yura+8IIZW5ekW3mGTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ04qIckSdI0PfTwh87o+s7Z65wZXZ+k8WcgkyRJbLHPV2Z0fT894Kkzt7L91525dQHsf/3Mrk+SVoGBTJKkOTLWoUeS1IXXkEmSJElSJwYySZIkSerEQCZJkiRJnXgNmSTpz8rG3zhrRtf3i79+xIyuT5KkUQYySdJKO+XU+8/o+nba8cczuj5Jku4o7LIoSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkThzUQ5LG1P777z/W65MkSavOQCbpTm3xPt+e0fVtesDjZnR9kiTpz5tdFiVJkiSpE8+QSZp1H3rO02Z0ff/wmS/P6PokSZJ6MZBJK+GCB289Y+va+sILZmxdAB991akztq7XfmLHGVuXJEmSls4ui5IkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTh72/s9p/3Rlc1/Uzty7goYc/dMbWdc5e58zYuiRJkqSZZiCbRVvs85UZW9dPD3jqjK1LkiRJ0niwy6IkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqZNqBLMlmSb6R5IIk5yV5Q2u/Z5KTk1zcvq/f2pPkoCSLkpydZLuRde3V5r84yV4j7Y9nq2jfAAAesElEQVRKck5b5qAkmattSJIkSdJsW5UzZDcD/1BVWwM7AK9Nsg2wD3BKVW0FnNKeAzwZ2Kp97Q18HIZwBewH/AWwPbDfRMBq8+w9styurX0utiFJkiRJs2ragayqrqiqH7THNwAXAJsAuwGHt9kOB3Zvj3cDjqjB6cB6Se4N7AKcXFXXVNW1wMnArm3aOlX1f1VVwBGT1jXb25AkSZKkWTUj15Al2QJ4JPBd4F5VdQUMoQ3YqM22CXDZyGKLW9uy2hdP0c4cbUOSJEmSZtUqB7Ikdwc+B7yxqn61rFmnaKtptC+znNnaRpK9kyxMsnDJkiXLKUOSJEmSlm+VAlmSNRjC2JFV9fnWfGXrCkj7flVrXwxsNrL4psDly2nfdIr2udrGbVTVwVW1oKoWzJ8/f6pZJEmSJGmlrMooiwEOAS6oqg+PTDoemBjFcC/guJH2F7WREHcArm/dDU8Cdk6yfhtoY2fgpDbthiQ7tG29aNK6ZnsbkiRJkjSr5q3Cso8FXgick+Ss1vZPwAHAMUleBlwK7NGmnQA8BVgE3Ai8BKCqrknyHuCMNt+7q+qa9vjVwGHA2sCJ7Ys52oYkSZIkzappB7Kq+h+mvgYLYKcp5i/gtUtZ16HAoVO0LwS2naL9l7O9DUmSJEmabTMyyqIkSZIkaeUZyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwOZJEmSJHViIJMkSZKkTgxkkiRJktSJgUySJEmSOjGQSZIkSVInBjJJkiRJ6sRAJkmSJEmdGMgkSZIkqRMDmSRJkiR1YiCTJEmSpE4MZJIkSZLUiYFMkiRJkjoxkEmSJElSJwYySZIkSerEQCZJkiRJnRjIJEmSJKkTA5kkSZIkdWIgkyRJkqRODGSSJEmS1ImBTJIkSZI6MZBJkiRJUicGMkmSJEnqxEAmSZIkSZ0YyCRJkiSpEwMZkGTXJBclWZRkn971SJIkSbpzuNMHsiSrAx8FngxsAzw3yTZ9q5IkSZJ0Z3CnD2TA9sCiqrqkqv4AHA3s1rkmSZIkSXcCBjLYBLhs5Pni1iZJkiRJsypV1buGrpLsAexSVS9vz18IbF9Vfz9pvr2BvdvTBwEXzVAJGwJXz9C6ZsM412dt02Nt02Nt02Nt02Nt02Nt02Nt0zPOtcF413dnqW3zqpq/vJnmzdDG7sgWA5uNPN8UuHzyTFV1MHDwTG88ycKqWjDT650p41yftU2PtU2PtU2PtU2PtU2PtU2PtU3PONcG412ftd2WXRbhDGCrJFsmWRPYEzi+c02SJEmS7gTu9GfIqurmJK8DTgJWBw6tqvM6lyVJkiTpTuBOH8gAquoE4IROm5/xbpAzbJzrs7bpsbbpsbbpsbbpsbbpsbbpsbbpGefaYLzrs7YRd/pBPSRJkiSpF68hkyRJkqRODGSSJEmS1InXkGnsJbk7sCvD7QluBi4GvlZVf+xamP5sJVnAyOutqi7sXJIkrbIk84CXAc8A7gMUw61+jgMOqaqbOpZHkvsCv6qq65JsASwALqyqc3vWpT9PSdYB3sZwy6sTq+q/R6Z9rKpeM2e1eA3Z3Bv3D3vjVF+SZwNvAX4I/DXwvwxndh8KPL+qzulV24Qk9wRex/BP7RDgn4C/BC4A3l9V13YsD4Ak8xnecG4GflJVv+5c0sQ/3quq6ndJArwY2A44H/hkVd3coaYnAB8CrgMeBXwHWB+4CXhhVV021zUtT5ItgUcC54/Te0mS9YGbq+qG3rVMGKf3tlFJdq2qr7bH6wIfBh4NnAu8qaqu7FzfOsD8qvrxpPaHVdXZncqaqGEXYHdgE0bCxcT+7FjXWP5fSHIUw/vb4Qz3YYXhf8NewD2r6jk96mq17QO8Evg98K/A/8fwHrwDQ1j8cK/alifJk6rq5I7bX5chWOwOTNyE+CqGoH1AVV3XqzYY3wMBST7HcJD/dOClDP/rn1dVv0/yg6rabs5qMZDNnXH/sDeO9SU5G9ihqm5MsiFwZFXtkuRhwCeq6jFzXdNkSU4AzgHWAbZuj48BngQ8vKp261jbNsBBwBbAfYEzgY2AbwJvqKrrO9Z2LrB9+91+ALg/8EVgR4CqemmHms4Edq6qJS3ofLiqnpHkScBbqmrnua5psiRfrKrd2+PdgI8ApwGPAf65qg7rWNt9gAOA3YC7Az9vkw4F3tfxn+7YvbeNGv3Hn+RTwC+ATwLPBJ4w8fvuVNuzGV5jVwFrAC+uqjPatDn9wDJFbR8BHggcwW3DxYsYAvcbOtY2lv8XklxUVQ9ayrQfVdUD57qmke2fx3BG7K7AT4H7tffiuwHfrapte9W2PEkurar7dtz+ScCpwOFV9YvWtjFD0P6bqnpSr9paLWN5ICDJWVX1iJHn+wJPAZ4OnDyn729V5dccfTF8GJ7fHm8JfKE9fhJDFzzru31N53DrgYO1gTNHpp3be5+1Os5q3wP8fKppHWs7HXhQe7w9w5s1wCuAYzvXdv7I4+8Dq408/2Gnms4eebw68IOR5+f13F8jdYz+DfwvsGV7vGGv/TZSz6nAE9vjZwIHAncD3gsc3HOfjdt726T6Rl9nZ02a1vs95Czg3u3x9sCFwDMn9mvn2n60lPYwBLKu+22klrH5v9D+J+wx6f12NeA5DKGn5z47u31fneEAwGiN3f/fA8cv5etLwG8613bRdKaNSX1T/h3PUV0XjL7OWttewHnAz+ayFq8hm1urV9WS9vhSYHOAqjq5HenrbRzrOwH4apJvAk8GPgt/6g6STjVNtlrrnnUP4O5JtqiqnybZAFizc21rV9VFAFX1vSSfaI8/meRNfUvjsiQ7VtWpDEdDNwN+1vZbLwuTHAKcwnCW5zSAJHdl+JAwDka7Ncyrqp8AVNXVSXpfV7lBVZ3W6vl8kn2r6jfA25P07B44ju9tozZK8maG97R1kqTaJwP6D761elVdAX96D/lr4MtJNuW2r8Uefpdk+6r63qT2RwO/61HQiHH9v7An8AHgY0muZXjNrQt8o03r6QdJ/pvhIM4pwOFJvsrQa+L8rpUNHge8AJjc5T8MByt6+lmSf2Q46HolQJJ7MVwKMA5d7a9NsgfwuWrX/ydZjeHgQM/LOr7E8Pr6+kRDVR2e5Erg3+eyEAPZ3Br3D3tjV19VvTXJU4BtgHfXrX20r2O43mgc/DPDUWMY+iB/argkiq2Bd/Uqqvlxkncw/E6fyXC0myRr0P/v/+XAEUn2B64HzmpdBtcH3typplcynD18DMMb9KGtvYBdOtU02cOT/IrhQ8BdkmxcVb9Isib930eWJHkBw5myv2MI2rRrBHsGi7F7b5vkkwwf3GHo0rMhw77cmPY329ENSe5f7fqxqroiyRMZuhc/pGtl8BKGYHEPbu0GtRnwK4YPoj2N5f+Fqvopw9kwWjhMVV3dq55JXs7wAb2AYxlCzvOAi4CPdqxrwunAjVX1zckTklzUoZ5RzwH2Ab6ZZKPWdiXDGbxnd6vqVpMPBACsR+cDAVX1j0tp/yqw1VzW4jVkc6h9CH4FQ7j4IXBoVd2SZG1go6r6mfXdMSVZneHv6eZ28eojGLqpXNG5rvUYLiaf+J0eUFU3tAuAt66q03vWB5Bka4brQOYxfKg6oxxBc6W13/XWVfV/HWu4L8PF+NswBIm3tA/wGzB0Zfxcp7p8b5umJA9n6I61aFL7GsCzq+rIPpXdppaNGQb1CLC42jU0vY3x/wVHLlY343YgIMmDGd4/vlsjA55lZLClOanDQKY7qiQHV9XevesASPJ44MqquijJXzGMCnVBVX2lc2maIUn2r6r9e9ehO5ck21XVD3rXMY4yBqM8rowk76+qf+pcw9iPXDwV33+nb9zfQ9JxhMokrwdey3At2SMYBjs7rk2b00GLevdNV9O6bY2tMa3vP3sXAH8a6esA4L+SvAf4IMMAJG9K8i9di1uGJGMRZqeS5ODeNUzh+70LWJ4x3W8AJHla7xqmMqbvbaNe3buApRmD19uZSRYleU+GEWXHRpKDJn39O/CaiecdS3s7w8idLwf+guEM8fMZro0ai/+pSzHW779j8LewLGP7HtIc0nHbrwAeVcNItk8E3pFkYnTWOR2noPc1JLrVWL/ZMIb1VdW41PQkYFuGEPZzYJMahnI/gGF0t7f0LG4ZxmVQlKmM3QeDqvpS7xpWwNjttxGPBr7cu4gpjMv7yJSq6hW9a1iG3q+3s4EXAs8Fjk/yG+Ao4Oh2rVRPz2S4VvFr3Ppeuyf9X28Bftse/4bhNihU1dkZ7jc3lu4A77+9/xaWahzeQ5Icv7RJQM+BvFaf6KbYBt15InBsks2Z489IdlnUWEvyOoZ/rlcneQDDIAsPY7jI9+Xj0L0iyblVtW2StYArgPtU1W/b9QPnVNVYHbnV0iW5H8MR5MsZznoeyK03c33LGHzI058puz2vvMldipJszxB69gAuq473qWwDjbyHIfC8pap+nuSSqrpfr5paXR9g6Jr1TYb7LZ1QVe/PMHLxt6uq20AtbZCd1zEM6vHvDL/LZzIMjvLu0et7NLUkCxi5NrCqeo5u+ydtII+ljVD5maq619xXBUlOBd5cVWeNtM1j+Kz5/Kqas0GfDGRzKGN6p/IJ41hfkvMm/kEk+Qrwqar6QjuK8b6qeuxc1zRZ+wf3GGAthiOiD2YYjekJwCVV9ap+1d1eklOrascxqONP13+0AQLeyjCq1rnAe6vqxg41fYvhCPu6DP88Ps1wM9edGd6cx2G/je1BiiRPZxgcoPeQ4yssyTur6t2da/gIw2t/HnASsBNwIsN7yJlV1e0s+5i/3s6sqkdO0R7g8VONhjfXkjyKYaCbrwCvq6ot+lYEGUYu3prhvoVfb20B1qiqP3Ss6xiGIdrXBh7EcCDsGOBvgY2r6oW9aoOx/1t4AvAhhhGoHwV8h2HE4puAF1ZV16Hvk5wIfLCqvjHFtG9V1eM7lEWG23fcPNVAQEkeW1XfmbNaDGRzJ2N6p/IJ41hfkouq6kHt8RlV9eiRaWdX1cPmuqapJPlLoKrq9CT3Zwi1lzLcfLnbyFVJJl/wHoYRDSfuTdZt/40e3U7yIYZuC58Gdme4n9WLOtT0pw94SS6tqvtONa2ncT5IkeS3DN2gTmQItidV1S296lkRk3/PnWo4j6m7Pa/BEMi27VnbGL/enldV/91r+yuqhZ3XAH9ZVS/oXMsNDAdbJ7pjjX4I/D3wY2DfqjqlQ21nVdUj2v66guGG5NWe/7D3//sx/1s4E9i5qpYk2RL4cFU9I8mTGM7Q7tyrNq0YryGbW9tNhIsRi4HTk/yoR0GTjGN9xyY5DHg38IUkbwQ+z3AE+dJONd1OjQw1XsP9ev61YzmjfspwT573Mlw3EODbDEccexvtn70T8Oiquqmdpfphp5r+mOSBDGfI7ppkQVUtbEdDx+F+VXDb9+2NquoLAFV1Wusm1dOFDDfZfBbwD8Cnk3wBOKrn2YoM922bchJDCOqt2gfPiYM3Ex+S/0j/wbfG9vU2GsaSzG9tS5a+RB81HPn+KGNwL62qWurvrHWz3xY4sn3vov0tnND228TzcTh7MLZ/CwzXQk289i8FNgeoqpPbGXitpCRfrqo5G4yq9xv9nc21SfbIcHdyAJKsluQ59L1T+YSxq6+q9mXoBngUw82C3wNM3LDv+T1qWhm9R16qqqcDnwMOBh7eroG6qap+Vv3vvbRukmck+TvgLhNdYts/4V7/fP8R+BJwBMOZurclWcQwNPQ7OtU02bFJDmvXu30hyRuT3DfJS+h/kKKq6tqq+mRV7QQ8HDgfOCBJzy4z1wFbVdU6k77uwXAkvrevJPk2w8GSTwHHJNmX4Uzjt7pWNt6vN5Lsn+RqhoMBP0qyJMk7x6CuG5L8aoqvG5ZxgKCrqrqlqn7IcP1WDwsz3CONqnrpRGPrdXJDp5pGjfPfwsIkhyR5HvDfDJ+bJq7L634w8Y7498AwAuOcscviHEqyBcOdyndkCDhhOBL/DWCfqvpJt+IY//ruiJI8qsZgNMgkd2MIsw9gOBO6aeeSSPLpSU37VNWVGW7yemT7QN9dkg2Ba8ep612SFzMMZXx/4C4M1118EfhAVV3fsa6ldutMsnmvgwBJ3gscX1Xfm2LaB6rqrR3KmlzHWHZ7brW9mPF8vb2JYWCKvSf+P7UPyx8HvlpVB/aqTTMrSWoMPrCO8d/CGgwBYhuGHiaHVtUtSdZmOJvX+wCslsNA1knG7E7lk41Tfe2I2a6MjBzEMHBA1w8pd0RJHs5wHcMnetdyR5OON6+8o0jyxKo6rXcdunNo1808afL/qdZ98WvjcM2nVlySNRlGVry8qr7ezvY8hmFwj4Or88Bn+vOT4VYPb2MYL+HESd2gP1ZVr5mzWgxk/bQLLx8JnF9jMjTpqHGoL8mzGe7j9UPgrxm6jq0GPJRh1LtxGPZ+nEdeWpOhi2K1538NbMfwOz2xV10T7khhO2Mw+MOEO9J+G1dJ3l9V/9S7juVJck5VPbRzDWP5eku75cjKTtN4SnIkw3Vad2XoZnx3br1mPFW1V8fygLH+W3gww21a/gi8nqGL/e7Aj4C9quqCjuWNrSSfY/gdng68lGFUyudV1e8z6bYas16LgWzuJPliDXcDJ8luwEcY+vk+Fnh/VR3Wr7rxrC/DKIE71DDi2IYMXdl2SfIw4BPV8T4zEzLeIy/9EHhiVV2b5C0M3aBOYBhOe2FVva1jbcsK2y+oNiT+HNe0rJtX7lhVd5vLeqYs5A5wkGIqPYNFkoMmNzHcUPgIgKp6/ZwXNVpM8sylTWJ4n5s/l/XcpoAxfr0t6wPTXH+Y0qpLGzk5wy14fs5wT89bkrEZZXGc/xa+BfwLQ4g9gOE2Mp8Bnga8cVwuARg3aSN7jjzfl6Eb9NOBk+fyPcRRFufW5iOP38rwAe8nLWicAhzWpapbjWN9YRgdEIbhtDcCqKqz26nmcTDuIy9NDMjyHOBxNdy0+gDgBwyn6nt5O8sI2wxdVeba41j6zSu3n/typrSs/faf9NlvwHKDxcZzWcskz2Q4uPQ1bh3dc0+g+/WdzWcYRrab6gjpWnNcy2Rj+3oDHr6UAQFC//2mlbda69VxN4azZOsC1zBcq7VGz8Kacf5buEdVfQkgyXuq6ujW/qUk7+pY17i7S5LVJs5wVtX7kixmGEzp7nNZiIFsbo3+s503cRFy6+o2Dl2NxrG+E4CvJvkmw1GLzwIkuSe3HTa9p3Eemv9XSbatqnOBqxk+pPyW4W+/9yir4xi2TwdurCmGaE9yUYd6pjKO+23CuAaLrRkGtdmV4Z48P0+yX1Ud3rGmUWcD/9r+Tm8jyd90qOc2JTCmr7eq6j56nGbUpxhGy1wd2Bf4bJJLgB2Ao5e14BwZ278FbjuS4ocnTVtzLgu5g/kSw0B2X59oqKrDk1zJHI82aiCbWxNH88KQyjeuql+0I0Lj8I9l7OqrqrcmeQrDB6r9q2rij+ZahuvbuquqfdvIS0dx68hLezOMvNR7aP5XAUe2rov/r717D9WsqsM4/n0E8ZJGZmEQhIxkmVrT2B8iKU6YOSSkhF2sJkgJUXPUpCi7wGhFiiaaWhqCWQkGjU40mJeGElLInCmvmZeCkPDWxXFGUXv6Y613Zs/rOWccx3nXOuc8HzhwZq/33ed39qy9z17vXuv3e5ySGve3lDVu324a2eaD7SV0MNi2vWSGtsMmGcsMujtuA10OLGw/A5wu6SDgJ3VqcesPJIZOp9QLnMqxkwxkCj33t5hbPkT5m/l3249J+jFwBHDlVBlSG+j5XLhU0m6219m+bLSxrmu/ZYb3zWu2vzTN9lF5pYnJGrIOSHoDsJ8HxYV70jI+Sc9QPm0fXeyGHfZ54GHgbNu3Tjq22UKl2OeRwL6UD2H+Afza9r+bBgbUwfa7KOsDbq7bdgB2tP18g3hG/W0q3fS33o7bIK5DKTdTL3syrFpku0FY43EIOJnyqfsPKAu4T2kbVd967W8xt9Q1WudSlkec32NWxZwLc482lRkZJmq51hMuY5ABWWxRvaH/hO2fto5lqMZ1AGUed9NsWr1mXhpSSQWN7SdaxzKdOi//KXd4Yeqpv43r+bj1RtJC4HjgY8CjwC9styqEO4pppkLGtn3OxIJ5BdLfYntRqZn5Dcrf02soWQMBsD0+Fa+5Xs6F2XYN6YWkZZTEJ6NlMWspM7COBU72BMu4ZMriBM3wtEeUE6bpHOQ6B/oU4K3ASuBm4FTgLEon7WpA5lKo90+SWt9MTZV56WDgPEmtMy8J+Cbl/1GURdMvApfYXt4qrhrbwZRsUE9T1vdcA7yJEuPSOmWgGx31t26PW683BZL2pSTx+CTwFGWtm2wvbhHPFJ6dYtuuwInAnpT/5yZ67m8xJ71AOR92AnZnMCBrrfNzodtrSOdOBBbWbJ4XAqtsHy7ph8ANTHBpTJ6QxUaSbqB8MnA7JSHFHpTFoMtsr20ZW8/UcWp+SWdQPvX5/ChJi6QFwOXAjba/1zC2O4GvUjJpXQEssX2HSj2Va52irlPq+bhJ+uIUmzfeFNieaNaqkZqU6DbgBNsP1W2P2F7QIp6Z1Mysy4ATgOuAC2w/3jCebvtbzC2SjqIkpFgJLLe9vnFIm5kt50Jv15CeSbobeJ9L3bE9gFtsH1TbJlrLME/IYmiBa50gST+iZOV7W10QH9PrOfPSUuCDtp8cbbD9iKRPU1KANxuQUTJ53gQgabntO2p8D5QHezGNbo+b7QtG3w9uCj5HyZB2wXTvm4CPUp6QrZZ0Y42nq05WEwOcSUlqcDWwyJtKVrTUbX+LOeds4Djb97YOZBpdnwsdX0N6diXwB0l3AIcB34WNSzyenmQgGZDF0MYFtPXx7aMZjL0iPWde2nE4GBux/YSk1nVdhlNRNoy15dH99Lo+bj3eFLjUBlxR16ccA5wB7CXpcmDF6CarFUnnU2qlXQEcaHu8Dl5LXfe3mDtsH9o6hi3o9lzo/BrSsyWUv1XvAC60/QBsXGs/0czKmbIYG0l6iU3zkAXsAqynkzVuPes185KkuzxNpfmZ2iZh0N+GfY36751ttx4wdqnn4zZ2U3BpzzcFdeB4HPBx2x9oHMv/KFk8X2TzG7vm196e+1vEJPV8LvR8DenZILPn1cB5LTN7ZkAWsR10lHlpOMjerIncTMVrLDcFERExm/SS2TNTFiO2Uc+Zl2z3UHA85gnbPRVbjoiI2JIuMntmQBax7b7PpsxLv2Es8xKQtNARERERHRnL7LmoZWbPTFmM2EaS1tpeWL+/3/Z+g7Y1vaTCjYiIiIhC0m3AST1k9swTsoht123mpYiIiIh4uZ4ye+YJWcQ26jnzUkRERET0LQOyiIiIiIiIRpIRKyIiIiIiopEMyCIiIiIiIhrJgCwiIiIiIqKRDMgiImLOk7Ru8P2+klZJekjS/ZKuk7SXpMMl/UfSGkl/kfQ7SUe/gn0vlXSPpHsl3SfprLpdkr4m6a+SHpS0WtL+g/f9TdLd9es+SedK2qm27S1pg6S1g6+l2+PYREREW0l7HxER84aknYFfAWfa/mXdthh4c33JbbaPrtsXAtdL2mD71mn2twQ4HTjS9mN1/5+pzacAhwDvsb1e0pHASkn7236uvmax7Scl7QZcUb8+W9seHtU4jIiIuStPyCIiYj45Hrh9NBgDsL3a9j3jL7S9FlgOnDrD/r4CnGX7sfqe52xfWdu+DHzB9vradhPwe+BTU/ysdcBJwDGS3viqfrOIiJiVMiCLiIj55ADgj1vx+ruAd27t/iS9Hnid7YfHmu4E9h9/PYDt/wKPAm+vm/YZm7LYTRHTiIh47WTKYkRExPS0HfY3UwHQ4c/LlMWIiHkgT8giImI+uRc4aCte/17g/q3dX33a9aykBWNNi4D7ptqRpN2BvYEHtyK+iIiY5TIgi4iI+eRnwCGSPjzaIOkoSQeOv1DSu4GvA5fOsL/vAOdJekt9z06STqtt5wMXS9qlth0BvL/GMP6zdgMuA663/a9X9ZtFRMSslCmLERExb9jeUFPZXyTpIuAF4M/AMmBP4FBJa4BdgceB06bLsFj3t0rSXsAtkkbTEa+qzZcAewB3S3oJ+CfwEdsbBrtYXd+3A7ACOGfQto+ktYN/X2X74lf9y0dERJdkzzSVPSIiIiIiIraXTFmMiIiIiIhoJFMWIyIitkDS2cBxY5t/bvtbLeKJiIi5I1MWIyIiIiIiGsmUxYiIiIiIiEYyIIuIiIiIiGgkA7KIiIiIiIhGMiCLiIiIiIhoJAOyiIiIiIiIRv4Pg52YObzZjk4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k.sort_values()[-20:].plot(kind='bar',figsize=(14,7),title='Top 20 most Revenue Genearated by diseases')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = df_com['QTY'].groupby([df_com['MRN'],df_com['FIN']]).sum()\n",
    "m = pd.DataFrame(m)\n",
    "m1 = df_com['ICD_CODE'].groupby([df_com['MRN'],df_com['FIN']]).unique()\n",
    "m['ICD_CODE'] = m1\n",
    "m1 = df_com['PRIORITY'].groupby([df_com['MRN'],df_com['FIN']]).unique()\n",
    "m['PRIORITY'] = m1\n",
    "m1 = df_com['PRICE'].groupby([df_com['MRN'],df_com['FIN']]).sum()\n",
    "m['PRICE'] = m1\n",
    "m1 = df_com['TOTAL_RRVENUE'].groupby([df_com['MRN'],df_com['FIN']]).sum()\n",
    "m['TOTAL_REVENUE'] = m1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del m1,k\n",
    "gc.enable()\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = pd.DataFrame()\n",
    "new_df['MRN'] = df_com['MRN']\n",
    "new_df['FIN'] = df_com['FIN']\n",
    "new_df['TRANS_DATE'] = df_com['TRANS_DATE']\n",
    "new_df['length of stay'] = df_com['length of stay']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#new_df = df_com[['MRN','FIN','TRANS_DATE','length of stay']]\n",
    "del df_com\n",
    "gc.enable()\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = new_df.sort_values(by=['MRN','FIN','TRANS_DATE'],ascending=[True,True,True])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = new_df.drop_duplicates(subset=['MRN','FIN'],keep='last')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = m.reset_index()\n",
    "new_df = new_df.reset_index()\n",
    "\n",
    "new_df['QTY'] = m['QTY']\n",
    "new_df['ICD_CODE'] = m['ICD_CODE']\n",
    "new_df['PRIORITY'] = m['PRIORITY']\n",
    "new_df['PRICE'] = m['PRICE']\n",
    "new_df['TOTAL_REVENUE'] = m['TOTAL_REVENUE']\n",
    "\n",
    "new_df['TRANS_DATE'] = pd.to_datetime(new_df['TRANS_DATE'])\n",
    "new_df = new_df.sort_values(by='TRANS_DATE')\n",
    "\n",
    "new_df = new_df.set_index(['TRANS_DATE'])\n",
    "\n",
    "new_df = new_df.drop(['index'],axis=1)\n",
    "\n",
    "new_df.to_csv('/home/hennestech/final_2018.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Data Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from os import listdir\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from IPython.display import clear_output\n",
    "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
    "from sklearn import metrics\n",
    "\n",
    "from PyEMD import EMD\n",
    "plt.rcParams[\"figure.figsize\"] = [14,8]\n",
    "pd.set_option('float_format', '{:f}'.format)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = pd.read_csv('/home/hennestech/final_2018.csv')\n",
    "plt.rcParams[\"figure.figsize\"] = [14,8]\n",
    "\n",
    "new_df['Date'] = new_df['TRANS_DATE'].apply(lambda x: x[:10])\n",
    "\n",
    "new_df['Date'] = pd.to_datetime(new_df['Date'])\n",
    "\n",
    "k = new_df['QTY'].groupby([new_df['Date']]).sum()\n",
    "k.index = pd.to_datetime(k.index)\n",
    "\n",
    "k.plot(kind='line',figsize=(12,7),title='Quantity Over Time')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = new_df['TOTAL_REVENUE'].groupby([new_df['Date']]).sum()\n",
    "k.index = pd.to_datetime(k.index)\n",
    "k.plot(kind='line',figsize=(12,7),title='Total Revenue Over Time')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df['length of stay'] = pd.to_timedelta(new_df['length of stay'])\n",
    "new_df['length of stay'][new_df['length of stay'] < pd.Timedelta(0)] = pd.Timedelta(0)\n",
    "\n",
    "n_bins = 100\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(13, 6))\n",
    "ax.hist(new_df['length of stay'].dt.days*1 + new_df['length of stay'].dt.seconds/3600, n_bins)\n",
    "\n",
    "ax.grid(True)\n",
    "ax.legend(loc='right')\n",
    "ax.set_title('LENGTH OF STAY (histogram)')\n",
    "ax.set_xlabel('Length of stay (days)')\n",
    "ax.set_ylabel('Frequency of occurrence')\n",
    "plt.show()\n",
    "\n",
    "print('max length of stay, in days: ', max(new_df['length of stay'].dt.days + new_df['length of stay'].dt.seconds/(3600*24)))\n",
    "print('min length of stay, in days: ', min(new_df['length of stay'].dt.days + new_df['length of stay'].dt.seconds/(3600*24)))\n",
    "print('mean length of stay, in days: ', np.mean(new_df['length of stay'].dt.days + new_df['length of stay'].dt.seconds/(3600*24)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "new_df['Days'] = new_df['length of stay'].dt.days\n",
    "k = new_df['TOTAL_REVENUE'].groupby([new_df['Days']]).mean()\n",
    "k.sort_values()[-20:].plot(kind='bar',title='Average Maximum Revenue with respect to length of stay')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k.sort_values()[:20].plot(kind='bar',title='Average Minimum Revenue with respect to length of stay')\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = new_df.set_index(['TRANS_DATE'])\n",
    "new_df['month'] = new_df.Date.dt.month.values\n",
    "new_df['year'] = new_df.Date.dt.year.values\n",
    "new_df['Month_Year'] = new_df['month'].astype('str') +'-' +new_df['year'].astype('str')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = new_df['TOTAL_REVENUE'].groupby([new_df['Date']]).sum()  #new_df['TOTAL_REVENUE']\n",
    "emd = EMD()\n",
    "IMFs = emd(s.values)\n",
    "\n",
    "# PLOT OF INTRINSIC MODE FUNCTIONS (IMFs) OF TOTAL_REVENUE \n",
    "\n",
    "plt.figure(figsize=(15,2))\n",
    "plt.plot(s)#df_res_m['TOTAL_RRVENUE'])\n",
    "plt.grid()\n",
    "plt.title('TOTAL_REVENUE')\n",
    "plt.show()\n",
    "\n",
    "t = pd.DataFrame()\n",
    "for i in range(len(IMFs)):\n",
    "    t['IMF_'+str(i)] = IMFs[i,:]\n",
    "    plt.figure(figsize=(15,2))\n",
    "    plt.plot(IMFs[i,:])\n",
    "    plt.grid()\n",
    "    plt.title('IMF_'+str(i))\n",
    "    plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CALCULATION OF IMFs PARAMETERS\n",
    "\n",
    "std_list = []\n",
    "std_loc_list = []\n",
    "mean_list = []\n",
    "zero_cr_list = []\n",
    "freq_list = []\n",
    "\n",
    "for i in range(len(IMFs)):\n",
    "    \n",
    "\n",
    "    if i != len(IMFs) - 1:\n",
    "        try:\n",
    "            first = np.where(IMFs[i]==IMFs[i][((IMFs[i][:-1] * IMFs[i][1:]) < 0)][0])[0][0]\n",
    "            last = np.where(IMFs[i]==IMFs[i][((IMFs[i][:-1] * IMFs[i][1:]) < 0)][-1])[0][0]\n",
    "\n",
    "            std = IMFs[i].std() / IMFs[-1].mean()\n",
    "            std_loc = IMFs[i][-500:].std() / IMFs[i].std()\n",
    "            mean = IMFs[i].max() / IMFs[-1].mean()\n",
    "\n",
    "            zero_cr = ((IMFs[i][:-1] * IMFs[i][1:]) < 0).sum()\n",
    "            freq = len(IMFs[i][first:last]) / (((IMFs[i][:-1] * IMFs[i][1:]) < 0).sum() - 1)\n",
    "        except IndexError:\n",
    "#             print('IndexError')\n",
    "            std = np.nan\n",
    "            mean = np.nan\n",
    "            zero_cr = np.nan\n",
    "            freq = np.inf\n",
    "        \n",
    "    else:\n",
    "        std = IMFs[i].std() / IMFs[-1].mean()\n",
    "        std_loc = IMFs[i][-500:].std() / IMFs[i].std()\n",
    "        mean = IMFs[i].max() / IMFs[-1].mean()\n",
    "        \n",
    "        zero_cr = 1\n",
    "        freq = len(IMFs[-1]) / 2\n",
    "        \n",
    "    std_list.append(std)\n",
    "    std_loc_list.append(std)\n",
    "    mean_list.append(mean)\n",
    "    zero_cr_list.append(zero_cr)\n",
    "    freq_list.append(freq)\n",
    "    \n",
    "#    print(i, 'std: ', std, ', mean: ', mean,\n",
    "#          ', zero-crossings: ', zero_cr,\n",
    "#          ', freq:, ', freq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for the estimation of the model\n",
    "def get_model_estimation(model, dfX, dfY, window, test_window, window_step, sign_a = 1):\n",
    "    pred_val = []\n",
    "    true_val = []\n",
    "    \n",
    "    nn = 0\n",
    "    date_start =  len(dfX) - test_window - window\n",
    "    \n",
    "    while date_start + window < len(dfX):\n",
    "        n_points = len(dfX) - (date_start + window)\n",
    "#         print(n_points, date_start, date_start+window) \n",
    "        \n",
    "        nn = nn + 1\n",
    "        if nn == 1:\n",
    "            #print(date_start,window)\n",
    "            model = model.fit(dfX[date_start:date_start+window].values,\n",
    "                              dfY[date_start:date_start+window].values) \n",
    "\n",
    "        if nn == window_step:\n",
    "            nn = 0\n",
    "        #print(date_start,window,dfX.shape)\n",
    "        #print(dfX.iloc[date_start+window:].shape,dfY.iloc[date_start+window].shape)\n",
    "        #print(model.predict(dfX.iloc[date_start+window:]))\n",
    "        pred_val.append(sign_a * model.predict(np.array(dfX.iloc[date_start+window]).reshape(-1,1)))\n",
    "        \n",
    "        true_val.append(dfY.iloc[date_start+window])#.values.reshape(len(dfY.iloc[date_start+window:])))\n",
    "        \n",
    "        \n",
    "        date_start = date_start + 1\n",
    "#         clear_output()\n",
    "    #print('Returns',true_val, pred_val)\n",
    "    return true_val, pred_val\n",
    "\n",
    "# function for prediction\n",
    "def get_prediction(model, X, Y, sign_a): \n",
    "    model = model.fit(X,Y)\n",
    "    prediction = sign_a * model.predict(Y)#.iloc[-1])\n",
    "    \n",
    "    return prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FORECASTING MODEL FOR IMFs\n",
    "\n",
    "model = RandomForestRegressor(n_estimators = 30)\n",
    "\n",
    "# model = xg.XGBClassifier()\n",
    "# model = LogisticRegression(C=1e3,n_jobs=-1)\n",
    "# model = LinearRegression()\n",
    "# model = svm.SVC(kernel='linear', C=1.0)\n",
    "# model = svm.SVC(kernel='rbf', gamma=0.7, C=1.0)\n",
    "# model = svm.SVC(kernel='poly', degree=3, C=1.0)\n",
    "# model = svm.LinearSVC(C=1.0)\n",
    "\n",
    "\n",
    "window = 3\n",
    "\n",
    "pred_list = []\n",
    "true_list = []\n",
    "for i in range(len(IMFs)):\n",
    "    #print(i)\n",
    "    X = t[['IMF_'+str(i)]].shift()\n",
    "    Y = t[['IMF_'+str(i)]]\n",
    "    \n",
    "    X = (X[1:])\n",
    "    #X = X.values.reshape(-1,1)\n",
    "    Y = (Y[1:])\n",
    "    #Y = Y.values.reshape(-1,1)\n",
    "    if freq_list[i] > 3:\n",
    "        true, pred = get_model_estimation(model, X, Y, window=window, test_window=100, window_step=1, sign_a = 1.0)\n",
    "    else:\n",
    "        true, pred = get_model_estimation(model, X, Y, window=window, test_window=100, window_step=1, sign_a = -1.0)\n",
    "    #print('List',len(pred),len(true))\n",
    "    pred_list.append(np.array(pred))\n",
    "    true_list.append(np.array(true))\n",
    "    \n",
    "    \n",
    "pred_arr = np.array(pred_list)\n",
    "true_arr = np.array(true_list)\n",
    "\n",
    "total_pred = pred_arr[:,:].sum(axis=0)\n",
    "total_true = true_arr[:,:].sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CALCULATION OF MODEL INDICATORS\n",
    "\n",
    "mpe = np.sum(((total_pred - total_true)) / total_true) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / total_true) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "\n",
    "signs = []\n",
    "for i in range(len(total_true)-1):\n",
    "    if np.sign(total_pred[i+1] - total_pred[i]) == np.sign(total_true[i+1] - total_true[i]):\n",
    "        signs.append(1.0)\n",
    "    else:\n",
    "        signs.append(0.0)\n",
    "        \n",
    "sign_acc = np.sum(signs) / len(signs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=t.index)[-len(total_pred):]\n",
    "\n",
    "df_total['total_pred'] = total_pred\n",
    "df_total['total_true'] = total_true\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='predicted TOTAL_RRVENUE values')\n",
    "plt.plot(df_total['total_true'] , label='actual TOTAL_RRVENUE values')\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "print('mpe: ', mpe, '\\n',\n",
    "       'mae: ', mae, '\\n',\n",
    "       'mape: ', mape, '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prophet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fbprophet import Prophet\n",
    "\n",
    "s = new_df['TOTAL_REVENUE'].groupby([new_df['Date']]).sum()\n",
    "s.plot()\n",
    "plt.ticklabel_format(style='plain', axis='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = s[:-100]\n",
    "train = pd.DataFrame(train)\n",
    "train['ds'] = train.index\n",
    "train.columns = ['y','ds']\n",
    "test = s[-100:]\n",
    "test = pd.DataFrame(test)\n",
    "test['ds'] = test.index\n",
    "test.columns = ['y','ds']\n",
    "\n",
    "model = Prophet().fit(train)\n",
    "\n",
    "data_forecast = s.index\n",
    "data_forecast = pd.DataFrame(data_forecast)\n",
    "data_forecast.columns = ['ds']\n",
    "forecast = model.predict(data_forecast)\n",
    "\n",
    "pred_values = forecast[['ds','yhat']].iloc[-100:]\n",
    "pred_values = pred_values.iloc[::-1]\n",
    "data_plot = pd.DataFrame()\n",
    "#data_plot['True-Values'] = pd.Series(s)\n",
    "#data_plot.index = s.index\n",
    "test.index = test['ds']\n",
    "pred_values.index = pred_values['ds']\n",
    "data_plot = pd.DataFrame(data_plot)\n",
    "data_plot['Real-Values'] = test['y']\n",
    "#data_plot['Predicted-Values'] = pred_values['yhat']\n",
    "k = forecast['yhat']\n",
    "k.index = forecast['ds']\n",
    "data_plot['Forecasted'] = k[::-1]\n",
    "data_plot.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_pred = pred_values['yhat']\n",
    "#total_pred = total_pred.reshape(total_pred.shape[0])\n",
    "total_true = test['y']\n",
    "mpe = np.sum(((total_pred - total_true)) / total_true) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / total_true) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print (mpe,mape,mae)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deep Learning Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import LSTM, Dense, Act\n",
    "import numpy as np\n",
    "\n",
    "look_back = 1\n",
    "trainX, trainY = train['y'][:-look_back], train['y'][look_back:]\n",
    "testX, testY = test['y'][:-look_back],test['y'][look_back:]\n",
    "\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], 1, 1))\n",
    "testX = np.reshape(testX, (testX.shape[0], 1, 1))\n",
    "\n",
    "data_dim = 1\n",
    "timesteps = 1\n",
    "\n",
    "# expected input data shape: (batch_size, timesteps, data_dim)\n",
    "model = Sequential()\n",
    "model.add(LSTM(32, return_sequences=True,\n",
    "               input_shape=(timesteps, data_dim)))  # returns a sequence of vectors of dimension 32\n",
    "model.add(LSTM(32, return_sequences=True))  # returns a sequence of vectors of dimension 32\n",
    "model.add(LSTM(32))  # return a single vector of dimension 32\n",
    "model.add(Dense(1))\n",
    "\n",
    "model.compile(loss='mean_squared_error',\n",
    "              optimizer='rmsprop',\n",
    "              metrics=['mean_squared_error'])\n",
    "\n",
    "model.fit(trainX, trainY,\n",
    "          batch_size=64, epochs=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PLOT OF THE RESULT\n",
    "y_pred = model.predict(testX) * 9000000\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index[:-1])\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test['y']\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='predicted TOTAL_RRVENUE values')\n",
    "plt.plot(df_total['total_true'] , label='actual TOTAL_RRVENUE values')\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_pred = y_pred\n",
    "total_pred = total_pred.reshape(total_pred.shape[0])\n",
    "total_true = test['y'][:-1]\n",
    "mpe = np.sum(((total_pred - total_true)) / total_true) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / total_true) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print (mpe,mape,mae)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom Random Forest Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = new_df['TOTAL_REVENUE'].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test['TOTAL_REVENUE']\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='predicted TOTAL_RRVENUE values')\n",
    "plt.plot(df_total['total_true'] , label='actual TOTAL_RRVENUE values')\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_pred = y_pred\n",
    "total_true = test['TOTAL_REVENUE']\n",
    "mpe = np.sum(((total_pred - total_true)) / total_true) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / total_true) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print (mpe,mape,mae)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Prediction for next Year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s['TOTAL_REVENUE']],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction.csv')  # If want to save next years predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction Length of stay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df['Less than 1 Day'] = new_df['Days'] < 1\n",
    "new_df['Less than 10 Days'] = new_df['Days'] < 10\n",
    "new_df['Less than 20 Days'] = new_df['Days'] < 20\n",
    "new_df['Less than 30 Days'] = new_df['Days'] < 30\n",
    "new_df['Greater than 30 Days'] = new_df['Days'] > 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom Random Forest Regressor\n",
    "\n",
    "As in all cases it is predicting best."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'Less than 1 Day'\n",
    "s = new_df[classes].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test[classes]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='Patients for '+ classes)\n",
    "plt.plot(df_total['total_true'] , label='Patients for '+ classes)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "total_pred = y_pred\n",
    "total_true = test[classes]\n",
    "mpe = np.sum(((total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print ('MPE->',mpe,' MAPE->',mape,' MAE->',mae)\n",
    "\n",
    "\n",
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)\n",
    "\n",
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction for '+ classes)\n",
    "\n",
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s[classes]],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction for '+ classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction '+classes + '.csv')  # If want to save next years predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'Less than 10 Days'\n",
    "s = new_df[classes].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test[classes]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='Patients for '+ classes)\n",
    "plt.plot(df_total['total_true'] , label='Patients for '+ classes)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "total_pred = y_pred\n",
    "total_true = test[classes]\n",
    "mpe = np.sum(((total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print ('MPE->',mpe,' MAPE->',mape,' MAE->',mae)\n",
    "\n",
    "\n",
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)\n",
    "\n",
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction for '+ classes)\n",
    "\n",
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s[classes]],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction for '+ classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction '+classes + '.csv')  # If want to save next years predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'Less than 20 Days'\n",
    "s = new_df[classes].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test[classes]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='Patients for '+ classes)\n",
    "plt.plot(df_total['total_true'] , label='Patients for '+ classes)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "total_pred = y_pred\n",
    "total_true = test[classes]\n",
    "mpe = np.sum(((total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print ('MPE->',mpe,' MAPE->',mape,' MAE->',mae)\n",
    "\n",
    "\n",
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)\n",
    "\n",
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction for '+ classes)\n",
    "\n",
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s[classes]],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction for '+ classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction '+classes + '.csv')  # If want to save next years predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'Less than 30 Days'\n",
    "s = new_df[classes].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test[classes]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='Patients for '+ classes)\n",
    "plt.plot(df_total['total_true'] , label='Patients for '+ classes)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "total_pred = y_pred\n",
    "total_true = test[classes]\n",
    "mpe = np.sum(((total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print ('MPE->',mpe,' MAPE->',mape,' MAE->',mae)\n",
    "\n",
    "\n",
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)\n",
    "\n",
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction for '+ classes)\n",
    "\n",
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s[classes]],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction for '+ classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction '+classes + '.csv')  # If want to save next years predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'Greater than 30 Days'\n",
    "s = new_df[classes].groupby([new_df['Date']]).sum()\n",
    "s = pd.DataFrame(s)\n",
    "\n",
    "s['Day'] = s.index.day.values\n",
    "s['Week'] = s.index.week.values\n",
    "s['WeekDay'] = s.index.weekday.values\n",
    "s['month'] = s.index.month.values\n",
    "s['year'] = s.index.year.values\n",
    "\n",
    "train = s[:-100]\n",
    "test = s[-100:]\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(train[train.columns[1:-1]].values,train[train.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(test[test.columns[1:-1]].values)\n",
    "\n",
    "# PLOT OF THE RESULT\n",
    "\n",
    "df_total = pd.DataFrame(index=test.index)\n",
    "\n",
    "df_total['total_pred'] = y_pred\n",
    "df_total['total_true'] = test[classes]\n",
    "\n",
    "plt.figure(figsize=(11,5))\n",
    "plt.plot(df_total['total_pred'], label='Patients for '+ classes)\n",
    "plt.plot(df_total['total_true'] , label='Patients for '+ classes)\n",
    "plt.legend(loc='best')\n",
    "plt.grid()\n",
    "plt.show()\n",
    "\n",
    "total_pred = y_pred\n",
    "total_true = test[classes]\n",
    "mpe = np.sum(((total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mape = np.sum((np.abs(total_pred - total_true)) / (total_true+1)) / len(total_true)\n",
    "mae = np.sum(np.abs(total_pred - total_true)) / len(total_true)\n",
    "print ('MPE->',mpe,' MAPE->',mape,' MAE->',mae)\n",
    "\n",
    "\n",
    "t = pd.date_range(start=str(s.index[-1])[:10],end='2018-12-30',freq='D')\n",
    "t = t[1:]\n",
    "t = pd.DataFrame(index=t)\n",
    "t['Day'] = t.index.day.values\n",
    "t['Week'] = t.index.week.values\n",
    "t['WeekDay'] = t.index.weekday.values\n",
    "t['month'] = t.index.month.values\n",
    "t['year'] = t.index.year.values\n",
    "\n",
    "np.random.seed(15)\n",
    "model = RandomForestRegressor(n_estimators = 100,max_depth=8)\n",
    "model.fit(s[s.columns[1:-1]].values,s[s.columns[0]].values)\n",
    "\n",
    "y_pred = model.predict(t[t.columns[:-1]].values)\n",
    "\n",
    "pd.Series(y_pred,index=t.index).plot(title='Next Year Prediction for '+ classes)\n",
    "\n",
    "m = pd.Series(y_pred,index=t.index)\n",
    "k = pd.concat([m,s[classes]],axis=1)\n",
    "k.columns = ['Predicted Values','Real Values']\n",
    "k.plot(title='Next Year Prediction for '+ classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = ''\n",
    "m.to_csv(path+'Prediction '+classes + '.csv')  # If want to save next years predictions."
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}