Clustering_County.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline\n",
    "from matplotlib.pylab import rcParams\n",
    "rcParams['figure.figsize']=30,15\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('try.csv')\n",
    "dataset['Period'] = dataset.apply(lambda row: datetime(int(row['Year']), int(row['Month']), 1) , axis=1)\n",
    "dataset = dataset.loc[:, ['Period', 'PDSI']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def test_stationarity(timeseries):\n",
    "    movingaverage=timeseries.rolling(window=12).mean()\n",
    "    movingstd=timeseries.rolling(window=12).std()\n",
    "    orig=plt.plot(timeseries,color='blue')\n",
    "    mean=plt.plot(movingaverage,color='red')\n",
    "    dev=plt.plot(movingstd,color='black')\n",
    "    plt.title('Rolling mean and Standarad Deviation')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide_test(dataset):\n",
    "    start_date=datetime(2000,1,1)\n",
    "    mask = (dataset['Period'] >= start_date)\n",
    "    return dataset.loc[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def divide_training(dataset):\n",
    "    start_date=datetime(2000,1,1)\n",
    "    mask = (dataset['Period'] < start_date)\n",
    "    return dataset.loc[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def model_fit(dataset):\n",
    "    dataset['Period'] = dataset.apply(lambda row: datetime(int(row['Year']), int(row['Month']), 1) , axis=1)\n",
    "    dataset = dataset.loc[:, ['Period', 'PDSI']]\n",
    "    training_set = divide_training(dataset)\n",
    "    training_set = training_set.set_index(['Period'])\n",
    "    plt.plot(training_set)\n",
    "    test_set = divide_test(dataset)\n",
    "    test_set = test_set.set_index(['Period'])\n",
    "    \n",
    "    training_set_shift=training_set-training_set.shift()\n",
    "    training_set_shift.dropna(inplace=True)\n",
    "    from statsmodels.tsa.arima_model import ARIMA\n",
    "\n",
    "    model = ARIMA(training_set_shift,order=(10,1,3))\n",
    "    results_ARIMA=model.fit(disp=-1)\n",
    "    predictions_ARIMA_diff = pd.Series(results_ARIMA.fittedvalues,copy=True)\n",
    "    predictions_ARIMA_diff_cumsum = predictions_ARIMA_diff.cumsum()\n",
    "    predictions_ARIMA = pd.Series(training_set['PDSI'].ix[0], index=dataset.index)\n",
    "    predictions_ARIMA = predictions_ARIMA.add(predictions_ARIMA_diff_cumsum,fill_value=0)\n",
    "    results_ARIMA.plot_predict(1,1000)\n",
    "    future = results_ARIMA.forecast(steps=test_set.shape[0])\n",
    "    dataframe = pd.DataFrame(future[0], columns=['PDSI'])\n",
    "    real_data = test_set\n",
    "    real_data = real_data.loc[:, ['PDSI']]\n",
    "    rd = ((real_data - dataframe))/real_data\n",
    "    size = dataframe.shape[0]\n",
    "    mape = (sum(rd['PDSI']))/size\n",
    "    return mape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "main_dataset = pd.read_csv('main.csv')\n",
    "#main_dataset.dropna(inplace=True)\n",
    "#main_dataset['Period'] = main_dataset.apply(lambda row: datetime(int(row['Year']), int(row['Month']), 1) , axis=1)\n",
    "main_dataset = main_dataset.loc[:, ['County', 'Year' ,'Month', 'PDSI']]\n",
    "main_dataset.head()\n",
    "previous = main_dataset['County'][0]\n",
    "df = pd.DataFrame(columns=['County', 'Year', 'Month', 'PDSI'])\n",
    "\n",
    "row = next(main_dataset.iterrows())[1]\n",
    "row = next(main_dataset.iterrows())[1]\n",
    "# #df['County'][0]=row['County']\n",
    "# df.loc[0]=row\n",
    "# row = next(main_dataset.iterrows())[1]\n",
    "# df.loc[1]=row\n",
    "# df\n",
    "\n",
    "count=0\n",
    "sum = 0\n",
    "while(!row.empty):\n",
    "    if(previous==row['County']):\n",
    "        df.loc[count]=row\n",
    "        count=count+1\n",
    "        row= next(main_dataset.iterrows())[1]\n",
    "        \n",
    "    else:\n",
    "        cur_dataset = df.loc[:, ['County', 'Year' ,'Month', 'PDSI']]\n",
    "        mape = model_fit(cur_dataset)\n",
    "        sum = sum + mape\n",
    "        \n",
    "mape = sum/count\n",
    "        \n",
    "        \n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}