04_preprocessing_and_training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 Pre-Processing and Training Data<a id='4_Pre-Processing_and_Training_Data'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Contents<a id='4.1_Contents'></a>\n",
    "* [4 Pre-Processing and Training Data](#4_Pre-Processing_and_Training_Data)\n",
    "  * [4.1 Contents](#4.1_Contents)\n",
    "  * [4.2 Introduction](#4.2_Introduction)\n",
    "  * [4.3 Imports](#4.3_Imports)\n",
    "  * [4.4 Load Data](#4.4_Load_Data)\n",
    "  * [4.5 Extract Big Mountain Data](#4.5_Extract_Big_Mountain_Data)\n",
    "  * [4.6 Train/Test Split](#4.6_Train/Test_Split)\n",
    "  * [4.7 Initial Not-Even-A-Model](#4.7_Initial_Not-Even-A-Model)\n",
    "    * [4.7.1 Metrics](#4.7.1_Metrics)\n",
    "      * [4.7.1.1 R-squared, or coefficient of determination](#4.7.1.1_R-squared,_or_coefficient_of_determination)\n",
    "      * [4.7.1.2 Mean Absolute Error](#4.7.1.2_Mean_Absolute_Error)\n",
    "      * [4.7.1.3 Mean Squared Error](#4.7.1.3_Mean_Squared_Error)\n",
    "    * [4.7.2 sklearn metrics](#4.7.2_sklearn_metrics)\n",
    "        * [4.7.2.0.1 R-squared](#4.7.2.0.1_R-squared)\n",
    "        * [4.7.2.0.2 Mean absolute error](#4.7.2.0.2_Mean_absolute_error)\n",
    "        * [4.7.2.0.3 Mean squared error](#4.7.2.0.3_Mean_squared_error)\n",
    "    * [4.7.3 Note On Calculating Metrics](#4.7.3_Note_On_Calculating_Metrics)\n",
    "  * [4.8 Initial Models](#4.8_Initial_Models)\n",
    "    * [4.8.1 Imputing missing feature (predictor) values](#4.8.1_Imputing_missing_feature_(predictor)_values)\n",
    "      * [4.8.1.1 Impute missing values with median](#4.8.1.1_Impute_missing_values_with_median)\n",
    "        * [4.8.1.1.1 Learn the values to impute from the train set](#4.8.1.1.1_Learn_the_values_to_impute_from_the_train_set)\n",
    "        * [4.8.1.1.2 Apply the imputation to both train and test splits](#4.8.1.1.2_Apply_the_imputation_to_both_train_and_test_splits)\n",
    "        * [4.8.1.1.3 Scale the data](#4.8.1.1.3_Scale_the_data)\n",
    "        * [4.8.1.1.4 Train the model on the train split](#4.8.1.1.4_Train_the_model_on_the_train_split)\n",
    "        * [4.8.1.1.5 Make predictions using the model on both train and test splits](#4.8.1.1.5_Make_predictions_using_the_model_on_both_train_and_test_splits)\n",
    "        * [4.8.1.1.6 Assess model performance](#4.8.1.1.6_Assess_model_performance)\n",
    "      * [4.8.1.2 Impute missing values with the mean](#4.8.1.2_Impute_missing_values_with_the_mean)\n",
    "        * [4.8.1.2.1 Learn the values to impute from the train set](#4.8.1.2.1_Learn_the_values_to_impute_from_the_train_set)\n",
    "        * [4.8.1.2.2 Apply the imputation to both train and test splits](#4.8.1.2.2_Apply_the_imputation_to_both_train_and_test_splits)\n",
    "        * [4.8.1.2.3 Scale the data](#4.8.1.2.3_Scale_the_data)\n",
    "        * [4.8.1.2.4 Train the model on the train split](#4.8.1.2.4_Train_the_model_on_the_train_split)\n",
    "        * [4.8.1.2.5 Make predictions using the model on both train and test splits](#4.8.1.2.5_Make_predictions_using_the_model_on_both_train_and_test_splits)\n",
    "        * [4.8.1.2.6 Assess model performance](#4.8.1.2.6_Assess_model_performance)\n",
    "    * [4.8.2 Pipelines](#4.8.2_Pipelines)\n",
    "      * [4.8.2.1 Define the pipeline](#4.8.2.1_Define_the_pipeline)\n",
    "      * [4.8.2.2 Fit the pipeline](#4.8.2.2_Fit_the_pipeline)\n",
    "      * [4.8.2.3 Make predictions on the train and test sets](#4.8.2.3_Make_predictions_on_the_train_and_test_sets)\n",
    "      * [4.8.2.4 Assess performance](#4.8.2.4_Assess_performance)\n",
    "  * [4.9 Refining The Linear Model](#4.9_Refining_The_Linear_Model)\n",
    "    * [4.9.1 Define the pipeline](#4.9.1_Define_the_pipeline)\n",
    "    * [4.9.2 Fit the pipeline](#4.9.2_Fit_the_pipeline)\n",
    "    * [4.9.3 Assess performance on the train and test set](#4.9.3_Assess_performance_on_the_train_and_test_set)\n",
    "    * [4.9.4 Define a new pipeline to select a different number of features](#4.9.4_Define_a_new_pipeline_to_select_a_different_number_of_features)\n",
    "    * [4.9.5 Fit the pipeline](#4.9.5_Fit_the_pipeline)\n",
    "    * [4.9.6 Assess performance on train and test data](#4.9.6_Assess_performance_on_train_and_test_data)\n",
    "    * [4.9.7 Assessing performance using cross-validation](#4.9.7_Assessing_performance_using_cross-validation)\n",
    "    * [4.9.8 Hyperparameter search using GridSearchCV](#4.9.8_Hyperparameter_search_using_GridSearchCV)\n",
    "  * [4.10 Random Forest Model](#4.10_Random_Forest_Model)\n",
    "    * [4.10.1 Define the pipeline](#4.10.1_Define_the_pipeline)\n",
    "    * [4.10.2 Fit and assess performance using cross-validation](#4.10.2_Fit_and_assess_performance_using_cross-validation)\n",
    "    * [4.10.3 Hyperparameter search using GridSearchCV](#4.10.3_Hyperparameter_search_using_GridSearchCV)\n",
    "  * [4.11 Final Model Selection](#4.11_Final_Model_Selection)\n",
    "    * [4.11.1 Linear regression model performance](#4.11.1_Linear_regression_model_performance)\n",
    "    * [4.11.2 Random forest regression model performance](#4.11.2_Random_forest_regression_model_performance)\n",
    "    * [4.11.3 Conclusion](#4.11.3_Conclusion)\n",
    "  * [4.12 Data quantity assessment](#4.12_Data_quantity_assessment)\n",
    "  * [4.13 Save best model object from pipeline](#4.13_Save_best_model_object_from_pipeline)\n",
    "  * [4.14 Summary](#4.14_Summary)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Introduction<a id='4.2_Introduction'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In preceding notebooks, performed preliminary assessments of data quality and refined the question to be answered. You found a small number of data values that gave clear choices about whether to replace values or drop a whole row. You determined that predicting the adult weekend ticket price was your primary aim. You threw away records with missing price data, but not before making the most of the other available data to look for any patterns between the states. You didn't see any and decided to treat all states equally; the state label didn't seem to be particularly useful.\n",
    "\n",
    "In this notebook you'll start to build machine learning models. Before even starting with learning a machine learning model, however, start by considering how useful the mean value is as a predictor. This is more than just a pedagogical device. You never want to go to stakeholders with a machine learning model only to have the CEO point out that it performs worse than just guessing the average! Your first model is a baseline performance comparitor for any subsequent model. You then build up the process of efficiently and robustly creating and assessing models against it. The development we lay out may be little slower than in the real world, but this step of the capstone is definitely more than just instructional. It is good practice to build up an understanding that the machine learning pipelines you build work as expected. You can validate steps with your own functions for checking expected equivalence between, say, pandas and sklearn implementations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 Imports<a id='4.3_Imports'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn import __version__ as sklearn_version\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import scale\n",
    "from sklearn.model_selection import train_test_split, cross_validate, GridSearchCV, learning_curve\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "from sklearn.dummy import DummyRegressor\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.feature_selection import SelectKBest, f_regression\n",
    "import datetime\n",
    "\n",
    "from library.sb_utils import save_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.4 Load Data<a id='4.4_Load_Data'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Name</th>\n",
       "      <td>Alyeska Resort</td>\n",
       "      <td>Eaglecrest Ski Area</td>\n",
       "      <td>Hilltop Ski Area</td>\n",
       "      <td>Arizona Snowbowl</td>\n",
       "      <td>Sunrise Park Resort</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Region</th>\n",
       "      <td>Alaska</td>\n",
       "      <td>Alaska</td>\n",
       "      <td>Alaska</td>\n",
       "      <td>Arizona</td>\n",
       "      <td>Arizona</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>state</th>\n",
       "      <td>Alaska</td>\n",
       "      <td>Alaska</td>\n",
       "      <td>Alaska</td>\n",
       "      <td>Arizona</td>\n",
       "      <td>Arizona</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>summit_elev</th>\n",
       "      <td>3939</td>\n",
       "      <td>2600</td>\n",
       "      <td>2090</td>\n",
       "      <td>11500</td>\n",
       "      <td>11100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vertical_drop</th>\n",
       "      <td>2500</td>\n",
       "      <td>1540</td>\n",
       "      <td>294</td>\n",
       "      <td>2300</td>\n",
       "      <td>1800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>base_elev</th>\n",
       "      <td>250</td>\n",
       "      <td>1200</td>\n",
       "      <td>1796</td>\n",
       "      <td>9200</td>\n",
       "      <td>9200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trams</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastSixes</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>quad</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>triple</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>double</th>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>surface</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs</th>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Runs</th>\n",
       "      <td>76.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>13.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>65.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TerrainParks</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LongestRun_mi</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SkiableTerrain_ac</th>\n",
       "      <td>1610.0</td>\n",
       "      <td>640.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>777.0</td>\n",
       "      <td>800.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Snow Making_ac</th>\n",
       "      <td>113.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>104.0</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>daysOpenLastYear</th>\n",
       "      <td>150.0</td>\n",
       "      <td>45.0</td>\n",
       "      <td>150.0</td>\n",
       "      <td>122.0</td>\n",
       "      <td>115.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>yearsOpen</th>\n",
       "      <td>60.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>36.0</td>\n",
       "      <td>81.0</td>\n",
       "      <td>49.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>averageSnowfall</th>\n",
       "      <td>669.0</td>\n",
       "      <td>350.0</td>\n",
       "      <td>69.0</td>\n",
       "      <td>260.0</td>\n",
       "      <td>250.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdultWeekend</th>\n",
       "      <td>85.0</td>\n",
       "      <td>53.0</td>\n",
       "      <td>34.0</td>\n",
       "      <td>89.0</td>\n",
       "      <td>78.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>projectedDaysOpen</th>\n",
       "      <td>150.0</td>\n",
       "      <td>90.0</td>\n",
       "      <td>152.0</td>\n",
       "      <td>122.0</td>\n",
       "      <td>104.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NightSkiing_ac</th>\n",
       "      <td>550.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>30.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_state</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_100kcapita</th>\n",
       "      <td>0.410091</td>\n",
       "      <td>0.410091</td>\n",
       "      <td>0.410091</td>\n",
       "      <td>0.027477</td>\n",
       "      <td>0.027477</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_100ksq_mile</th>\n",
       "      <td>0.450867</td>\n",
       "      <td>0.450867</td>\n",
       "      <td>0.450867</td>\n",
       "      <td>1.75454</td>\n",
       "      <td>1.75454</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_skiable_area_ac_state_ratio</th>\n",
       "      <td>0.70614</td>\n",
       "      <td>0.280702</td>\n",
       "      <td>0.013158</td>\n",
       "      <td>0.492708</td>\n",
       "      <td>0.507292</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_days_open_state_ratio</th>\n",
       "      <td>0.434783</td>\n",
       "      <td>0.130435</td>\n",
       "      <td>0.434783</td>\n",
       "      <td>0.514768</td>\n",
       "      <td>0.485232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_terrain_park_state_ratio</th>\n",
       "      <td>0.5</td>\n",
       "      <td>0.25</td>\n",
       "      <td>0.25</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_night_skiing_state_ratio</th>\n",
       "      <td>0.948276</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.051724</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs_runs_ratio</th>\n",
       "      <td>0.092105</td>\n",
       "      <td>0.111111</td>\n",
       "      <td>0.230769</td>\n",
       "      <td>0.145455</td>\n",
       "      <td>0.107692</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs_skiable_ratio</th>\n",
       "      <td>0.004348</td>\n",
       "      <td>0.00625</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.010296</td>\n",
       "      <td>0.00875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads_runs_ratio</th>\n",
       "      <td>0.026316</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.015385</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads_skiable_ratio</th>\n",
       "      <td>0.001242</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.00125</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                 0                    1  \\\n",
       "Name                                Alyeska Resort  Eaglecrest Ski Area   \n",
       "Region                                      Alaska               Alaska   \n",
       "state                                       Alaska               Alaska   \n",
       "summit_elev                                   3939                 2600   \n",
       "vertical_drop                                 2500                 1540   \n",
       "base_elev                                      250                 1200   \n",
       "trams                                            1                    0   \n",
       "fastSixes                                        0                    0   \n",
       "fastQuads                                        2                    0   \n",
       "quad                                             2                    0   \n",
       "triple                                           0                    0   \n",
       "double                                           0                    4   \n",
       "surface                                          2                    0   \n",
       "total_chairs                                     7                    4   \n",
       "Runs                                          76.0                 36.0   \n",
       "TerrainParks                                   2.0                  1.0   \n",
       "LongestRun_mi                                  1.0                  2.0   \n",
       "SkiableTerrain_ac                           1610.0                640.0   \n",
       "Snow Making_ac                               113.0                 60.0   \n",
       "daysOpenLastYear                             150.0                 45.0   \n",
       "yearsOpen                                     60.0                 44.0   \n",
       "averageSnowfall                              669.0                350.0   \n",
       "AdultWeekend                                  85.0                 53.0   \n",
       "projectedDaysOpen                            150.0                 90.0   \n",
       "NightSkiing_ac                               550.0                  NaN   \n",
       "resorts_per_state                                3                    3   \n",
       "resorts_per_100kcapita                    0.410091             0.410091   \n",
       "resorts_per_100ksq_mile                   0.450867             0.450867   \n",
       "resort_skiable_area_ac_state_ratio         0.70614             0.280702   \n",
       "resort_days_open_state_ratio              0.434783             0.130435   \n",
       "resort_terrain_park_state_ratio                0.5                 0.25   \n",
       "resort_night_skiing_state_ratio           0.948276                  NaN   \n",
       "total_chairs_runs_ratio                   0.092105             0.111111   \n",
       "total_chairs_skiable_ratio                0.004348              0.00625   \n",
       "fastQuads_runs_ratio                      0.026316                  0.0   \n",
       "fastQuads_skiable_ratio                   0.001242                  0.0   \n",
       "\n",
       "                                                   2                 3  \\\n",
       "Name                                Hilltop Ski Area  Arizona Snowbowl   \n",
       "Region                                        Alaska           Arizona   \n",
       "state                                         Alaska           Arizona   \n",
       "summit_elev                                     2090             11500   \n",
       "vertical_drop                                    294              2300   \n",
       "base_elev                                       1796              9200   \n",
       "trams                                              0                 0   \n",
       "fastSixes                                          0                 1   \n",
       "fastQuads                                          0                 0   \n",
       "quad                                               0                 2   \n",
       "triple                                             1                 2   \n",
       "double                                             0                 1   \n",
       "surface                                            2                 2   \n",
       "total_chairs                                       3                 8   \n",
       "Runs                                            13.0              55.0   \n",
       "TerrainParks                                     1.0               4.0   \n",
       "LongestRun_mi                                    1.0               2.0   \n",
       "SkiableTerrain_ac                               30.0             777.0   \n",
       "Snow Making_ac                                  30.0             104.0   \n",
       "daysOpenLastYear                               150.0             122.0   \n",
       "yearsOpen                                       36.0              81.0   \n",
       "averageSnowfall                                 69.0             260.0   \n",
       "AdultWeekend                                    34.0              89.0   \n",
       "projectedDaysOpen                              152.0             122.0   \n",
       "NightSkiing_ac                                  30.0               NaN   \n",
       "resorts_per_state                                  3                 2   \n",
       "resorts_per_100kcapita                      0.410091          0.027477   \n",
       "resorts_per_100ksq_mile                     0.450867           1.75454   \n",
       "resort_skiable_area_ac_state_ratio          0.013158          0.492708   \n",
       "resort_days_open_state_ratio                0.434783          0.514768   \n",
       "resort_terrain_park_state_ratio                 0.25          0.666667   \n",
       "resort_night_skiing_state_ratio             0.051724               NaN   \n",
       "total_chairs_runs_ratio                     0.230769          0.145455   \n",
       "total_chairs_skiable_ratio                       0.1          0.010296   \n",
       "fastQuads_runs_ratio                             0.0               0.0   \n",
       "fastQuads_skiable_ratio                          0.0               0.0   \n",
       "\n",
       "                                                      4  \n",
       "Name                                Sunrise Park Resort  \n",
       "Region                                          Arizona  \n",
       "state                                           Arizona  \n",
       "summit_elev                                       11100  \n",
       "vertical_drop                                      1800  \n",
       "base_elev                                          9200  \n",
       "trams                                                 0  \n",
       "fastSixes                                             0  \n",
       "fastQuads                                             1  \n",
       "quad                                                  2  \n",
       "triple                                                3  \n",
       "double                                                1  \n",
       "surface                                               0  \n",
       "total_chairs                                          7  \n",
       "Runs                                               65.0  \n",
       "TerrainParks                                        2.0  \n",
       "LongestRun_mi                                       1.2  \n",
       "SkiableTerrain_ac                                 800.0  \n",
       "Snow Making_ac                                     80.0  \n",
       "daysOpenLastYear                                  115.0  \n",
       "yearsOpen                                          49.0  \n",
       "averageSnowfall                                   250.0  \n",
       "AdultWeekend                                       78.0  \n",
       "projectedDaysOpen                                 104.0  \n",
       "NightSkiing_ac                                     80.0  \n",
       "resorts_per_state                                     2  \n",
       "resorts_per_100kcapita                         0.027477  \n",
       "resorts_per_100ksq_mile                         1.75454  \n",
       "resort_skiable_area_ac_state_ratio             0.507292  \n",
       "resort_days_open_state_ratio                   0.485232  \n",
       "resort_terrain_park_state_ratio                0.333333  \n",
       "resort_night_skiing_state_ratio                     1.0  \n",
       "total_chairs_runs_ratio                        0.107692  \n",
       "total_chairs_skiable_ratio                      0.00875  \n",
       "fastQuads_runs_ratio                           0.015385  \n",
       "fastQuads_skiable_ratio                         0.00125  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ski_data = pd.read_csv('../data/ski_data_step3_features.csv')\n",
    "ski_data.head().T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.5 Extract Big Mountain Data<a id='4.5_Extract_Big_Mountain_Data'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Big Mountain is your resort. Separate it from the rest of the data to use later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "big_mountain = ski_data[ski_data.Name == 'Big Mountain Resort']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>124</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Name</th>\n",
       "      <td>Big Mountain Resort</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Region</th>\n",
       "      <td>Montana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>state</th>\n",
       "      <td>Montana</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>summit_elev</th>\n",
       "      <td>6817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>vertical_drop</th>\n",
       "      <td>2353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>base_elev</th>\n",
       "      <td>4464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>trams</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastSixes</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>quad</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>triple</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>double</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>surface</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs</th>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Runs</th>\n",
       "      <td>105.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TerrainParks</th>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LongestRun_mi</th>\n",
       "      <td>3.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SkiableTerrain_ac</th>\n",
       "      <td>3000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Snow Making_ac</th>\n",
       "      <td>600.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>daysOpenLastYear</th>\n",
       "      <td>123.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>yearsOpen</th>\n",
       "      <td>72.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>averageSnowfall</th>\n",
       "      <td>333.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdultWeekend</th>\n",
       "      <td>81.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>projectedDaysOpen</th>\n",
       "      <td>123.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NightSkiing_ac</th>\n",
       "      <td>600.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_state</th>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_100kcapita</th>\n",
       "      <td>1.122778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resorts_per_100ksq_mile</th>\n",
       "      <td>8.161045</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_skiable_area_ac_state_ratio</th>\n",
       "      <td>0.140121</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_days_open_state_ratio</th>\n",
       "      <td>0.129338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_terrain_park_state_ratio</th>\n",
       "      <td>0.148148</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resort_night_skiing_state_ratio</th>\n",
       "      <td>0.84507</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs_runs_ratio</th>\n",
       "      <td>0.133333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>total_chairs_skiable_ratio</th>\n",
       "      <td>0.004667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads_runs_ratio</th>\n",
       "      <td>0.028571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fastQuads_skiable_ratio</th>\n",
       "      <td>0.001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                    124\n",
       "Name                                Big Mountain Resort\n",
       "Region                                          Montana\n",
       "state                                           Montana\n",
       "summit_elev                                        6817\n",
       "vertical_drop                                      2353\n",
       "base_elev                                          4464\n",
       "trams                                                 0\n",
       "fastSixes                                             0\n",
       "fastQuads                                             3\n",
       "quad                                                  2\n",
       "triple                                                6\n",
       "double                                                0\n",
       "surface                                               3\n",
       "total_chairs                                         14\n",
       "Runs                                              105.0\n",
       "TerrainParks                                        4.0\n",
       "LongestRun_mi                                       3.3\n",
       "SkiableTerrain_ac                                3000.0\n",
       "Snow Making_ac                                    600.0\n",
       "daysOpenLastYear                                  123.0\n",
       "yearsOpen                                          72.0\n",
       "averageSnowfall                                   333.0\n",
       "AdultWeekend                                       81.0\n",
       "projectedDaysOpen                                 123.0\n",
       "NightSkiing_ac                                    600.0\n",
       "resorts_per_state                                    12\n",
       "resorts_per_100kcapita                         1.122778\n",
       "resorts_per_100ksq_mile                        8.161045\n",
       "resort_skiable_area_ac_state_ratio             0.140121\n",
       "resort_days_open_state_ratio                   0.129338\n",
       "resort_terrain_park_state_ratio                0.148148\n",
       "resort_night_skiing_state_ratio                 0.84507\n",
       "total_chairs_runs_ratio                        0.133333\n",
       "total_chairs_skiable_ratio                     0.004667\n",
       "fastQuads_runs_ratio                           0.028571\n",
       "fastQuads_skiable_ratio                           0.001"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "big_mountain.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(277, 36)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ski_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ski_data = ski_data[ski_data.Name != 'Big Mountain Resort']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(276, 36)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ski_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.6 Train/Test Split<a id='4.6_Train/Test_Split'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, you've treated ski resort data as a single entity. In machine learning, when you train your model on all of your data, you end up with no data set aside to evaluate model performance. You could keep making more and more complex models that fit the data better and better and not realise you were overfitting to that one set of samples. By partitioning the data into training and testing splits, without letting a model (or missing-value imputation) learn anything about the test split, you have a somewhat independent assessment of how your model might perform in the future. An often overlooked subtlety here is that people all too frequently use the test set to assess model performance _and then compare multiple models to pick the best_. This means their overall model selection process is  fitting to one specific data set, now the test split. You could keep going, trying to get better and better performance on that one data set, but that's  where cross-validation becomes especially useful. While training models, a test split is very useful as a final check on expected future performance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What partition sizes would you have with a 70/30 train/test split?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(193.2, 82.8)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ski_data) * .7, len(ski_data) * .3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(ski_data.drop(columns='AdultWeekend'), \n",
    "                                                    ski_data.AdultWeekend, test_size=0.3, \n",
    "                                                    random_state=47)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((193, 35), (83, 35))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((193,), (83,))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((193, 32), (83, 32))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 1#\n",
    "#Save the 'Name', 'state', and 'Region' columns from the train/test data into names_train and names_test\n",
    "#Then drop those columns from `X_train` and `X_test`. Use 'inplace=True'\n",
    "names_list = ['Name', 'state', 'Region']\n",
    "names_train = X_train[names_list]\n",
    "names_test = X_test[names_list]\n",
    "X_train.drop(columns=names_list, inplace=True)\n",
    "X_test.drop(columns=names_list, inplace=True)\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "summit_elev                             int64\n",
       "vertical_drop                           int64\n",
       "base_elev                               int64\n",
       "trams                                   int64\n",
       "fastSixes                               int64\n",
       "fastQuads                               int64\n",
       "quad                                    int64\n",
       "triple                                  int64\n",
       "double                                  int64\n",
       "surface                                 int64\n",
       "total_chairs                            int64\n",
       "Runs                                  float64\n",
       "TerrainParks                          float64\n",
       "LongestRun_mi                         float64\n",
       "SkiableTerrain_ac                     float64\n",
       "Snow Making_ac                        float64\n",
       "daysOpenLastYear                      float64\n",
       "yearsOpen                             float64\n",
       "averageSnowfall                       float64\n",
       "projectedDaysOpen                     float64\n",
       "NightSkiing_ac                        float64\n",
       "resorts_per_state                       int64\n",
       "resorts_per_100kcapita                float64\n",
       "resorts_per_100ksq_mile               float64\n",
       "resort_skiable_area_ac_state_ratio    float64\n",
       "resort_days_open_state_ratio          float64\n",
       "resort_terrain_park_state_ratio       float64\n",
       "resort_night_skiing_state_ratio       float64\n",
       "total_chairs_runs_ratio               float64\n",
       "total_chairs_skiable_ratio            float64\n",
       "fastQuads_runs_ratio                  float64\n",
       "fastQuads_skiable_ratio               float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 2#\n",
    "#Check the `dtypes` attribute of `X_train` to verify all features are numeric\n",
    "X_train.dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "summit_elev                             int64\n",
       "vertical_drop                           int64\n",
       "base_elev                               int64\n",
       "trams                                   int64\n",
       "fastSixes                               int64\n",
       "fastQuads                               int64\n",
       "quad                                    int64\n",
       "triple                                  int64\n",
       "double                                  int64\n",
       "surface                                 int64\n",
       "total_chairs                            int64\n",
       "Runs                                  float64\n",
       "TerrainParks                          float64\n",
       "LongestRun_mi                         float64\n",
       "SkiableTerrain_ac                     float64\n",
       "Snow Making_ac                        float64\n",
       "daysOpenLastYear                      float64\n",
       "yearsOpen                             float64\n",
       "averageSnowfall                       float64\n",
       "projectedDaysOpen                     float64\n",
       "NightSkiing_ac                        float64\n",
       "resorts_per_state                       int64\n",
       "resorts_per_100kcapita                float64\n",
       "resorts_per_100ksq_mile               float64\n",
       "resort_skiable_area_ac_state_ratio    float64\n",
       "resort_days_open_state_ratio          float64\n",
       "resort_terrain_park_state_ratio       float64\n",
       "resort_night_skiing_state_ratio       float64\n",
       "total_chairs_runs_ratio               float64\n",
       "total_chairs_skiable_ratio            float64\n",
       "fastQuads_runs_ratio                  float64\n",
       "fastQuads_skiable_ratio               float64\n",
       "dtype: object"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 3#\n",
    "#Repeat this check for the test split in `X_test`\n",
    "X_test.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have only numeric features in your X now!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.7 Initial Not-Even-A-Model<a id='4.7_Initial_Not-Even-A-Model'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A good place to start is to see how good the mean is as a predictor. In other words, what if you simply say your best guess is the average price?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63.811088082901556"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 4#\n",
    "#Calculate the mean of `y_train`\n",
    "train_mean = y_train.mean()\n",
    "train_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sklearn`'s `DummyRegressor` easily does this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[63.81108808]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 5#\n",
    "#Fit the dummy regressor on the training data\n",
    "#Hint, call its `.fit()` method with `X_train` and `y_train` as arguments\n",
    "#Then print the object's `constant_` attribute and verify it's the same as the mean above\n",
    "dumb_reg = DummyRegressor(strategy='mean')\n",
    "dumb_reg.fit(X_train, y_train)\n",
    "dumb_reg.constant_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How good is this? How closely does this match, or explain, the actual values? There are many ways of assessing how good one set of values agrees with another, which brings us to the subject of metrics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.7.1 Metrics<a id='4.7.1_Metrics'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.7.1.1 R-squared, or coefficient of determination<a id='4.7.1.1_R-squared,_or_coefficient_of_determination'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One measure is $R^2$, the [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination). This is a measure of the proportion of variance in the dependent variable (our ticket price) that is predicted by our \"model\". The linked Wikipedia articles gives a nice explanation of how negative values can arise. This is frequently a cause of confusion for newcomers who, reasonably, ask how can a squared value be negative?\n",
    "\n",
    "Recall the mean can be denoted by $\\bar{y}$, where\n",
    "\n",
    "$$\\bar{y} = \\frac{1}{n}\\sum_{i=1}^ny_i$$\n",
    "\n",
    "and where $y_i$ are the individual values of the dependent variable.\n",
    "\n",
    "The total sum of squares (error), can be expressed as\n",
    "\n",
    "$$SS_{tot} = \\sum_i(y_i-\\bar{y})^2$$\n",
    "\n",
    "The above formula should be familiar as it's simply the variance without the denominator to scale (divide) by the sample size.\n",
    "\n",
    "The residual sum of squares is similarly defined to be\n",
    "\n",
    "$$SS_{res} = \\sum_i(y_i-\\hat{y})^2$$\n",
    "\n",
    "where $\\hat{y}$ are our predicted values for the depended variable.\n",
    "\n",
    "The coefficient of determination, $R^2$, here is given by\n",
    "\n",
    "$$R^2 = 1 - \\frac{SS_{res}}{SS_{tot}}$$\n",
    "\n",
    "Putting it into words, it's one minus the ratio of the residual variance to the original variance. Thus, the baseline model here, which always predicts $\\bar{y}$, should give $R^2=0$. A model that perfectly predicts the observed values would have no residual error and so give $R^2=1$. Models that do worse than predicting the mean will have increased the sum of squares of residuals and so produce a negative $R^2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 6#\n",
    "#Calculate the R^2 as defined above\n",
    "def r_squared(y, ypred):\n",
    "    \"\"\"R-squared score.\n",
    "    \n",
    "    Calculate the R-squared, or coefficient of determination, of the input.\n",
    "    \n",
    "    Arguments:\n",
    "    y -- the observed values\n",
    "    ypred -- the predicted values\n",
    "    \"\"\"\n",
    "    ybar = np.sum(y) / len(y) #yes, we could use np.mean(y)\n",
    "    sum_sq_tot = np.mean((y - ybar)**2) #total sum of squares error\n",
    "    sum_sq_res = np.mean((y - ypred)**2) #residual sum of squares error\n",
    "    R2 = 1.0 - sum_sq_tot/sum_sq_res\n",
    "   \n",
    "    return R2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make your predictions by creating an array of length the size of the training set with the single value of the mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([63.81108808, 63.81108808, 63.81108808, 63.81108808, 63.81108808])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_tr_pred_ = train_mean * np.ones(len(y_train))\n",
    "y_tr_pred_[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([63.81108808, 63.81108808, 63.81108808, 63.81108808, 63.81108808])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# above line of code is simplified -- per suggestion by Mentor\n",
    "y_tr_pred = np.array([train_mean] * 5)\n",
    "y_tr_pred_[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember the `sklearn` dummy regressor? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([63.81108808, 63.81108808, 63.81108808, 63.81108808, 63.81108808])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_tr_pred = dumb_reg.predict(X_train)\n",
    "y_tr_pred[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that `DummyRegressor` produces exactly the same results and saves you having to mess about broadcasting the mean (or whichever other statistic we used - check out the [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.dummy.DummyRegressor.html) to see what's available) to an array of the appropriate length. It also gives you an object with `fit()` and `predict()` methods as well so you can use them as conveniently as any other `sklearn` estimator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r_squared(y_train, y_tr_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exactly as expected, if you use the average value as your prediction, you get an $R^2$ of zero _on our training set_. What if you use this \"model\" to predict unseen values from the test set? Remember, of course, that your \"model\" is trained on the training set; you still use the training set mean as your prediction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make your predictions by creating an array of length the size of the test set with the single value of the (training) mean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0031137940436897216"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_te_pred = train_mean * np.ones(len(y_test))\n",
    "r_squared(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, you can expect performance on a test set to be slightly worse than on the training set. As you are getting an $R^2$ of zero on the training set, there's nowhere to go but negative!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$R^2$ is a common metric, and interpretable in terms of the amount of variance explained, it's less appealing if you want an idea of how \"close\" your predictions are to the true values. Metrics that summarise the difference between predicted and actual values are _mean absolute error_ and _mean squared error_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.7.1.2 Mean Absolute Error<a id='4.7.1.2_Mean_Absolute_Error'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is very simply the average of the absolute errors:\n",
    "\n",
    "$$MAE = \\frac{1}{n}\\sum_i^n|y_i - \\hat{y}|$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 7#\n",
    "#Calculate the MAE as defined above\n",
    "def mae(y, ypred):\n",
    "    \"\"\"Mean absolute error.\n",
    "    \n",
    "    Calculate the mean absolute error of the arguments\n",
    "\n",
    "    Arguments:\n",
    "    y -- the observed values\n",
    "    ypred -- the predicted values\n",
    "    \"\"\"\n",
    "    #abs_error = np.abs(y - ypred)\n",
    "    #mae = np.mean(abs_error)\n",
    "    mae =np.mean(np.abs(y - ypred)) # added this per suggestion by Mentor\n",
    "    return mae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.923463717146785"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mae(y_train, y_tr_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19.136142081278486"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mae(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mean absolute error is arguably the most intuitive of all the metrics, this essentially tells you that, on average, you might expect to be off by around \\\\$19 if you guessed ticket price based on an average of known values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.7.1.3 Mean Squared Error<a id='4.7.1.3_Mean_Squared_Error'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another common metric (and an important one internally for optimizing machine learning models) is the mean squared error. This is simply the average of the square of the errors:\n",
    "\n",
    "$$MSE = \\frac{1}{n}\\sum_i^n(y_i - \\hat{y})^2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Code task 8#\n",
    "#Calculate the MSE as defined above\n",
    "def mse(y, ypred):\n",
    "    \"\"\"Mean square error.\n",
    "    \n",
    "    Calculate the mean square error of the arguments\n",
    "\n",
    "    Arguments:\n",
    "    y -- the observed values\n",
    "    ypred -- the predicted values\n",
    "    \"\"\"\n",
    "    #sq_error = (y - ypred)**2\n",
    "    #mse = np.mean(sq_error)\n",
    "    mse = np.mean((y - ypred)**2) # added as per suggestion by Mentor\n",
    "    return mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "614.1334096969057"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mse(y_train, y_tr_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "581.4365441953481"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mse(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So here, you get a slightly better MSE on the test set than you did on the train set. And what does a squared error mean anyway? To convert this back to our measurement space, we often take the square root, to form the _root mean square error_ thus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([24.78171523, 24.11299534])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt([mse(y_train, y_tr_pred), mse(y_test, y_te_pred)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.7.2 sklearn metrics<a id='4.7.2_sklearn_metrics'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are good, but you don't want to have to define functions every time we want to assess performance. `sklearn.metrics` provides many commonly used metrics, included the ones above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.7.2.0.1 R-squared<a id='4.7.2.0.1_R-squared'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, -0.0031235200417913944)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.7.2.0.2 Mean absolute error<a id='4.7.2.0.2_Mean_absolute_error'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(17.92346371714677, 19.136142081278486)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.7.2.0.3 Mean squared error<a id='4.7.2.0.3_Mean_squared_error'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(614.1334096969046, 581.4365441953483)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_squared_error(y_train, y_tr_pred), mean_squared_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.7.3 Note On Calculating Metrics<a id='4.7.3_Note_On_Calculating_Metrics'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When calling functions to calculate metrics, it is important to take care in the order of the arguments. Two of the metrics above actually don't care if the arguments are reversed; one does. Which one cares?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a Jupyter code cell, running `r2_score?` will bring up the docstring for the function, and `r2_score??` will bring up the actual code of the function! Try them and compare the source for `sklearn`'s function with yours. Feel free to explore what happens when you reverse the order of the arguments and compare behaviour of `sklearn`'s function and yours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, -3.041041349306602e+30)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train set - sklearn\n",
    "# correct order, incorrect order\n",
    "r2_score(y_train, y_tr_pred), r2_score(y_tr_pred, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.0031235200417913944, 0.0)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test set - sklearn\n",
    "# correct order, incorrect order\n",
    "r2_score(y_test, y_te_pred), r2_score(y_te_pred, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.0)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train set - using our homebrew function\n",
    "# correct order, incorrect order\n",
    "r_squared(y_train, y_tr_pred), r_squared(y_tr_pred, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0031137940436897216, 1.0)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test set - using our homebrew function\n",
    "# correct order, incorrect order\n",
    "r_squared(y_test, y_te_pred), r_squared(y_te_pred, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get very different results swapping the argument order. It's worth highlighting this because data scientists do this too much in the real world! Don't be one of them! Frequently the argument order doesn't matter, but it will bite you when you do it with a function that does care. It's sloppy, bad practice and if you don't make a habit of putting arguments in the right order, you will forget!\n",
    "\n",
    "Remember:\n",
    "* argument order matters,\n",
    "* check function syntax with `func?` in a code cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.8 Initial Models<a id='4.8_Initial_Models'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.8.1 Imputing missing feature (predictor) values<a id='4.8.1_Imputing_missing_feature_(predictor)_values'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall when performing EDA, you imputed (filled in) some missing values in pandas. You did this judiciously for exploratory/visualization purposes. You left many missing values in the data. You can impute missing values using scikit-learn, but note that you should learn values to impute from a train split and apply that to the test split to then assess how well your imputation worked."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.1.1 Impute missing values with median<a id='4.8.1.1_Impute_missing_values_with_median'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's missing values. Recall from your data exploration that many distributions were skewed. Your first thought might be to impute missing values using the median."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.1 Learn the values to impute from the train set<a id='4.8.1.1.1_Learn_the_values_to_impute_from_the_train_set'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "summit_elev                           2215.000000\n",
       "vertical_drop                          750.000000\n",
       "base_elev                             1300.000000\n",
       "trams                                    0.000000\n",
       "fastSixes                                0.000000\n",
       "fastQuads                                0.000000\n",
       "quad                                     1.000000\n",
       "triple                                   1.000000\n",
       "double                                   1.000000\n",
       "surface                                  2.000000\n",
       "total_chairs                             7.000000\n",
       "Runs                                    28.000000\n",
       "TerrainParks                             2.000000\n",
       "LongestRun_mi                            1.000000\n",
       "SkiableTerrain_ac                      170.000000\n",
       "Snow Making_ac                          96.500000\n",
       "daysOpenLastYear                       109.000000\n",
       "yearsOpen                               57.000000\n",
       "averageSnowfall                        120.000000\n",
       "projectedDaysOpen                      115.000000\n",
       "NightSkiing_ac                          70.000000\n",
       "resorts_per_state                       15.000000\n",
       "resorts_per_100kcapita                   0.248243\n",
       "resorts_per_100ksq_mile                 22.902162\n",
       "resort_skiable_area_ac_state_ratio       0.051458\n",
       "resort_days_open_state_ratio             0.071225\n",
       "resort_terrain_park_state_ratio          0.069444\n",
       "resort_night_skiing_state_ratio          0.077081\n",
       "total_chairs_runs_ratio                  0.200000\n",
       "total_chairs_skiable_ratio               0.040323\n",
       "fastQuads_runs_ratio                     0.000000\n",
       "fastQuads_skiable_ratio                  0.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These are the values we'll use to fill in any missing values\n",
    "X_defaults_median = X_train.median()\n",
    "X_defaults_median"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.2 Apply the imputation to both train and test splits<a id='4.8.1.1.2_Apply_the_imputation_to_both_train_and_test_splits'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 9#\n",
    "#Call `X_train` and `X_test`'s `fillna()` method, passing `X_defaults_median` as the values to use\n",
    "#Assign the results to `X_tr` and `X_te`, respectively\n",
    "X_tr = X_train.fillna(X_defaults_median)\n",
    "X_te = X_test.fillna(X_defaults_median)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.3 Scale the data<a id='4.8.1.1.3_Scale_the_data'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you have features measured in many different units, with numbers that vary by orders of magnitude, start off by scaling them to put them all on a consistent scale. The [StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) scales each feature to zero mean and unit variance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 10#\n",
    "#Call the StandardScaler`s fit method on `X_tr` to fit the scaler\n",
    "#then use it's `transform()` method to apply the scaling to both the train and test split\n",
    "#data (`X_tr` and `X_te`), naming the results `X_tr_scaled` and `X_te_scaled`, respectively\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X_tr)\n",
    "X_tr_scaled = scaler.transform(X_tr)\n",
    "X_te_scaled = scaler.transform(X_te)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.4 Train the model on the train split<a id='4.8.1.1.4_Train_the_model_on_the_train_split'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "lm = LinearRegression().fit(X_tr_scaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.5 Make predictions using the model on both train and test splits<a id='4.8.1.1.5_Make_predictions_using_the_model_on_both_train_and_test_splits'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 11#\n",
    "#Call the `predict()` method of the model (`lm`) on both the (scaled) train and test data\n",
    "#Assign the predictions to `y_tr_pred` and `y_te_pred`, respectively\n",
    "y_tr_pred = lm.predict(X_tr_scaled)\n",
    "y_te_pred = lm.predict(X_te_scaled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.1.6 Assess model performance<a id='4.8.1.1.6_Assess_model_performance'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8177988515690603, 0.7209725843435144)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# r^2 - train, test\n",
    "median_r2 = r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)\n",
    "median_r2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that you estimated ticket price by simply using a known average. As expected, this produced an $R^2$ of zero for both the training and test set, because $R^2$ tells us how much of the variance you're explaining beyond that of using just the mean, and you were using just the mean. Here we see that our simple linear regression model explains over 80% of the variance on the train set and over 70% on the test set. Clearly you are onto something, although the much lower value for the test set suggests you're overfitting somewhat. This isn't a surprise as you've made no effort to select a parsimonious set of features or deal with multicollinearity in our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.547850301825427, 9.407020118581318)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 12#\n",
    "#Now calculate the mean absolute error scores using `sklearn`'s `mean_absolute_error` function\n",
    "# as we did above for R^2\n",
    "# MAE - train, test\n",
    "median_mae = mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)\n",
    "median_mae"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using this model, then, on average you'd expect to estimate a ticket price within \\\\$9 or so of the real price. This is much, much better than the \\\\$19 from just guessing using the average. There may be something to this machine learning lark after all!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(111.8958125365848, 161.73156451192273)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 13#\n",
    "#And also do the same using `sklearn`'s `mean_squared_error`\n",
    "# MSE - train, test\n",
    "median_mse = mean_squared_error(y_train, y_tr_pred), mean_squared_error(y_test, y_te_pred)\n",
    "median_mse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.1.2 Impute missing values with the mean<a id='4.8.1.2_Impute_missing_values_with_the_mean'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You chose to use the median for filling missing values because of the skew of many of our predictor feature distributions. What if you wanted to try something else, such as the mean?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.1 Learn the values to impute from the train set<a id='4.8.1.2.1_Learn_the_values_to_impute_from_the_train_set'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "summit_elev                           4074.554404\n",
       "vertical_drop                         1043.196891\n",
       "base_elev                             3020.512953\n",
       "trams                                    0.103627\n",
       "fastSixes                                0.072539\n",
       "fastQuads                                0.673575\n",
       "quad                                     1.010363\n",
       "triple                                   1.440415\n",
       "double                                   1.813472\n",
       "surface                                  2.497409\n",
       "total_chairs                             7.611399\n",
       "Runs                                    41.188482\n",
       "TerrainParks                             2.434783\n",
       "LongestRun_mi                            1.293122\n",
       "SkiableTerrain_ac                      448.785340\n",
       "Snow Making_ac                         129.601190\n",
       "daysOpenLastYear                       110.100629\n",
       "yearsOpen                               56.559585\n",
       "averageSnowfall                        162.310160\n",
       "projectedDaysOpen                      115.920245\n",
       "NightSkiing_ac                          86.384615\n",
       "resorts_per_state                       16.264249\n",
       "resorts_per_100kcapita                   0.424802\n",
       "resorts_per_100ksq_mile                 40.957785\n",
       "resort_skiable_area_ac_state_ratio       0.097205\n",
       "resort_days_open_state_ratio             0.126014\n",
       "resort_terrain_park_state_ratio          0.116022\n",
       "resort_night_skiing_state_ratio          0.155024\n",
       "total_chairs_runs_ratio                  0.271441\n",
       "total_chairs_skiable_ratio               0.070483\n",
       "fastQuads_runs_ratio                     0.010401\n",
       "fastQuads_skiable_ratio                  0.001633\n",
       "dtype: float64"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 14#\n",
    "#As we did for the median above, calculate mean values for imputing missing values\n",
    "# These are the values we'll use to fill in any missing values\n",
    "X_defaults_mean = X_train.mean()\n",
    "X_defaults_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By eye, you can immediately tell that your replacement values are much higher than those from using the median."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.2 Apply the imputation to both train and test splits<a id='4.8.1.2.2_Apply_the_imputation_to_both_train_and_test_splits'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_tr = X_train.fillna(X_defaults_mean)\n",
    "X_te = X_test.fillna(X_defaults_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.3 Scale the data<a id='4.8.1.2.3_Scale_the_data'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "scaler.fit(X_tr)\n",
    "X_tr_scaled = scaler.transform(X_tr)\n",
    "X_te_scaled = scaler.transform(X_te)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.4 Train the model on the train split<a id='4.8.1.2.4_Train_the_model_on_the_train_split'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "lm = LinearRegression().fit(X_tr_scaled, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.5 Make predictions using the model on both train and test splits<a id='4.8.1.2.5_Make_predictions_using_the_model_on_both_train_and_test_splits'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_tr_pred = lm.predict(X_tr_scaled)\n",
    "y_te_pred = lm.predict(X_te_scaled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.8.1.2.6 Assess model performance<a id='4.8.1.2.6_Assess_model_performance'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8170154093990024, 0.7163814716959958)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.536884040670977, 9.416375625789277)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(112.37695054778278, 164.39269309524374)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_squared_error(y_train, y_tr_pred), mean_squared_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results don't seem very different to when you used the median for imputing missing values. Perhaps it doesn't make much difference here. Maybe your overtraining dominates. Maybe other feature transformations, such as taking the log, would help. You could try with just a subset of features rather than using all of them as inputs.\n",
    "\n",
    "To perform the median/mean comparison, you copied and pasted a lot of code just to change the function for imputing missing values. It would make more sense to write a function that performed the sequence of steps:\n",
    "1. impute missing values\n",
    "2. scale the features\n",
    "3. train a model\n",
    "4. calculate model performance\n",
    "\n",
    "But these are common steps and `sklearn` provides something much better than writing custom functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.8.2 Pipelines<a id='4.8.2_Pipelines'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the most important and useful components of `sklearn` is the [pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html). In place of `panda`'s `fillna` DataFrame method, there is `sklearn`'s `SimpleImputer`. Remember the first linear model above performed the steps:\n",
    "\n",
    "1. replace missing values with the median for each feature\n",
    "2. scale the data to zero mean and unit variance\n",
    "3. train a linear regression model\n",
    "\n",
    "and all these steps were trained on the train split and then applied to the test split for assessment.\n",
    "\n",
    "The pipeline below defines exactly those same steps. Crucially, the resultant `Pipeline` object has a `fit()` method and a `predict()` method, just like the `LinearRegression()` object itself. Just as you might create a linear regression model and train it with `.fit()` and predict with `.predict()`, you can wrap the entire process of imputing and feature scaling and regression in a single object you can train with `.fit()` and predict with `.predict()`. And that's basically a pipeline: a model on steroids."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.2.1 Define the pipeline<a id='4.8.2.1_Define_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipe = make_pipeline(\n",
    "    SimpleImputer(strategy='median'), \n",
    "    StandardScaler(), \n",
    "    LinearRegression()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sklearn.pipeline.Pipeline"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pipe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(pipe, 'fit'), hasattr(pipe, 'predict')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.2.2 Fit the pipeline<a id='4.8.2.2_Fit_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, a single call to the pipeline's `fit()` method combines the steps of learning the imputation (determining what values to use to fill the missing ones), the scaling (determining the mean to subtract and the variance to divide by), and then training the model. It does this all in the one call with the training data as arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('simpleimputer', SimpleImputer(strategy='median')),\n",
       "                ('standardscaler', StandardScaler()),\n",
       "                ('linearregression', LinearRegression())])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 15#\n",
    "#Call the pipe's `fit()` method with `X_train` and `y_train` as arguments\n",
    "pipe.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.2.3 Make predictions on the train and test sets<a id='4.8.2.3_Make_predictions_on_the_train_and_test_sets'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_tr_pred = pipe.predict(X_train)\n",
    "y_te_pred = pipe.predict(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.8.2.4 Assess performance<a id='4.8.2.4_Assess_performance'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8177988515690603, 0.7209725843435144)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And compare with your earlier (non-pipeline) result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8177988515690603, 0.7209725843435144)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "median_r2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.547850301825427, 9.407020118581318)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare with your earlier result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8.547850301825427, 9.407020118581318)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "median_mae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(111.8958125365848, 161.73156451192273)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_squared_error(y_train, y_tr_pred), mean_squared_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare with your earlier result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(111.8958125365848, 161.73156451192273)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "median_mse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results confirm the pipeline is doing exactly what's expected, and results are identical to your earlier steps. This allows you to move faster but with confidence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.9 Refining The Linear Model<a id='4.9_Refining_The_Linear_Model'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You suspected the model was overfitting. This is no real surprise given the number of features you blindly used. It's likely a judicious subset of features would generalize better. `sklearn` has a number of feature selection functions available. The one you'll use here is `SelectKBest` which, as you might guess, selects the k best features. You can read about SelectKBest \n",
    "[here](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html#sklearn.feature_selection.SelectKBest). `f_regression` is just the [score function](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.f_regression.html#sklearn.feature_selection.f_regression) you're using because you're performing regression. It's important to choose an appropriate one for your machine learning task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.1 Define the pipeline<a id='4.9.1_Define_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redefine your pipeline to include this feature selection step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 16#\n",
    "#Add `SelectKBest` as a step in the pipeline between `StandardScaler()` and `LinearRegression()`\n",
    "#Don't forget to tell it to use `f_regression` as its score function\n",
    "pipe = make_pipeline(\n",
    "    SimpleImputer(strategy='median'), \n",
    "    StandardScaler(),\n",
    "    SelectKBest(f_regression),\n",
    "    LinearRegression()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.2 Fit the pipeline<a id='4.9.2_Fit_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('simpleimputer', SimpleImputer(strategy='median')),\n",
       "                ('standardscaler', StandardScaler()),\n",
       "                ('selectkbest',\n",
       "                 SelectKBest(score_func=<function f_regression at 0x00000284963AA820>)),\n",
       "                ('linearregression', LinearRegression())])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.3 Assess performance on the train and test set<a id='4.9.3_Assess_performance_on_the_train_and_test_set'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_tr_pred = pipe.predict(X_train)\n",
    "y_te_pred = pipe.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7674914326052744, 0.6259877354190834)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9.501495079727484, 11.201830190332055)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This has made things worse! Clearly selecting a subset of features has an impact on performance. `SelectKBest` defaults to k=10. You've just seen that 10 is worse than using all features. What is the best k? You could create a new pipeline with a different value of k:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.4 Define a new pipeline to select a different number of features<a id='4.9.4_Define_a_new_pipeline_to_select_a_different_number_of_features'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 17#\n",
    "#Modify the `SelectKBest` step to use a value of 15 for k\n",
    "pipe15 = make_pipeline(\n",
    "    SimpleImputer(strategy='median'), \n",
    "    StandardScaler(),\n",
    "    SelectKBest(f_regression, k=15),\n",
    "    LinearRegression()\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.5 Fit the pipeline<a id='4.9.5_Fit_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pipeline(steps=[('simpleimputer', SimpleImputer(strategy='median')),\n",
       "                ('standardscaler', StandardScaler()),\n",
       "                ('selectkbest',\n",
       "                 SelectKBest(k=15,\n",
       "                             score_func=<function f_regression at 0x00000284963AA820>)),\n",
       "                ('linearregression', LinearRegression())])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pipe15.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.6 Assess performance on train and test data<a id='4.9.6_Assess_performance_on_train_and_test_data'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_tr_pred = pipe15.predict(X_train)\n",
    "y_te_pred = pipe15.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7924096060483825, 0.6376199973170797)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_train, y_tr_pred), r2_score(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9.211767769307114, 10.488246867294357)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_train, y_tr_pred), mean_absolute_error(y_test, y_te_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could keep going, trying different values of k, training a model, measuring performance on the test set, and then picking the model with the best test set performance. There's a fundamental problem with this approach: _you're tuning the model to the arbitrary test set_! If you continue this way you'll end up with a model works well on the particular quirks of our test set _but fails to generalize to new data_. The whole point of keeping a test set is for it to be a set of that new data, to check how well our model might perform on data it hasn't seen.\n",
    "\n",
    "The way around this is a technique called _cross-validation_. You partition the training set into k folds, train our model on k-1 of those folds, and calculate performance on the fold not used in training. This procedure then cycles through k times with a different fold held back each time. Thus you end up building k models on k sets of data with k estimates of how the model performs on unseen data but without having to touch the test set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.7 Assessing performance using cross-validation<a id='4.9.7_Assessing_performance_using_cross-validation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv_results = cross_validate(pipe15, X_train, y_train, cv=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.63760862, 0.72831381, 0.74443537, 0.5487915 , 0.50441472])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_scores = cv_results['test_score']\n",
    "cv_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Without using the same random state for initializing the CV folds, your actual numbers will be different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6327128053007867, 0.09502487849877693)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(cv_scores), np.std(cv_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results highlight that assessing model performance in inherently open to variability. You'll get different results depending on the quirks of which points are in which fold. An advantage of this is that you can also obtain an estimate of the variability, or uncertainty, in your performance estimate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.44, 0.82])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round((np.mean(cv_scores) - 2 * np.std(cv_scores), np.mean(cv_scores) + 2 * np.std(cv_scores)), 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.9.8 Hyperparameter search using GridSearchCV<a id='4.9.8_Hyperparameter_search_using_GridSearchCV'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pulling the above together, we have:\n",
    "* a pipeline that\n",
    "    * imputes missing values\n",
    "    * scales the data\n",
    "    * selects the k best features\n",
    "    * trains a linear regression model\n",
    "* a technique (cross-validation) for estimating model performance\n",
    "\n",
    "Now you want to use cross-validation for multiple values of k and use cross-validation to pick the value of k that gives the best performance. `make_pipeline` automatically names each step as the lowercase name of the step and the parameters of the step are then accessed by appending a double underscore followed by the parameter name. You know the name of the step will be 'selectkbest' and you know the parameter is 'k'.\n",
    "\n",
    "You can also list the names of all the parameters in a pipeline like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['memory', 'steps', 'verbose', 'simpleimputer', 'standardscaler', 'selectkbest', 'linearregression', 'simpleimputer__add_indicator', 'simpleimputer__copy', 'simpleimputer__fill_value', 'simpleimputer__missing_values', 'simpleimputer__strategy', 'simpleimputer__verbose', 'standardscaler__copy', 'standardscaler__with_mean', 'standardscaler__with_std', 'selectkbest__k', 'selectkbest__score_func', 'linearregression__copy_X', 'linearregression__fit_intercept', 'linearregression__n_jobs', 'linearregression__normalize', 'linearregression__positive'])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 18#\n",
    "#Call `pipe`'s `get_params()` method to get a dict of available parameters and print their names\n",
    "#using dict's `keys()` method\n",
    "pipe.get_params().keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above can be particularly useful as your pipelines becomes more complex (you can even nest pipelines within pipelines)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = [k+1 for k in range(len(X_train.columns))]\n",
    "grid_params = {'selectkbest__k': k}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you have a range of `k` to investigate. Is 1 feature best? 2? 3? 4? All of them? You could write a for loop and iterate over each possible value, doing all the housekeeping oyurselves to track the best value of k. But this is  a common task so there's a built in function in `sklearn`. This is [`GridSearchCV`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html).\n",
    "This takes the pipeline object, in fact it takes anything with a `.fit()` and `.predict()` method. In simple cases with no feature selection or imputation or feature scaling etc. you may see the classifier or regressor object itself directly passed into `GridSearchCV`. The other key input is the parameters and values to search over. Optional parameters include the cross-validation strategy and number of CPUs to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr_grid_cv = GridSearchCV(pipe, param_grid=grid_params, cv=5, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5,\n",
       "             estimator=Pipeline(steps=[('simpleimputer',\n",
       "                                        SimpleImputer(strategy='median')),\n",
       "                                       ('standardscaler', StandardScaler()),\n",
       "                                       ('selectkbest',\n",
       "                                        SelectKBest(score_func=<function f_regression at 0x00000284963AA820>)),\n",
       "                                       ('linearregression',\n",
       "                                        LinearRegression())]),\n",
       "             n_jobs=-1,\n",
       "             param_grid={'selectkbest__k': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\n",
       "                                            12, 13, 14, 15, 16, 17, 18, 19, 20,\n",
       "                                            21, 22, 23, 24, 25, 26, 27, 28, 29,\n",
       "                                            30, ...]})"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_grid_cv.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_mean = lr_grid_cv.cv_results_['mean_test_score']\n",
    "score_std = lr_grid_cv.cv_results_['std_test_score']\n",
    "cv_k = [k for k in lr_grid_cv.cv_results_['param_selectkbest__k']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'selectkbest__k': 8}"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 19#\n",
    "#Print the `best_params_` attribute of `lr_grid_cv`\n",
    "lr_grid_cv.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Code task 20#\n",
    "#Assign the value of k from the above dict of `best_params_` and assign it to `best_k`\n",
    "best_k = lr_grid_cv.best_params_['selectkbest__k']\n",
    "plt.subplots(figsize=(10, 5))\n",
    "plt.errorbar(cv_k, score_mean, yerr=score_std)\n",
    "plt.axvline(x=best_k, c='r', ls='--', alpha=.5)\n",
    "plt.xlabel('k')\n",
    "plt.ylabel('CV score (r-squared)')\n",
    "plt.title('Pipeline mean CV score (error bars +/- 1sd)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above suggests a good value for k is 8. There was an initial rapid increase with k, followed by a slow decline. Also noticeable is the variance of the results greatly increase above k=8. As you increasingly overfit, expect greater swings in performance as different points move in and out of the train/test folds."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which features were most useful? Step into your best model, shown below. Starting with the fitted grid search object, you get the best estimator, then the named step 'selectkbest', for which you can its `get_support()` method for a logical mask of the features selected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "selected = lr_grid_cv.best_estimator_.named_steps.selectkbest.get_support()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, instead of using the 'selectkbest' named step, you can access the named step for the linear regression model and, from that, grab the model coefficients via its `coef_` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SkiableTerrain_ac    -5.249780\n",
       "trams                -4.142024\n",
       "LongestRun_mi         0.181814\n",
       "Runs                  5.370555\n",
       "fastQuads             5.745626\n",
       "total_chairs          5.794156\n",
       "Snow Making_ac        6.290074\n",
       "vertical_drop        10.767857\n",
       "dtype: float64"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 21#\n",
    "#Get the linear model coefficients from the `coef_` attribute and store in `coefs`,\n",
    "#get the matching feature names from the column names of the dataframe,\n",
    "#and display the results as a pandas Series with `coefs` as the values and `features` as the index,\n",
    "#sorting the values in descending order\n",
    "coefs = lr_grid_cv.best_estimator_.named_steps.linearregression.coef_\n",
    "features = X_train.columns[selected]\n",
    "pd.Series(coefs, index=features).sort_values(ascending=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These results suggest that vertical drop is your biggest positive feature. This makes intuitive sense and is consistent with what you saw during the EDA work. Also, you see the area covered by snow making equipment is a strong positive as well. People like guaranteed skiing! The skiable terrain area is negatively associated with ticket price! This seems odd. People will pay less for larger resorts? There could be all manner of reasons for this. It could be  an effect whereby larger resorts can host more visitors at any one time and so can charge less per ticket. As has been mentioned previously, the data are missing information about visitor numbers. Bear in mind,  the coefficient for skiable terrain is negative _for this model_. For example, if you kept the total number of chairs and fastQuads constant, but increased the skiable terrain extent, you might imagine the resort is worse off because the chairlift capacity is stretched thinner."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.10 Random Forest Model<a id='4.10_Random_Forest_Model'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A model that can work very well in a lot of cases is the random forest. For regression, this is provided by `sklearn`'s `RandomForestRegressor` class.\n",
    "\n",
    "Time to stop the bad practice of repeatedly checking performance on the test split. Instead, go straight from defining the pipeline to assessing performance using cross-validation. `cross_validate` will perform the fitting as part of the process. This uses the default settings for the random forest so you'll then proceed to investigate some different hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.10.1 Define the pipeline<a id='4.10.1_Define_the_pipeline'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 22#\n",
    "#Define a pipeline comprising the steps:\n",
    "#SimpleImputer() with a strategy of 'median'\n",
    "#StandardScaler(),\n",
    "#and then RandomForestRegressor() with a random state of 47\n",
    "RF_pipe = make_pipeline(\n",
    "   SimpleImputer(strategy='median'),\n",
    "    StandardScaler(),\n",
    "    RandomForestRegressor(random_state=47)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.10.2 Fit and assess performance using cross-validation<a id='4.10.2_Fit_and_assess_performance_using_cross-validation'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 23#\n",
    "#Call `cross_validate` to estimate the pipeline's performance.\n",
    "#Pass it the random forest pipe object, `X_train` and `y_train`,\n",
    "#and get it to use 5-fold cross-validation\n",
    "rf_default_cv_results = cross_validate(RF_pipe, X_train, y_train, cv=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.69249204, 0.78061953, 0.77546915, 0.62190924, 0.61742339])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_cv_scores = rf_default_cv_results['test_score']\n",
    "rf_cv_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6975826707112506, 0.07090742940774528)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(rf_cv_scores), np.std(rf_cv_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.10.3 Hyperparameter search using GridSearchCV<a id='4.10.3_Hyperparameter_search_using_GridSearchCV'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Random forest has a number of hyperparameters that can be explored, however here you'll limit yourselves to exploring some different values for the number of trees. You'll try it with and without feature scaling, and try both the mean and median as strategies for imputing missing values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'randomforestregressor__n_estimators': [10,\n",
       "  12,\n",
       "  16,\n",
       "  20,\n",
       "  26,\n",
       "  33,\n",
       "  42,\n",
       "  54,\n",
       "  69,\n",
       "  88,\n",
       "  112,\n",
       "  143,\n",
       "  183,\n",
       "  233,\n",
       "  297,\n",
       "  379,\n",
       "  483,\n",
       "  615,\n",
       "  784,\n",
       "  1000],\n",
       " 'standardscaler': [StandardScaler(), None],\n",
       " 'simpleimputer__strategy': ['mean', 'median']}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_est = [int(n) for n in np.logspace(start=1, stop=3, num=20)]\n",
    "grid_params = {\n",
    "        'randomforestregressor__n_estimators': n_est,\n",
    "        'standardscaler': [StandardScaler(), None],\n",
    "        'simpleimputer__strategy': ['mean', 'median']\n",
    "}\n",
    "grid_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 24#\n",
    "#Call `GridSearchCV` with the random forest pipeline, passing in the above `grid_params`\n",
    "#dict for parameters to evaluate, 5-fold cross-validation, and all available CPU cores (if desired)\n",
    "rf_grid_cv = GridSearchCV(RF_pipe, param_grid=grid_params, cv=5, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GridSearchCV(cv=5,\n",
       "             estimator=Pipeline(steps=[('simpleimputer',\n",
       "                                        SimpleImputer(strategy='median')),\n",
       "                                       ('standardscaler', StandardScaler()),\n",
       "                                       ('randomforestregressor',\n",
       "                                        RandomForestRegressor(random_state=47))]),\n",
       "             n_jobs=-1,\n",
       "             param_grid={'randomforestregressor__n_estimators': [10, 12, 16, 20,\n",
       "                                                                 26, 33, 42, 54,\n",
       "                                                                 69, 88, 112,\n",
       "                                                                 143, 183, 233,\n",
       "                                                                 297, 379, 483,\n",
       "                                                                 615, 784,\n",
       "                                                                 1000],\n",
       "                         'simpleimputer__strategy': ['mean', 'median'],\n",
       "                         'standardscaler': [StandardScaler(), None]})"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 25#\n",
    "#Now call the `GridSearchCV`'s `fit()` method with `X_train` and `y_train` as arguments\n",
    "#to actually start the grid search. This may take a minute or two.\n",
    "rf_grid_cv.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'randomforestregressor__n_estimators': 69,\n",
       " 'simpleimputer__strategy': 'median',\n",
       " 'standardscaler': None}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Code task 26#\n",
    "#Print the best params (`best_params_` attribute) from the grid search\n",
    "rf_grid_cv.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like imputing with the median helps, but scaling the features doesn't."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.6951357 , 0.79430697, 0.77170917, 0.62254707, 0.66499334])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_best_cv_results = cross_validate(rf_grid_cv.best_estimator_, X_train, y_train, cv=5)\n",
    "rf_best_scores = rf_best_cv_results['test_score']\n",
    "rf_best_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7097384501425082, 0.06451341966873386)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(rf_best_scores), np.std(rf_best_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've marginally improved upon the default CV results. Random forest has many more hyperparameters you could tune, but we won't dive into that here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Code task 27#\n",
    "#Plot a barplot of the random forest's feature importances,\n",
    "#assigning the `feature_importances_` attribute of \n",
    "#`rf_grid_cv.best_estimator_.named_steps.randomforestregressor` to the name `imps` to then\n",
    "#create a pandas Series object of the feature importances, with the index given by the\n",
    "#training data column names, sorting the values in descending order\n",
    "plt.subplots(figsize=(10, 5))\n",
    "imps = rf_grid_cv.best_estimator_.named_steps.randomforestregressor.feature_importances_\n",
    "rf_feat_imps = pd.Series(imps, index=X_train.columns).sort_values(ascending=False)\n",
    "rf_feat_imps.plot(kind='bar')\n",
    "plt.xlabel('features')\n",
    "plt.ylabel('importance')\n",
    "plt.title('Best random forest regressor feature importances');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encouragingly, the dominant top four features are in common with your linear model:\n",
    "* fastQuads\n",
    "* Runs\n",
    "* Snow Making_ac\n",
    "* vertical_drop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.11 Final Model Selection<a id='4.11_Final_Model_Selection'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to select your final model to use for further business modeling! It would be good to revisit the above model selection; there is undoubtedly more that could be done to explore possible hyperparameters.\n",
    "It would also be worthwhile to investigate removing the least useful features. Gathering or calculating, and storing, features adds business cost and dependencies, so if features genuinely are not needed they should be removed.\n",
    "Building a simpler model with fewer features can also have the advantage of being easier to sell (and/or explain) to stakeholders.\n",
    "Certainly there seem to be four strong features here and so a model using only those would probably work well.\n",
    "However, you want to explore some different scenarios where other features vary so keep the fuller \n",
    "model for now. \n",
    "The business is waiting for this model and you have something that you have confidence in to be much better than guessing with the average price.\n",
    "\n",
    "Or, rather, you have two \"somethings\". You built a best linear model and a best random forest model. You need to finally choose between them. You can calculate the mean absolute error using cross-validation. Although `cross-validate` defaults to the $R^2$ [metric for scoring](https://scikit-learn.org/stable/modules/model_evaluation.html#scoring) regression, you can specify the mean absolute error as an alternative via\n",
    "the `scoring` parameter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.11.1 Linear regression model performance<a id='4.11.1_Linear_regression_model_performance'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'neg_mean_absolute_error' uses the (negative of) the mean absolute error\n",
    "lr_neg_mae = cross_validate(lr_grid_cv.best_estimator_, X_train, y_train, \n",
    "                            scoring='neg_mean_absolute_error', cv=5, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10.499032338015294, 1.6220608976799664)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr_mae_mean = np.mean(-1 * lr_neg_mae['test_score'])\n",
    "lr_mae_std = np.std(-1 * lr_neg_mae['test_score'])\n",
    "lr_mae_mean, lr_mae_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.793465668669324"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_test, lr_grid_cv.best_estimator_.predict(X_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.11.2 Random forest regression model performance<a id='4.11.2_Random_forest_regression_model_performance'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf_neg_mae = cross_validate(rf_grid_cv.best_estimator_, X_train, y_train, \n",
    "                            scoring='neg_mean_absolute_error', cv=5, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9.644639167595688, 1.3528565172191818)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf_mae_mean = np.mean(-1 * rf_neg_mae['test_score'])\n",
    "rf_mae_std = np.std(-1 * rf_neg_mae['test_score'])\n",
    "rf_mae_mean, rf_mae_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.537730050637332"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(y_test, rf_grid_cv.best_estimator_.predict(X_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.11.3 Conclusion<a id='4.11.3_Conclusion'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random forest model has a lower cross-validation mean absolute error by almost \\\\$1. It also exhibits less variability. Verifying performance on the test set produces performance consistent with the cross-validation results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.12 Data quantity assessment<a id='4.12_Data_quantity_assessment'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you need to advise the business whether it needs to undertake further data collection. Would more data be useful? We're often led to believe more data is always good, but gathering data invariably has a cost associated with it. Assess this trade off by seeing how performance varies with differing data set sizes. The `learning_curve` function does this conveniently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "fractions = [.2, .25, .3, .35, .4, .45, .5, .6, .75, .8, 1.0]\n",
    "train_size, train_scores, test_scores = learning_curve(pipe, X_train, y_train, train_sizes=fractions)\n",
    "train_scores_mean = np.mean(train_scores, axis=1)\n",
    "train_scores_std = np.std(train_scores, axis=1)\n",
    "test_scores_mean = np.mean(test_scores, axis=1)\n",
    "test_scores_std = np.std(test_scores, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(figsize=(10, 5))\n",
    "plt.errorbar(train_size, test_scores_mean, yerr=test_scores_std)\n",
    "plt.xlabel('Training set size')\n",
    "plt.ylabel('CV scores')\n",
    "plt.title('Cross-validation score as training set size increases');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows that you seem to have plenty of data. There's an initial rapid improvement in model scores as one would expect, but it's essentially levelled off by around a sample size of 40-50."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.13 Save best model object from pipeline<a id='4.13_Save_best_model_object_from_pipeline'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code task 28#\n",
    "#This may not be \"production grade ML deployment\" practice, but adding some basic\n",
    "#information to your saved models can save your bacon in development.\n",
    "#Just what version model have you just loaded to reuse? What version of `sklearn`\n",
    "#created it? When did you make it?\n",
    "#Assign the pandas version number (`pd.__version__`) to the `pandas_version` attribute,\n",
    "#the numpy version (`np.__version__`) to the `numpy_version` attribute,\n",
    "#the sklearn version (`sklearn_version`) to the `sklearn_version` attribute,\n",
    "#and the current datetime (`datetime.datetime.now()`) to the `build_datetime` attribute\n",
    "#Let's call this model version '1.0'\n",
    "best_model = rf_grid_cv.best_estimator_\n",
    "best_model.version = '1.0'\n",
    "best_model.pandas_version = pd.__version__\n",
    "best_model.numpy_version = np.__version__\n",
    "best_model.sklearn_version = sklearn_version\n",
    "best_model.X_columns = [col for col in X_train.columns]\n",
    "best_model.build_datetime = datetime.datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing file.  \"../models\\ski_resort_pricing_model.pkl\"\n"
     ]
    }
   ],
   "source": [
    "# save the model\n",
    "\n",
    "modelpath = '../models'\n",
    "save_file(best_model, 'ski_resort_pricing_model.pkl', modelpath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.14 Summary<a id='4.14_Summary'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q: 1** Write a summary of the work in this notebook. Capture the fact that you gained a baseline idea of performance by simply taking the average price and how well that did. Then highlight that you built a linear model and the features that found. Comment on the estimate of its performance from cross-validation and whether its performance on the test split was consistent with this estimate. Also highlight that a random forest regressor was tried, what preprocessing steps were found to be best, and again what its estimated performance via cross-validation was and whether its performance on the test set was consistent with that. State which model you have decided to use going forwards and why. This summary should provide a quick overview for someone wanting to know quickly why the given model was chosen for the next part of the business problem to help guide important business decisions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A: 1** Your answer here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Intially performance evaluated done using mean prices, this helped in getting the baseline for comprison.later linear model and Random forest model were used to get near accuracy. with the prediction by only mean, avearge would be off by about $19.\n",
    "\n",
    "While building the linear model, missing values were imputed with median and mean values. If only linear model was used ticket price would be off by about $9. it was noticed thet, intial linear model was overfitting and needed to be adjusted by many features. With help of cross validation, the value k was set to eight features to focus on, vertical_drop, snow making_ac,total chairs,fastQuads, Runs,LongestRun_mi, trams and skiableTerrain_ac. These were fitting the intial assumptions from EDA.\n",
    "\n",
    "Later Random forest model was also used, with missing values imputed with median and mean values.This model revealed that the top four features to consider are fastQuads, Runs, Snow Making_ac, and vertical_drop.\n",
    "\n",
    "Finally, a comparison of the Linear Regression model performance was compared to the performance of the Random Forest Regression model. The result was the Random Forest model had a lower cross-validation mean absolute error by almost a $1. It also exhibited less variability and its performance on the test set produced a performance consistent with its cross-validation results (output 98 - 102). Therefore, the Random Forest Regression model is the model that is used moving forward for this project."
   ]
  }
 ],
 "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}