Cumulative COVID-19 Global Analysis and Predictions .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing all the libraries"
   ]
  },
  {
   "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",
    "import tensorflow as tf\n",
    "keras = tf.keras\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import plotly.graph_objects as go\n",
    "physical_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_memory_growth(physical_devices[0], True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(X, y, time_steps=1):\n",
    "    Xs, ys = [], []\n",
    "    for i in range(len(X) - time_steps):\n",
    "        v = X.iloc[i:(i + time_steps)].values\n",
    "        Xs.append(v)\n",
    "        ys.append(y.iloc[i + time_steps])\n",
    "    return np.array(Xs), np.array(ys)\n",
    "\n",
    "class ResetStatesCallback(keras.callbacks.Callback):\n",
    "    def on_epoch_begin(self, epoch, logs):\n",
    "        self.model.reset_states()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing CoronaVirus Cases Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "confirmed_df = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv')\n",
    "death_df = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv')\n",
    "recovered_df = pd.read_csv('https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_recovered_global.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Pre Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confirmed Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "confirmed_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "death_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recovered_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "confirmed_df = confirmed_df.iloc[:, 4:]\n",
    "confirmed_df = confirmed_df.sum(axis=0)\n",
    "confirmed_df.index = pd.to_datetime(confirmed_df.index).strftime('%Y-%m-%d')\n",
    "confirmed_df = pd.DataFrame(confirmed_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Death Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "death_df = death_df.iloc[:, 4:]\n",
    "death_df = death_df.sum(axis=0)\n",
    "death_df.index = pd.to_datetime(death_df.index).strftime('%Y-%m-%d')\n",
    "death_df = pd.DataFrame(death_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recovered Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recovered_df = recovered_df.iloc[:, 4:]\n",
    "recovered_df = recovered_df.sum(axis=0)\n",
    "recovered_df.index = pd.to_datetime(recovered_df.index).strftime('%Y-%m-%d')\n",
    "recovered_df = pd.DataFrame(recovered_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overall Corona Cases"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scaling Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confirmed Cases Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler_confirm = MinMaxScaler()\n",
    "scaler_confirm = scaler_confirm.fit(confirmed_df)\n",
    "train_confirm = scaler_confirm.fit_transform(confirmed_df)\n",
    "train_confirm = pd.DataFrame(train_confirm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Death Cases Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler_death = MinMaxScaler()\n",
    "scaler_death = scaler_death.fit(death_df)\n",
    "train_death = scaler_death.transform(death_df)\n",
    "train_death = pd.DataFrame(train_death)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recovered Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler_recovered = MinMaxScaler()\n",
    "scaler_recovered = scaler_recovered.fit(recovered_df)\n",
    "train_recovered = scaler_recovered.fit_transform(recovered_df)\n",
    "train_recovered = pd.DataFrame(train_recovered)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing Data For Time Series Analysis Using LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_steps = 1\n",
    "X_train_confirm, y_train_confirm = create_dataset(train_confirm, train_confirm, time_steps)\n",
    "X_train_death, y_train_death = create_dataset(train_death, train_death, time_steps)\n",
    "X_train_recovered, y_train_recovered = create_dataset(train_recovered, train_recovered, time_steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Building"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model for Confirmed Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "tf.random.set_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "confirm_model = keras.Sequential()\n",
    "confirm_model.add(keras.layers.LSTM(units=128,input_shape=(X_train_confirm.shape[1], X_train_confirm.shape[2]),return_sequences = True))\n",
    "confirm_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "confirm_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "confirm_model.add(keras.layers.LSTM(units=128))\n",
    "confirm_model.add(keras.layers.Dropout(rate=0.2))\n",
    "confirm_model.add(keras.layers.Dense(units=1))\n",
    "confirm_model.compile(loss='mean_squared_error', optimizer='adam') \n",
    "reset_states = ResetStatesCallback()\n",
    "confirm_model.fit(X_train_confirm, y_train_confirm,epochs=500,batch_size=16,shuffle=False,callbacks = [reset_states],verbose = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model for Death Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "tf.random.set_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "death_model = keras.Sequential()\n",
    "death_model.add(keras.layers.LSTM(units=128,input_shape=(X_train_death.shape[1], X_train_death.shape[2]),return_sequences = True))\n",
    "death_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "death_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "death_model.add(keras.layers.LSTM(units=128))\n",
    "death_model.add(keras.layers.Dropout(rate=0.2))\n",
    "death_model.add(keras.layers.Dense(units=1))\n",
    "death_model.compile(loss='mean_squared_error', optimizer='adam') \n",
    "reset_states = ResetStatesCallback()\n",
    "death_model.fit(X_train_death, y_train_death,epochs=500,batch_size=16,shuffle=False,callbacks = [reset_states],verbose=0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model for Recovered Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "tf.random.set_seed(42)\n",
    "np.random.seed(42)\n",
    "\n",
    "recovered_model = keras.Sequential()\n",
    "recovered_model.add(keras.layers.LSTM(units=128,input_shape=(X_train_recovered.shape[1], X_train_recovered.shape[2]),return_sequences = True))\n",
    "recovered_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "recovered_model.add(keras.layers.LSTM(units=128,return_sequences = True))\n",
    "recovered_model.add(keras.layers.LSTM(units=128))\n",
    "recovered_model.add(keras.layers.Dropout(rate=0.2))\n",
    "recovered_model.add(keras.layers.Dense(units=1))\n",
    "recovered_model.compile(loss='mean_squared_error', optimizer='adam') \n",
    "reset_states = ResetStatesCallback()\n",
    "recovered_model.fit(X_train_recovered, y_train_recovered,epochs=500,batch_size=16,shuffle=False,callbacks = [reset_states],verbose=0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicting The Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "DAYS_TO_PREDICT = int(input('Enter Number Of Days You Want to Predict : '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting Results For Confirmed Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "confirm_test_seq  = y_train_confirm[-1:]\n",
    "confirm_preds = []\n",
    "for _ in range(DAYS_TO_PREDICT):\n",
    "    y2_confirm = confirm_test_seq.reshape((len(confirm_test_seq ), time_steps, 1))\n",
    "    confirm_pred = confirm_model.predict(y2_confirm)\n",
    "    confirm_preds.append(confirm_pred)\n",
    "    confirm_new_seq = confirm_test_seq.flatten()\n",
    "    confirm_new_seq = np.append(confirm_new_seq,[confirm_pred])\n",
    "    confirm_new_seq = confirm_new_seq[-1:]\n",
    "    confirm_test_seq = confirm_new_seq.reshape((len(confirm_new_seq), time_steps, 1))\n",
    "    y2_confirm = confirm_test_seq\n",
    "    \n",
    "confirm_preds = (np.array(confirm_preds).flatten()).reshape(-1,1)\n",
    "confirm_preds = scaler_confirm.inverse_transform(confirm_preds)\n",
    "\n",
    "predicted_confirmed_index = pd.date_range(start=confirmed_df.index[-1],periods=DAYS_TO_PREDICT + 1,closed='right').strftime('%Y-%m-%d')\n",
    "predicted_confirmed_cases = pd.DataFrame()\n",
    "predicted_confirmed_cases['Dates'] = predicted_confirmed_index\n",
    "predicted_confirmed_cases['Confirmed Cases Predictions'] = confirm_preds\n",
    "predicted_confirmed_cases.set_index('Dates', inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=predicted_confirmed_cases.index, \n",
    "                         y=predicted_confirmed_cases['Confirmed Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='confirm',\n",
    "                         line=dict(color='red', width=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting Results For Death Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "death_test_seq  = y_train_death[-1:]\n",
    "death_preds = []\n",
    "for i in range(DAYS_TO_PREDICT):\n",
    "    y2_death = death_test_seq.reshape((len(death_test_seq), time_steps, 1))\n",
    "    death_pred = death_model.predict(y2_death)\n",
    "    death_preds.append(death_pred)\n",
    "    death_new_seq = death_test_seq.flatten()\n",
    "    death_new_seq = np.append(death_new_seq,[death_pred])\n",
    "    death_new_seq = death_new_seq[-1:]\n",
    "    death_test_seq = death_new_seq.reshape((len(death_new_seq), time_steps, 1))\n",
    "    y2_death = death_test_seq\n",
    "    \n",
    "death_preds = (np.array(death_preds).flatten()).reshape(-1,1)\n",
    "death_preds = scaler_death.inverse_transform(death_preds)\n",
    "\n",
    "predict_death_index = pd.date_range(start=death_df.index[-1],periods=DAYS_TO_PREDICT + 1,closed='right').strftime('%Y-%m-%d')\n",
    "predict_death_cases = pd.DataFrame()\n",
    "predict_death_cases['Dates'] = predict_death_index\n",
    "predict_death_cases['Death Cases Predictions'] = death_preds\n",
    "predict_death_cases.set_index('Dates', inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=predict_death_cases.index, \n",
    "                         y=predict_death_cases['Death Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='death',\n",
    "                         line=dict(color='blue', width=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting Results For Recovered Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "recovered_test_seq  = y_train_recovered[-1:]\n",
    "recovered_preds = []\n",
    "for i in range(DAYS_TO_PREDICT):\n",
    "    y2_recovered = recovered_test_seq.reshape((len(recovered_test_seq), time_steps, 1))\n",
    "    recovered_pred = recovered_model.predict(y2_recovered)\n",
    "    recovered_preds.append(recovered_pred)\n",
    "    recovered_new_seq = recovered_test_seq.flatten()\n",
    "    recovered_new_seq = np.append(recovered_new_seq,[recovered_pred])\n",
    "    recovered_new_seq = recovered_new_seq[-1:]\n",
    "    recovered_test_seq = recovered_new_seq.reshape((len(recovered_new_seq), time_steps, 1))\n",
    "    y2_recovered = recovered_test_seq\n",
    "    \n",
    "recovered_preds = (np.array(recovered_preds).flatten()).reshape(-1,1)\n",
    "recovered_preds = scaler_recovered.inverse_transform(recovered_preds)\n",
    "\n",
    "predict_recovered_index = pd.date_range(start=recovered_df.index[-1],periods=DAYS_TO_PREDICT + 1,closed='right').strftime('%Y-%m-%d')\n",
    "\n",
    "predict_recovered_cases = pd.DataFrame()\n",
    "predict_recovered_cases['Dates'] = predict_recovered_index\n",
    "predict_recovered_cases['Recovered Cases Predictions'] = recovered_preds\n",
    "predict_recovered_cases.set_index('Dates', inplace = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=predict_recovered_cases.index, \n",
    "                         y=predict_recovered_cases['Recovered Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='recovered',\n",
    "                         line=dict(color='green', width=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Historial Cases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=confirmed_df.index, \n",
    "                         y=confirmed_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='confirm',\n",
    "                         line=dict(color='red', width=2)))\n",
    "fig.add_trace(go.Scatter(x=death_df.index, \n",
    "                         y=death_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='death',\n",
    "                         line=dict(color='green', width=2)))\n",
    "fig.add_trace(go.Scatter(x=recovered_df.index, \n",
    "                         y=recovered_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='recovered',\n",
    "                         line=dict(color='blue', width=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictions for every individual scenario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=predicted_confirmed_cases.index, \n",
    "                         y=predicted_confirmed_cases['Confirmed Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Confirmed Cases Predictions',\n",
    "                         line=dict(color='yellow', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=predict_death_cases.index, \n",
    "                         y=predict_death_cases['Death Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Death Cases Predictions',\n",
    "                         line=dict(color='turquoise', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=predict_recovered_cases.index, \n",
    "                         y=predict_recovered_cases['Recovered Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Recovered Cases Predictions',\n",
    "                         line=dict(color='white', width=2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Historical and Predicted Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "fig.update_layout(template='plotly_dark')\n",
    "fig.update_xaxes(tickangle=90, showticklabels = True, type = 'category')\n",
    "fig.add_trace(go.Scatter(x=confirmed_df.index, \n",
    "                         y=confirmed_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='confirm',\n",
    "                         line=dict(color='red', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=death_df.index, \n",
    "                         y=death_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='death',\n",
    "                         line=dict(color='green', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=recovered_df.index, \n",
    "                         y=recovered_df[0],\n",
    "                         mode='lines+markers',\n",
    "                         name='recovered',\n",
    "                         line=dict(color='blue', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=predicted_confirmed_cases.index, \n",
    "                         y=predicted_confirmed_cases['Confirmed Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Confirmed Cases Predictions',\n",
    "                         line=dict(color='yellow', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=predict_death_cases.index, \n",
    "                         y=predict_death_cases['Death Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Death Cases Predictions',\n",
    "                         line=dict(color='turquoise', width=2)))\n",
    "\n",
    "fig.add_trace(go.Scatter(x=predict_recovered_cases.index, \n",
    "                         y=predict_recovered_cases['Recovered Cases Predictions'],\n",
    "                         mode='lines+markers',\n",
    "                         name='Recovered Cases Predictions',\n",
    "                         line=dict(color='white', width=2)))\n"
   ]
  }
 ],
 "metadata": {
  "author": {
   "email": "rv20197@gmail.com",
   "name": "Vatsal Dinesh Rajgor"
  },
  "contributors": {
   "contributor1": "Ajinky Porje",
   "contributor2": "Jibran Mujawar"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}