StatPredictorLockathon (2).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "StatPredictorLockathon.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "U5ucBsOew1Cm",
        "colab_type": "code",
        "outputId": "d26404d1-6ce3-4a8d-84e9-0902368d248c",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 75
        }
      },
      "source": [
        "from google.colab import files                   # since data was taken from kaggle, hence kaggle token used\n",
        "import os\n",
        "uploaded = files.upload()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-44263820-b122-44d1-b24e-925e16589643\" name=\"files[]\" multiple disabled />\n",
              "     <output id=\"result-44263820-b122-44d1-b24e-925e16589643\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Saving kaggle.json to kaggle (1).json\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nloHbLNcxPQB",
        "colab_type": "code",
        "outputId": "f5cdb461-4301-4d8c-d18f-3e27f6792fa5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        }
      },
      "source": [
        "!ls -lha kaggle.json\n",
        "!pip install statsmodels==0.11.0rc1\n",
        "!pip install -q kaggle\n",
        "!mkdir -p ~/.kaggle\n",
        "!cp kaggle.json ~/.kaggle\n",
        "!chmod 600 ~/.kaggle/kaggle.json\n",
        "!kaggle datasets download --force -d sudalairajkumar/covid19-in-india"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-rw-r--r-- 1 root root 67 May 12 12:10 kaggle.json\n",
            "Requirement already satisfied: statsmodels==0.11.0rc1 in /usr/local/lib/python3.6/dist-packages (0.11.0rc1)\n",
            "Requirement already satisfied: pandas>=0.21 in /usr/local/lib/python3.6/dist-packages (from statsmodels==0.11.0rc1) (1.0.3)\n",
            "Requirement already satisfied: patsy>=0.5 in /usr/local/lib/python3.6/dist-packages (from statsmodels==0.11.0rc1) (0.5.1)\n",
            "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.6/dist-packages (from statsmodels==0.11.0rc1) (1.4.1)\n",
            "Requirement already satisfied: numpy>=1.14 in /usr/local/lib/python3.6/dist-packages (from statsmodels==0.11.0rc1) (1.18.4)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.21->statsmodels==0.11.0rc1) (2018.9)\n",
            "Requirement already satisfied: python-dateutil>=2.6.1 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.21->statsmodels==0.11.0rc1) (2.8.1)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from patsy>=0.5->statsmodels==0.11.0rc1) (1.12.0)\n",
            "Downloading covid19-in-india.zip to /content\n",
            "  0% 0.00/191k [00:00<?, ?B/s]\n",
            "100% 191k/191k [00:00<00:00, 28.8MB/s]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBNr40HXxVV5",
        "colab_type": "code",
        "outputId": "80be2e86-0e11-43b0-ea22-ee30a7a7c012",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 199
        }
      },
      "source": [
        "!unzip covid19-in-india.zip                            # covid19-in-india.zip has been pushed seperately in the repo"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Archive:  covid19-in-india.zip\n",
            "replace AgeGroupDetails.csv? [y]es, [n]o, [A]ll, [N]one, [r]ename: A\n",
            "  inflating: AgeGroupDetails.csv     \n",
            "  inflating: HospitalBedsIndia.csv   \n",
            "  inflating: ICMRTestingDetails.csv  \n",
            "  inflating: ICMRTestingLabs.csv     \n",
            "  inflating: IndividualDetails.csv   \n",
            "  inflating: StatewiseTestingDetails.csv  \n",
            "  inflating: covid_19_india.csv      \n",
            "  inflating: population_india_census2011.csv  \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ke0EtYwLzXeh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import datetime\n",
        "import warnings\n",
        "from datetime import timedelta\n",
        "warnings.filterwarnings('ignore')\n",
        "raw_data = pd.read_csv('covid_19_india.csv')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RJMStGJo4EkP",
        "colab_type": "code",
        "outputId": "7bef7eb7-f3bf-4885-b605-0a06e88d8bc5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 254
        }
      },
      "source": [
        "x = np.array(raw_data['Time'])\n",
        "u = np.unique(x)\n",
        "print(u)                                                                      # replacing the AM-PM timestyle with 24 hour timestyle\n",
        "raw_data['Time'][raw_data['Time'] == '10:00 AM'] = '10:00:00' \n",
        "raw_data['Time'][raw_data['Time'] == '10:00 AM'] = '10:00:00' \n",
        "raw_data['Time'][raw_data['Time'] == '8:00 AM'] = '08:00:00'\n",
        "raw_data['Time'][raw_data['Time'] == '5:00 PM'] = '17:00:00'                                     # replacing the AM-PM timestyle with 24 hour timestyle\n",
        "raw_data['Time'][raw_data['Time'] == '6:00 PM'] = '18:00:00'\n",
        "raw_data['Time'][raw_data['Time'] == '7:30 PM'] = '19:30:00'\n",
        "raw_data['Time'][raw_data['Time'] == '8:30 PM'] = '20:30:00'\n",
        "raw_data['Time'][raw_data['Time'] == '9:30 PM'] = '21:30:00'     \n",
        "print(raw_data['Time'])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['10:00 AM' '5:00 PM' '6:00 PM' '7:30 PM' '8:00 AM' '8:30 PM' '9:30 PM']\n",
            "0       18:00:00\n",
            "1       18:00:00\n",
            "2       18:00:00\n",
            "3       18:00:00\n",
            "4       18:00:00\n",
            "          ...   \n",
            "1864    08:00:00\n",
            "1865    08:00:00\n",
            "1866    08:00:00\n",
            "1867    08:00:00\n",
            "1868    08:00:00\n",
            "Name: Time, Length: 1869, dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OHiazDOA0XZo",
        "colab_type": "code",
        "outputId": "c4690cf2-e616-4f8c-a5b6-a5699531b3bf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        }
      },
      "source": [
        "raw_data['Date'] = raw_data['Date'] + '20'\n",
        "raw_data['Datetime'] = raw_data['Date'] + ' ' + raw_data['Time']\n",
        "for i in range(len(raw_data['Datetime'])):\n",
        "  raw_data['Datetime'][i] = datetime.datetime.strptime(raw_data['Datetime'][i],'%d/%m/%Y %H:%M:%S')  \n",
        "print(raw_data['Datetime'])                                                                              # converting all the dates in string to datetime data type"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0       2020-01-30 18:00:00\n",
            "1       2020-01-31 18:00:00\n",
            "2       2020-02-01 18:00:00\n",
            "3       2020-02-02 18:00:00\n",
            "4       2020-02-03 18:00:00\n",
            "               ...         \n",
            "1864    2020-05-12 08:00:00\n",
            "1865    2020-05-12 08:00:00\n",
            "1866    2020-05-12 08:00:00\n",
            "1867    2020-05-12 08:00:00\n",
            "1868    2020-05-12 08:00:00\n",
            "Name: Datetime, Length: 1869, dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RMF6VAJAQRNZ",
        "colab_type": "code",
        "outputId": "cd581d83-9bfe-44d2-a643-86b102d49f7f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 726
        }
      },
      "source": [
        "statewise = raw_data.groupby('State/UnionTerritory')['Confirmed','Deaths','Cured'].max()\n",
        "statewise['Active'] = statewise['Confirmed'] - statewise['Deaths'] - statewise['Cured']\n",
        "print(statewise)                                                                # displaying statewise statistics as they stand for better understanding"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "                             Confirmed  Deaths  Cured  Active\n",
            "State/UnionTerritory                                         \n",
            "Andaman and Nicobar Islands         33       0     33       0\n",
            "Andhra Pradesh                    2018      45    975     998\n",
            "Arunachal Pradesh                    1       0      1       0\n",
            "Assam                               65       2     34      29\n",
            "Bihar                              747       6    377     364\n",
            "Chandigarh                         174       2     24     148\n",
            "Chhattisgarh                        59       0     53       6\n",
            "Dadar Nagar Haveli                   1       0      0       1\n",
            "Delhi                             7233      73   2129    5031\n",
            "Goa                                  7       0      7       0\n",
            "Gujarat                           8541     513   2780    5248\n",
            "Haryana                            730      11    337     382\n",
            "Himachal Pradesh                    59       2     39      18\n",
            "Jammu and Kashmir                  879      10    427     442\n",
            "Jharkhand                          160       3     78      79\n",
            "Jharkhand#                          45       3      0      42\n",
            "Karnataka                          862      31    426     405\n",
            "Kerala                             519       4    489      26\n",
            "Ladakh                              42       0     21      21\n",
            "Madhya Pradesh                    3785     221   1747    1817\n",
            "Maharashtra                      23401     868   4786   17747\n",
            "Manipur                              2       0      2       0\n",
            "Meghalaya                           13       1     10       2\n",
            "Mizoram                              1       0      1       0\n",
            "Nagaland                             1       0      0       1\n",
            "Nagaland#                            0       0      0       0\n",
            "Odisha                             414       3     85     326\n",
            "Puducherry                          12       0      6       6\n",
            "Punjab                            1877      31    168    1678\n",
            "Rajasthan                         3988     113   2264    1611\n",
            "Tamil Nadu                        8002      53   2051    5898\n",
            "Telengana                         1275      30    800     445\n",
            "Tripura                            152       0      2     150\n",
            "Unassigned                          77       0      0      77\n",
            "Uttar Pradesh                     3573      80   1758    1735\n",
            "Uttarakhand                         68       1     46      21\n",
            "West Bengal                       2063     190    499    1374\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2hjkXDTSY23G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from statsmodels.tsa.arima_model import ARIMA\n",
        "from matplotlib import pyplot as plt\n",
        "from pandas.plotting import autocorrelation_plot"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gumb2xM50w9k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def predcountry(raw_data,days_in_advance):\n",
        "  raw_data['Datetime'] = raw_data['Date'] + ' ' + raw_data['Time']\n",
        "  for i in range(len(raw_data['Datetime'])):\n",
        "    raw_data['Datetime'][i] = datetime.datetime.strptime(raw_data['Datetime'][i],'%d/%m/%Y %H:%M:%S')  \n",
        "  #print(raw_data['Datetime'])     \n",
        "  country_data = raw_data.groupby(\"Datetime\")[[\"Confirmed\",\"Cured\",\"Deaths\"]].sum().reset_index()\n",
        "  country_data['Active'] = country_data['Confirmed'] - country_data['Cured'] - country_data['Deaths']            \n",
        "  #print(country_data)                             \n",
        "  country_data['ds'] = country_data['Datetime']\n",
        "  country_data['y'] = country_data['Confirmed'] \n",
        "  testing = country_data.loc[:,('Confirmed','Datetime')]\n",
        "  model2 = ARIMA(testing['Confirmed'],order = [5,1,0])\n",
        "  model2 = model2.fit()\n",
        "  forecast = model2.forecast(steps = 30)\n",
        "  pred = list(forecast[0].astype(int))\n",
        "  y = country_data['Confirmed']\n",
        "  y = y.append(pd.Series(pred))\n",
        "  y = y.reset_index(drop = True)\n",
        "  #print(y)\n",
        "  x = pd.Series(pd.date_range(raw_data['Date'][0],periods=len(y)))\n",
        "  #with pd.option_context('display.max_rows', None, 'display.max_columns', None):  # more options can be specified also\n",
        "   #print(x)\n",
        "  plt.plot(x,y,linestyle = 'solid')\n",
        "  plt.show()\n",
        "  return pred[days_in_advance].astype(int),x,y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aEUIEsZH4Ral",
        "colab_type": "code",
        "outputId": "75712929-3edd-4b74-e2dd-4cf5414b55a8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        }
      },
      "source": [
        "+mmmmmmmmmmmmmmval,x,y = predcountry(raw_data,2)\n",
        "print(\"Expected confirmed cases by \" + str((datetime.datetime.today().date()+timedelta(days=10)))+\" are \" + str(val))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Expected confirmed cases by 2020-05-22 are 82639\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SfeP3xCa9hXV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def pred_state(raw_data,state,days_in_advance):\n",
        "  delh = raw_data[raw_data['State/UnionTerritory'] == state].reset_index()\n",
        "  #print(delh)\n",
        "  tdata = delh.loc[:,('Datetime','Confirmed')]\n",
        "  model1 = ARIMA(tdata['Confirmed'],order = [5,1,0])\n",
        "  model1 = model1.fit(trend = 'c')\n",
        "  forec = model1.forecast(steps = 30)\n",
        "  pred = list(forec[0])\n",
        "  y = delh['Confirmed']\n",
        "  y = y.append(pd.Series(pred))\n",
        "  y = y.reset_index(drop = True)\n",
        "  #print(y)\n",
        "  x = pd.Series(pd.date_range(raw_data['Date'][0],periods=len(y)))\n",
        "  return pred[days_in_advance].astype(int),x,y"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qDO8f7uU_oK4",
        "colab_type": "code",
        "outputId": "73102e99-7bfb-4b26-d141-65b87728f560",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 301
        }
      },
      "source": [
        "state = 'Delhi'\n",
        "days = 5\n",
        "val2,x1,y1 = pred_state(raw_data,state,days)\n",
        "print(\"Expected Confirmed cases in \" + state + \" by \" + str((datetime.datetime.today().date()+timedelta(days=days)))+\" is \"+str(val2))\n",
        "plt.plot(x1,y1,linestyle = 'dashed')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Expected Confirmed cases in Delhi by 2020-05-17 is 9143\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fa3f05c02e8>]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}