model-and-predict-data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#import standard packages\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# mport the random forest package # it's the best model used so far but i want to prove that\n",
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.cross_validation import cross_val_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# ignore warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#load the cleaned training values\n",
    "train = pd.read_csv('cleaned_v2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#load the cleaned test set\n",
    "test = pd.read_csv('cleaned_test_v2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59400, 35), (14850, 34))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#look at shape because will combine and separate again later\n",
    "train.shape, test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#take off the status group column  - it is the outcome to predict\n",
    "y_train = train.pop('status_group')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59400, 34), (14850, 34))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape, test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#drop this unnamed column \n",
    "train.drop('Unnamed: 0', axis=1, inplace=True)\n",
    "test.drop('Unnamed: 0', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#define categorical variables to encode for model\n",
    "categorical = ['funder',\n",
    " 'installer',\n",
    " 'scheme_management',\n",
    " 'extraction_type',\n",
    " 'management',\n",
    " 'payment_type',\n",
    " 'water_quality',\n",
    " 'quantity']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Encode the categorical data, with the complete set (train and test)\n",
    "\n",
    "#this allows you to separate out your df again\n",
    "train[\"train\"] = 1\n",
    "test[\"train\"] = 0\n",
    "\n",
    "#combine the dfs\n",
    "combined = pd.concat([train, test])\n",
    "\n",
    "#factorize for random forest\n",
    "combined['funder'] = pd.factorize(combined['funder'])[0]\n",
    "combined['installer'] = pd.factorize(combined['installer'])[0]\n",
    "combined['scheme_management'] = pd.factorize(combined['scheme_management'])[0]\n",
    "combined['extraction_type'] = pd.factorize(combined['extraction_type'])[0]\n",
    "combined['management'] = pd.factorize(combined['management'])[0]\n",
    "combined['payment_type'] = pd.factorize(combined['payment_type'])[0]\n",
    "combined['water_quality'] = pd.factorize(combined['water_quality'])[0]\n",
    "combined['quantity'] = pd.factorize(combined['quantity'])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(74250, 35)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Encode the categorical data, with the complete set (train and test)\n",
    "\n",
    "#this allows you to separate out your df again\n",
    "train[\"train\"] = 1\n",
    "test[\"train\"] = 0\n",
    "\n",
    "#combine the dfs\n",
    "combined = pd.concat([train, test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#boolean indexing to separate train vs test\n",
    "train_df = combined[combined[\"train\"] == 1]\n",
    "test_df = combined[combined[\"train\"] == 0]\n",
    "train_df.drop([\"train\"], axis=1, inplace=True)\n",
    "test_df.drop([\"train\"], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59400, 34), (14850, 34))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_df.shape, test_df.shape\n",
    "#looks correct!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((59400, 41), (14850, 41))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.shape, test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#define features columns\n",
    "#some trial and error went into this \n",
    "feature_columns = [\n",
    " 'funder',\n",
    " 'installer',\n",
    " 'scheme_management',\n",
    " 'extraction_type',\n",
    " 'management',\n",
    " 'payment_type',\n",
    " 'water_quality',\n",
    " 'longitude',\n",
    " 'latitude',\n",
    " 'gps_height',\n",
    " 'region_code',\n",
    " 'district_code',\n",
    " 'operation_year',\n",
    " 'quantity'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#define X train\n",
    "X = train_df[feature_columns]\n",
    "#y_train indentified at the beginning \n",
    "y = y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#define X test\n",
    "X_test = test_df[feature_columns]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=1000, n_jobs=1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#define and fit model - i found 1000 estimators gave the best score\n",
    "model = RandomForestClassifier(n_estimators=1000)\n",
    "model.fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.80642989,  0.80121192,  0.80020199,  0.79279583,  0.79983165,\n",
       "        0.79175084,  0.80252525,  0.78868496,  0.79121064,  0.80060626])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#warning this takes forever\n",
    "cross_val_score(model, X, y, 'accuracy', cv=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.0557846 ,  0.04613513,  0.02024127,  0.08536828,  0.0205207 ,\n",
       "        0.04047207,  0.01725403,  0.18043261,  0.17914069,  0.09945361,\n",
       "        0.02803818,  0.03119936,  0.07887847,  0.117081  ])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#look at feature importance\n",
    "importances = model.feature_importances_\n",
    "importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature ranking:\n",
      "1. feature 7 (0.180433)\n",
      "2. feature 8 (0.179141)\n",
      "3. feature 13 (0.117081)\n",
      "4. feature 9 (0.099454)\n",
      "5. feature 3 (0.085368)\n",
      "6. feature 12 (0.078878)\n",
      "7. feature 0 (0.055785)\n",
      "8. feature 1 (0.046135)\n",
      "9. feature 5 (0.040472)\n",
      "10. feature 11 (0.031199)\n",
      "11. feature 10 (0.028038)\n",
      "12. feature 4 (0.020521)\n",
      "13. feature 2 (0.020241)\n",
      "14. feature 6 (0.017254)\n"
     ]
    }
   ],
   "source": [
    "indices = np.argsort(importances)[::-1]\n",
    "\n",
    "# Print the feature ranking\n",
    "print(\"Feature ranking:\")\n",
    "\n",
    "for f in range(X.shape[1]):\n",
    "    print(\"%d. feature %d (%f)\" % (f + 1, indices[f], importances[indices[f]]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#in order: \n",
    "#longitude, latitude, quantity, gps height, extraction type, operation year, funder, installer\n",
    "#payment type, district code, region code, management, scheme management, water quality\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#create status_group column on test df\n",
    "y_pred = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['non functional', 'functional', 'functional', ..., 'functional',\n",
       "       'functional', 'non functional'], dtype=object)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#export it to csv\n",
    "pd.DataFrame(y_pred).to_csv(\"submission.csv\")"
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}