07_svm_rfc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# final notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* In this notebook I will be checking to see if any of the feature engineering done improves our best two models. After that I will test the best two models againt the holdout data and see which one is better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import pandas as pd\n",
    "import xgboost as xgb\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import confusion_matrix, plot_confusion_matrix\n",
    "from sklearn.svm import SVC\n",
    "from imblearn.pipeline import Pipeline as imbPipeline\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from imblearn.over_sampling import SMOTE\n",
    "from sklearn.impute import SimpleImputer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the engineered data\n",
    "X_train_eng = pd.read_csv('data/X_train_eng.csv', index_col = 'id')\n",
    "X_test_eng = pd.read_csv('data/X_test_eng.csv', index_col = 'id')\n",
    "y_train_eng = pd.read_csv('data/y_train_eng.csv', index_col = 'id')\n",
    "y_test_eng = pd.read_csv('data/y_test_eng.csv', index_col = 'id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "holdout = pd.read_csv('data/holdout_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_loss(model, X=None, y=None, scoring='neg_log_loss', cv=3):\n",
    "    # This function will give the log loss score for each model\n",
    "    log_loss = cross_val_score(model, X, y, scoring=scoring, cv=cv)\n",
    "    log_loss = -log_loss.mean()\n",
    "    print(f'Log loss: {log_loss}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_predictions(model, X=None, y=None):\n",
    "    # this function will return the accuracy scores for each model.\n",
    "    # Will we get an accuracy score of functional, functional needs repairs, and non functional wells\n",
    "    y_pred = model.predict(X)\n",
    "    cm = confusion_matrix(y, y_pred)\n",
    "    func = cm[0][0] / (cm[0][0] + cm[0][1] + cm[0][2])\n",
    "    func_nr = cm[1][1] / (cm[1][0] + cm[1][1] + cm[1][2])\n",
    "    non_func = cm[2][2] / (cm[2][0] + cm[2][1] + cm[2][2])\n",
    "    print(f'The model correctly predicts {round(func*100, 2)}% of the funtional wells.')\n",
    "    print(f'The model correctly predicts {round(func_nr*100, 2)}% of the funtional-needs-repair wells.')\n",
    "    print(f'The model correctly predicts {round(non_func*100, 2)}% of the non-functional wells.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_cat = X_train_eng.select_dtypes('object')\n",
    "X_train_num = X_train_eng.select_dtypes(['float64', 'int64'])\n",
    "\n",
    "cat_pipe = Pipeline(steps = [\n",
    "    ('imp', SimpleImputer(strategy='constant', fill_value='missing')),\n",
    "    ('ohe', OneHotEncoder(sparse=False, handle_unknown='ignore'))\n",
    "])\n",
    "num_pipe = Pipeline(steps = [\n",
    "    ('imp', SimpleImputer(missing_values=0, strategy='median')),\n",
    "    ('ss', StandardScaler()),\n",
    "])\n",
    "\n",
    "transformer = ColumnTransformer([('categorical', cat_pipe, X_train_cat.columns), \n",
    "                                  ('numerical', num_pipe, X_train_num.columns)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# using the svm model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  we are going to use the SVM model with no hyperparameter tuning since it has the best combined score of functional needs repair and non functional wells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_eng = y_train_eng['status_group']\n",
    "y_test_eng = y_test_eng['status_group']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('imp',\n",
       "                                                                   SimpleImputer(fill_value='missing',\n",
       "                                                                                 strategy='constant')),\n",
       "                                                                  ('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\n",
       "                                                  Index(['installer', 'basin', 'public_meeting', 'scheme_management', 'permit',\n",
       "       'management', 'payment', 'quantity'],\n",
       "      dtype='object')),\n",
       "                                                 ('numerical...\n",
       "                                                                  ('ss',\n",
       "                                                                   StandardScaler())]),\n",
       "                                                  Index(['longitude', 'latitude', 'num_private', 'region_code', 'district_code',\n",
       "       'population', 'construction_year', 'water_quality_by_region',\n",
       "       'water_quality_by_extraction_type', 'water_quality_by_waterpoint_type',\n",
       "       'water_quality_by_source', 'water_quality_by_gps_height'],\n",
       "      dtype='object'))])),\n",
       "                ('smote', SMOTE(random_state=42)), ('svm', SVC())])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_pipe = imbPipeline([\n",
    "    ('trans', transformer), \n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('svm', SVC())\n",
    "])\n",
    "svm_pipe.fit(X_train_eng, y_train_eng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Train: 0.6854111935086961\n",
      "Accuracy Score Test: 0.6565243415802074\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Train:', svm_pipe.score(X_train_eng,y_train_eng))\n",
    "print('Accuracy Score Test:', svm_pipe.score(X_test_eng,y_test_eng))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(svm_pipe, X_test_eng, y_test_eng, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 66.98% of the funtional wells.\n",
      "The model correctly predicts 62.74% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 64.32% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(svm_pipe, X_test_eng, y_test_eng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Random Forest Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We are going to use the best random forest model to see how well it does with the engineered data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_pipe_4 = imbPipeline(steps=[\n",
    "    ('trans', transformer),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2, \n",
    "                                   criterion = 'entropy',\n",
    "                                   max_depth = 80,\n",
    "                                   min_samples_leaf = 2,\n",
    "                                   min_samples_split = 2,\n",
    "                                   n_estimators = 250,\n",
    "                                   class_weight='balanced'))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:    1.5s\n",
      "[Parallel(n_jobs=-2)]: Done 186 tasks      | elapsed:    7.5s\n",
      "[Parallel(n_jobs=-2)]: Done 250 out of 250 | elapsed:    9.9s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('imp',\n",
       "                                                                   SimpleImputer(fill_value='missing',\n",
       "                                                                                 strategy='constant')),\n",
       "                                                                  ('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\n",
       "                                                  Index(['installer', 'basin', 'public_meeting', 'scheme_management', 'permit',\n",
       "       'management', 'payment', 'quantity'],\n",
       "      dtype='object')),\n",
       "                                                 ('numerical...\n",
       "       'population', 'construction_year', 'water_quality_by_region',\n",
       "       'water_quality_by_extraction_type', 'water_quality_by_waterpoint_type',\n",
       "       'water_quality_by_source', 'water_quality_by_gps_height'],\n",
       "      dtype='object'))])),\n",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('rfc',\n",
       "                 RandomForestClassifier(class_weight='balanced',\n",
       "                                        criterion='entropy', max_depth=80,\n",
       "                                        min_samples_leaf=2, n_estimators=250,\n",
       "                                        n_jobs=-2, verbose=1))])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.fit(X_train_eng, y_train_eng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.2s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.3s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.8861028898274085"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.score(X_train_eng, y_train_eng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7549880287310455"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4.score(X_test_eng, y_test_eng)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(model_pipe_4, X_test_eng, y_test_eng, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 80.03% of the funtional wells.\n",
      "The model correctly predicts 47.95% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 74.3% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(model_pipe_4, X_test_eng, y_test_eng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The engineered data does not preform better on either SVM or Random Forest Classifer in it's predictions. So it will not be used to fit our data on.\n",
    "\n",
    "* The test score using the engineered data for SVM was about 0.5 lower than using the non engineered data. The accuracy scores for well status were a bit lower across the board using SVM as well.\n",
    "\n",
    "* The test score using the engineered data for Random Forest classifer was about 0.4 lower than using the non engineered data. The accuracy scores for well status were a bit lower across the board using Random Forest as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# using the holdout data to see which model is better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the presplit data that is not engineered. \n",
    "X_train = pd.read_csv('data/X_train.csv', index_col='id')\n",
    "X_test = pd.read_csv('data/X_test.csv', index_col='id')\n",
    "y_train = pd.read_csv('data/y_train.csv', index_col='id')\n",
    "y_test = pd.read_csv('data/y_test.csv', index_col='id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make the pipline for the to process the data\n",
    "X_train_cat = X_train.select_dtypes('object')\n",
    "X_train_num = X_train.select_dtypes(['float64', 'int64'])\n",
    "\n",
    "cat_pipe = Pipeline(steps = [\n",
    "    ('imp', SimpleImputer(strategy='constant', fill_value='missing')),\n",
    "    ('ohe', OneHotEncoder(sparse=False, handle_unknown='ignore'))\n",
    "])\n",
    "num_pipe = Pipeline(steps = [\n",
    "    ('imp', SimpleImputer(missing_values=0, strategy='median')),\n",
    "    ('ss', StandardScaler()),\n",
    "])\n",
    "\n",
    "transformer = ColumnTransformer([('categorical', cat_pipe, X_train_cat.columns), \n",
    "                                  ('numerical', num_pipe, X_train_num.columns)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## using svm to fit the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y_train['status_group']\n",
    "y_test = y_test['status_group']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('imp',\n",
       "                                                                   SimpleImputer(fill_value='missing',\n",
       "                                                                                 strategy='constant')),\n",
       "                                                                  ('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\n",
       "                                                  Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_quality',\n",
       "       'quantity', 'source', 'waterpoint_type'],\n",
       "      dtype='object')),\n",
       "                                                 ('numerical',\n",
       "                                                  Pipeline(steps=[('imp',\n",
       "                                                                   SimpleImputer(missing_values=0,\n",
       "                                                                                 strategy='median')),\n",
       "                                                                  ('ss',\n",
       "                                                                   StandardScaler())]),\n",
       "                                                  Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object'))])),\n",
       "                ('smote', SMOTE(random_state=42)), ('svm', SVC())])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "svm_pipe = imbPipeline([\n",
    "    ('trans', transformer), \n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('svm', SVC())\n",
    "])\n",
    "svm_pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## using random forest to fit the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-2)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=-2)]: Done  36 tasks      | elapsed:    2.3s\n",
      "[Parallel(n_jobs=-2)]: Done 186 tasks      | elapsed:   12.1s\n",
      "[Parallel(n_jobs=-2)]: Done 250 out of 250 | elapsed:   15.6s finished\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('trans',\n",
       "                 ColumnTransformer(transformers=[('categorical',\n",
       "                                                  Pipeline(steps=[('imp',\n",
       "                                                                   SimpleImputer(fill_value='missing',\n",
       "                                                                                 strategy='constant')),\n",
       "                                                                  ('ohe',\n",
       "                                                                   OneHotEncoder(handle_unknown='ignore',\n",
       "                                                                                 sparse=False))]),\n",
       "                                                  Index(['installer', 'basin', 'region', 'public_meeting', 'scheme_management',\n",
       "       'permit', 'extraction_type', 'management', 'payment', 'water_qualit...\n",
       "                                                                                 strategy='median')),\n",
       "                                                                  ('ss',\n",
       "                                                                   StandardScaler())]),\n",
       "                                                  Index(['gps_height', 'longitude', 'latitude', 'num_private', 'region_code',\n",
       "       'district_code', 'population', 'construction_year'],\n",
       "      dtype='object'))])),\n",
       "                ('smote', SMOTE(random_state=42)),\n",
       "                ('rfc',\n",
       "                 RandomForestClassifier(class_weight='balanced',\n",
       "                                        criterion='entropy', max_depth=80,\n",
       "                                        min_samples_leaf=2, n_estimators=250,\n",
       "                                        n_jobs=-2, verbose=1))])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_pipe_4 = imbPipeline(steps=[\n",
    "    ('trans', transformer),\n",
    "    ('smote', SMOTE(random_state=42)),\n",
    "    ('rfc', RandomForestClassifier(verbose=1, n_jobs=-2, \n",
    "                                   criterion = 'entropy',\n",
    "                                   max_depth = 80,\n",
    "                                   min_samples_leaf = 2,\n",
    "                                   min_samples_split = 2,\n",
    "                                   n_estimators = 250,\n",
    "                                   class_weight='balanced'))])\n",
    "model_pipe_4.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test_holdout = holdout.drop('status_group', axis=1)\n",
    "y_test_holdout = holdout[['status_group']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# scoring the svm and random forest on the holdout data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## svm model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Test: 0.7129629629629629\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Test:', svm_pipe.score(X_test_holdout, y_test_holdout))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(svm_pipe, X_test_holdout, y_test_holdout, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 71.91% of the funtional wells.\n",
      "The model correctly predicts 68.47% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 70.97% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(svm_pipe, X_test_holdout, y_test_holdout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## random forest model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy Score Test: 0.7823232323232323\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n",
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.0s finished\n"
     ]
    }
   ],
   "source": [
    "print('Accuracy Score Test:', model_pipe_4.score(X_test_holdout, y_test_holdout))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n",
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.0s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_confusion_matrix(model_pipe_4, X_test_holdout, y_test_holdout, xticks_rotation='vertical');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Manav Kahlon\\anaconda3\\envs\\learn-env\\lib\\site-packages\\sklearn\\compose\\_column_transformer.py:437: FutureWarning: Given feature/column names or counts do not match the ones for the data given during fit. This will fail from v0.24.\n",
      "  warnings.warn(\"Given feature/column names or counts do not match \"\n",
      "[Parallel(n_jobs=7)]: Using backend ThreadingBackend with 7 concurrent workers.\n",
      "[Parallel(n_jobs=7)]: Done  36 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 186 tasks      | elapsed:    0.0s\n",
      "[Parallel(n_jobs=7)]: Done 250 out of 250 | elapsed:    0.1s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model correctly predicts 81.64% of the funtional wells.\n",
      "The model correctly predicts 52.94% of the funtional-needs-repair wells.\n",
      "The model correctly predicts 78.17% of the non-functional wells.\n"
     ]
    }
   ],
   "source": [
    "model_predictions(model_pipe_4, X_test_holdout, y_test_holdout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* using the best SVM model we find that the accuracy scores are similar to the test data set used previously. The accuracy scores were also similar across the all three well classification to the test data used previously.\n",
    "\n",
    "* using the best Random Forest model we find that the accuracy scores are similar to the test data set used previously. The accuracy scores were also similar across the all three well classification to the test data used previously. \n",
    "\n",
    "* We can therefore be confident that if we were given new data that has not been seen before we would be able to accuractly predict it to what we expect for each model. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (learn-env)",
   "language": "python",
   "name": "learn-env"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}