ensemble-lab-solutioncode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Random Forest\n",
    "\n",
    "---\n",
    "\n",
    "Sources:\n",
    "\n",
    "* Class material from General Assembly Data Science Immersive Course\n",
    "* Stackoverflow: https://stackoverflow.com\n",
    "* StatQuest with Josh Starmer: https://www.youtube.com/channel/UCtYLUTtgS3k1Fg4y5tAhLbw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a Random Forest?\n",
    "\n",
    "---\n",
    "\n",
    "Random Forests are some of the most widespread classifiers used. They are relatively simple to use because they require very few parameters to set and they perform well. As we have seen, Decision Trees are very powerful machine learning models.\n",
    "\n",
    "Decision Trees have some critical limitations. In particular, trees that are grown very deep tend to learn highly irregular patterns: they overfit their training sets. **In other words: they work great with the data used to create them, but they are not flexible when it comes to classifying new samples**. However Random forests are a further way of averaging multiple deep decision trees, trained on different parts of the same training set, with the goal of reducing the variance. This comes at the expense of a small increase in the bias and some loss of interpretability, but generally greatly boosts the performance of the final model. **Random Forests then combine the simplicity of decision trees with flexibility, resulting in a vast improvement in accuracy**.\n",
    "\n",
    "### Feature bagging\n",
    "\n",
    "Random forests differ from bagging decision trees in only one way: they use a modified tree learning algorithm that selects, at each candidate split in the learning process, a random subset of the features. This process is sometimes called feature bagging. \n",
    "\n",
    "The reason for doing this is due to correlation of trees in an ordinary bootstrap sample: if one or a few features are very strong predictors for the response variable (target output), these features will be selected in many of the bagging base trees, causing them to become correlated. By selecting a random subset of the features at each split, we avoid this correlation between base trees, strengthening the overall model.\n",
    "\n",
    "#### For a problem with p features, it is typical to use:\n",
    "- $p^{1/2}$ (rounded down) features in each split for a classification problem.\n",
    "- $p/3$ (rounded down) with a minimum node size of 5 as the default for a regression problem.\n",
    "\n",
    "\n",
    "#### Sklearn implementation\n",
    "- [Sklearn Random Forest Regressor](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html#sklearn.ensemble.RandomForestRegressor)\n",
    "- [Sklearn Random Forest Classifier](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html#sklearn.ensemble.RandomForestClassifier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest in 3 simple steps\n",
    "\n",
    "---\n",
    "\n",
    "1. **Step 1: We need a bootstrap dataset**\n",
    "\n",
    "To create a boostrapped dataset that is the same size as the original, we just randomly select samples from the original dataset. The important detail is that **we're allowed to pick** the same sample more than once.\n",
    "\n",
    "2. **Step 2: Create a Decision Trees**\n",
    "\n",
    "Now we build our model, but only using a **random** subset of variables/features/columns at each step. Once we've identified the feature that did the best job separating the samples, we build the tree as usual, but only considerand a random subset of variables at each step.\n",
    "\n",
    "3. **Step 3: go back to Step 1 and repeat**\n",
    "\n",
    "Making a new bootstrapped dataset and building a tree considering a subet of variables at each step. Ideally, doing this hundreds of times.\n",
    "\n",
    "Using a boostrapped sample and considering only a subset of variables at each step results in a wide variety of trees. This variety is what makes random forests more effective than individual decision trees."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How do we use Random Forests?\n",
    "---\n",
    "\n",
    "After running the data down all of the trees in the Random Forest, we see which option received more votes in our classification problem. For example, suppose we're trying to predict \"Dog\" or \"Cat\" out of several animal characteristics and we create a Random Forest with 500 iterations. If at the end, 470 models would have predicted \"Cat\" and only 30 models \"Dog\", our final category would be of course \"Cat\".\n",
    "\n",
    "Boostrapping the data and using the aggregate to make a decision is the definition of **BAGGING**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The out-of-bag sample\n",
    "---\n",
    "\n",
    "Each time we boostrap a sample, about 1/3 of it doesn't get into the boostrapped sample. And we could take those rows as our test group to evaluate our model. Measuring how accurate our Random Forest is by the proportion of out-of-bag samples that were correctly classified.\n",
    "\n",
    "The proportion of out-of-bag samples that were incorrectly classified is often called the 'out-of-bag error'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's work over one exmaple with the Boston housing dataset\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "plt.style.use('ggplot')\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.model_selection import train_test_split, cross_val_predict, cross_val_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the Boston housing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(506, 13)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_boston\n",
    "boston = load_boston()\n",
    "print((boston.data.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['data', 'target', 'feature_names', 'DESCR', 'filename']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The Boston housing dataset is divided into several files\n",
    "# We can check those files names by calling boston.keys()\n",
    "\n",
    "list(boston.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".. _boston_dataset:\n",
      "\n",
      "Boston house prices dataset\n",
      "---------------------------\n",
      "\n",
      "**Data Set Characteristics:**  \n",
      "\n",
      "    :Number of Instances: 506 \n",
      "\n",
      "    :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.\n",
      "\n",
      "    :Attribute Information (in order):\n",
      "        - CRIM     per capita crime rate by town\n",
      "        - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.\n",
      "        - INDUS    proportion of non-retail business acres per town\n",
      "        - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)\n",
      "        - NOX      nitric oxides concentration (parts per 10 million)\n",
      "        - RM       average number of rooms per dwelling\n",
      "        - AGE      proportion of owner-occupied units built prior to 1940\n",
      "        - DIS      weighted distances to five Boston employment centres\n",
      "        - RAD      index of accessibility to radial highways\n",
      "        - TAX      full-value property-tax rate per $10,000\n",
      "        - PTRATIO  pupil-teacher ratio by town\n",
      "        - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town\n",
      "        - LSTAT    % lower status of the population\n",
      "        - MEDV     Median value of owner-occupied homes in $1000's\n",
      "\n",
      "    :Missing Attribute Values: None\n",
      "\n",
      "    :Creator: Harrison, D. and Rubinfeld, D.L.\n",
      "\n",
      "This is a copy of UCI ML housing dataset.\n",
      "https://archive.ics.uci.edu/ml/machine-learning-databases/housing/\n",
      "\n",
      "\n",
      "This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.\n",
      "\n",
      "The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic\n",
      "prices and the demand for clean air', J. Environ. Economics & Management,\n",
      "vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics\n",
      "...', Wiley, 1980.   N.B. Various transformations are used in the table on\n",
      "pages 244-261 of the latter.\n",
      "\n",
      "The Boston house-price data has been used in many machine learning papers that address regression\n",
      "problems.   \n",
      "     \n",
      ".. topic:: References\n",
      "\n",
      "   - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.\n",
      "   - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# And we can check the description of the dataset calling boston.DESCR\n",
    "\n",
    "print(boston.DESCR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',\n",
       "       'TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Features/columns names\n",
    "\n",
    "boston.feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assigning data and target out of pre-built files\n",
    "\n",
    "X = pd.DataFrame(boston['data'], columns=boston.feature_names)\n",
    "y = pd.DataFrame(boston.target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>CRIM</th>\n",
       "      <th>ZN</th>\n",
       "      <th>INDUS</th>\n",
       "      <th>CHAS</th>\n",
       "      <th>NOX</th>\n",
       "      <th>RM</th>\n",
       "      <th>AGE</th>\n",
       "      <th>DIS</th>\n",
       "      <th>RAD</th>\n",
       "      <th>TAX</th>\n",
       "      <th>PTRATIO</th>\n",
       "      <th>B</th>\n",
       "      <th>LSTAT</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00632</td>\n",
       "      <td>18.0</td>\n",
       "      <td>2.31</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.538</td>\n",
       "      <td>6.575</td>\n",
       "      <td>65.2</td>\n",
       "      <td>4.0900</td>\n",
       "      <td>1.0</td>\n",
       "      <td>296.0</td>\n",
       "      <td>15.3</td>\n",
       "      <td>396.90</td>\n",
       "      <td>4.98</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.02731</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>6.421</td>\n",
       "      <td>78.9</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2.0</td>\n",
       "      <td>242.0</td>\n",
       "      <td>17.8</td>\n",
       "      <td>396.90</td>\n",
       "      <td>9.14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.02729</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>7.185</td>\n",
       "      <td>61.1</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2.0</td>\n",
       "      <td>242.0</td>\n",
       "      <td>17.8</td>\n",
       "      <td>392.83</td>\n",
       "      <td>4.03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.03237</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>6.998</td>\n",
       "      <td>45.8</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3.0</td>\n",
       "      <td>222.0</td>\n",
       "      <td>18.7</td>\n",
       "      <td>394.63</td>\n",
       "      <td>2.94</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.06905</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>7.147</td>\n",
       "      <td>54.2</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3.0</td>\n",
       "      <td>222.0</td>\n",
       "      <td>18.7</td>\n",
       "      <td>396.90</td>\n",
       "      <td>5.33</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      CRIM    ZN  INDUS  CHAS    NOX     RM   AGE     DIS  RAD    TAX  \\\n",
       "0  0.00632  18.0   2.31   0.0  0.538  6.575  65.2  4.0900  1.0  296.0   \n",
       "1  0.02731   0.0   7.07   0.0  0.469  6.421  78.9  4.9671  2.0  242.0   \n",
       "2  0.02729   0.0   7.07   0.0  0.469  7.185  61.1  4.9671  2.0  242.0   \n",
       "3  0.03237   0.0   2.18   0.0  0.458  6.998  45.8  6.0622  3.0  222.0   \n",
       "4  0.06905   0.0   2.18   0.0  0.458  7.147  54.2  6.0622  3.0  222.0   \n",
       "\n",
       "   PTRATIO       B  LSTAT  \n",
       "0     15.3  396.90   4.98  \n",
       "1     17.8  396.90   9.14  \n",
       "2     17.8  392.83   4.03  \n",
       "3     18.7  394.63   2.94  \n",
       "4     18.7  396.90   5.33  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting data into train and test sets and rescaling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "scaler = StandardScaler()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_train = pd.DataFrame(X_train, columns=boston.feature_names)\n",
    "\n",
    "X_test = scaler.transform(X_test)\n",
    "X_test = pd.DataFrame(X_test, columns=boston.feature_names)\n",
    "\n",
    "y_train = scaler.fit_transform(y_train)\n",
    "y_train.shape = (len(y_train),)\n",
    "\n",
    "y_test = scaler.transform(y_test)\n",
    "y_test.shape = (len(y_test),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((404,), (102,))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape, y_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fitting the data using a decision tree regressor on the training data and obtaining mean squared and r2 error for the test set for a maximal tree depth of three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training error: \n",
      "MSE:  0.18304363952308936\n",
      "R2:  0.8169563604769107\n",
      "Test error: \n",
      "MSE:  0.1552980824710956\n",
      "R2:  0.816029223482161\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "\n",
    "model = DecisionTreeRegressor(max_depth=3, random_state=1)\n",
    "\n",
    "model.fit(X_train, y_train)\n",
    "predictions = model.predict(X_test)\n",
    "\n",
    "print('Training error: ')\n",
    "print('MSE: ', mean_squared_error(y_train, model.predict(X_train)))\n",
    "print('R2: ', r2_score(y_train, model.predict(X_train)))\n",
    "\n",
    "print('Test error: ')\n",
    "print('MSE: ', mean_squared_error(y_test, predictions))\n",
    "print('R2: ', r2_score(y_test, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualising the resulting decision tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from os import system\n",
    "from sklearn.tree import export_graphviz\n",
    "\n",
    "\n",
    "def build_tree_image(model, filename='tree.png'):\n",
    "    dotfile = open(\"tree.dot\", 'w')\n",
    "    export_graphviz(model, out_file=dotfile, feature_names=X.columns, filled=True,\n",
    "                    rounded=True, special_characters=True)\n",
    "    dotfile.close()\n",
    "    # comment out this line if you don't have GraphViz yet\n",
    "    system(\"dot -Tpng tree.dot -o {0}\".format(filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "build_tree_image(model, 'tree.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='./tree.png' width = 80%>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performing Grid Search varying the maximal tree depth, the maximal number of leaf nodes and the minimal number of samples in the leafs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import cross_val_score, cross_val_predict\n",
    "from sklearn.metrics import r2_score, mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'criterion': 'mse',\n",
       " 'max_depth': 3,\n",
       " 'max_features': None,\n",
       " 'max_leaf_nodes': None,\n",
       " 'min_impurity_decrease': 0.0,\n",
       " 'min_impurity_split': None,\n",
       " 'min_samples_leaf': 1,\n",
       " 'min_samples_split': 2,\n",
       " 'min_weight_fraction_leaf': 0.0,\n",
       " 'presort': False,\n",
       " 'random_state': 1,\n",
       " 'splitter': 'best'}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_params()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "kfolds = 5\n",
    "model = DecisionTreeRegressor(random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeRegressor(criterion='mse', max_depth=3, max_features=5,\n",
      "           max_leaf_nodes=5, min_impurity_decrease=0.0,\n",
      "           min_impurity_split=None, min_samples_leaf=5,\n",
      "           min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
      "           presort=False, random_state=1, splitter='best')\n",
      "R2 training:  0.6884819705474974\n",
      "R2 test:  0.6483468129011942\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/gonzaloferreiro/anaconda3/lib/python3.6/site-packages/sklearn/model_selection/_search.py:841: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "# Grid Search\n",
    "params = {'max_depth': [1, 3, 5],\n",
    "          'max_features':[1,3,5],\n",
    "          'max_leaf_nodes': [2,3,5],\n",
    "          'min_samples_leaf': [2,3,5],\n",
    "          'min_samples_split':[2,2,3]}\n",
    "\n",
    "gs = GridSearchCV(model, param_grid=params, cv=kfolds)\n",
    "gs.fit(X_train, y_train)\n",
    "\n",
    "model = gs.best_estimator_\n",
    "print(gs.best_estimator_)\n",
    "print('R2 training: ', gs.score(X_train, y_train))\n",
    "print('R2 test: ', gs.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=3, max_features=5,\n",
       "           max_leaf_nodes=5, min_impurity_decrease=0.0,\n",
       "           min_impurity_split=None, min_samples_leaf=5,\n",
       "           min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "           presort=False, random_state=1, splitter='best')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the best model\n",
    "\n",
    "gs.best_estimator_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'max_depth': 3,\n",
       " 'max_features': 5,\n",
       " 'max_leaf_nodes': 5,\n",
       " 'min_samples_leaf': 5,\n",
       " 'min_samples_split': 2}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the best params. We can see it could be easily improved\n",
    "\n",
    "gs.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now we'll use ensemble methods to fit decision trees. For BaggingRegressor and RandomForestRegressor, we'll vary the number of estimators (`n_estimators`), using cross_val_score with five-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import BaggingRegressor, RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_cross_val(model, X, y):\n",
    "    scores = cross_val_score(model, X, y, cv=5, n_jobs=1)\n",
    "    return scores.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DecisionTreeRegressor(criterion='mse', max_depth=3, max_features=5,\n",
      "           max_leaf_nodes=5, min_impurity_decrease=0.0,\n",
      "           min_impurity_split=None, min_samples_leaf=5,\n",
      "           min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
      "           presort=False, random_state=1, splitter='best')\n",
      "R2 training:  0.8126014148247207\n",
      "R2 test:  0.7383655717347707\n"
     ]
    }
   ],
   "source": [
    "# First we're gonna run some 'heavy' Grid Search to find some neat parameters\n",
    "# for our Random Forest, and then we're gonna run our Bagging-Random Forest comparison\n",
    "\n",
    "test_model = RandomForestRegressor(n_estimators = 500)\n",
    "\n",
    "grid = {'max_features': [0.4,0.6,0.8,1],\n",
    "       'max_depth': [2,5,10,15],\n",
    "       'max_leaf': [2,5,10,20],\n",
    "       'min_samples_leaf': [2,3,5],\n",
    "       'min_samples_split':[2,3,5]}\n",
    "\n",
    "test_gs = GridSearchCV(test_model, param_grid=params, cv=3)\n",
    "\n",
    "test_gs.fit(X_train, y_train)\n",
    "\n",
    "model = gs.best_estimator_\n",
    "print(gs.best_estimator_)\n",
    "print('R2 training: ', test_gs.score(X_train, y_train))\n",
    "print('R2 test: ', test_gs.score(X_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As we saw before, matching the right params, we can achieve better scores\n",
    "# than the ones we obtained just with a Decision Tree\n",
    "# Now let's run our comparison Bagging vs Random Forest\n",
    "\n",
    "score_list = []\n",
    "\n",
    "for n in np.logspace(0, 2, 10, dtype=int):\n",
    "    \n",
    "    models = [('Bagging', BaggingRegressor(random_state=1, n_estimators=n)),\n",
    "              ('RandomForest', RandomForestRegressor(random_state=1, n_estimators=n))]\n",
    "    \n",
    "    for model in models:\n",
    "        \n",
    "        model[1].fit(X_train, y_train)\n",
    "        train_score_cv = do_cross_val(model[1], X_train, y_train)\n",
    "        train_predictions = model[1].predict(X_train)\n",
    "        test_predictions = model[1].predict(X_test)\n",
    "        train_score = mean_squared_error(y_train, train_predictions)\n",
    "        test_score = mean_squared_error(y_test, test_predictions)\n",
    "        score_list.append([model[0], n, train_score_cv, train_score, test_score])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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>model</th>\n",
       "      <th>estimators</th>\n",
       "      <th>train_mse_cv</th>\n",
       "      <th>train_mse</th>\n",
       "      <th>test_mse</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bagging</td>\n",
       "      <td>1</td>\n",
       "      <td>0.721215</td>\n",
       "      <td>0.116916</td>\n",
       "      <td>0.299361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bagging</td>\n",
       "      <td>1</td>\n",
       "      <td>0.721215</td>\n",
       "      <td>0.116916</td>\n",
       "      <td>0.299361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RandomForest</td>\n",
       "      <td>1</td>\n",
       "      <td>0.728178</td>\n",
       "      <td>0.108303</td>\n",
       "      <td>0.296353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>RandomForest</td>\n",
       "      <td>1</td>\n",
       "      <td>0.728178</td>\n",
       "      <td>0.108303</td>\n",
       "      <td>0.296353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4</td>\n",
       "      <td>0.815946</td>\n",
       "      <td>0.031734</td>\n",
       "      <td>0.134907</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          model  estimators  train_mse_cv  train_mse  test_mse\n",
       "0       Bagging           1      0.721215   0.116916  0.299361\n",
       "2       Bagging           1      0.721215   0.116916  0.299361\n",
       "1  RandomForest           1      0.728178   0.108303  0.296353\n",
       "3  RandomForest           1      0.728178   0.108303  0.296353\n",
       "7  RandomForest           4      0.815946   0.031734  0.134907"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# As we'll see in the following DataFrame, without tunning the params, we don't\n",
    "# get a score not even simmilar to the ones we got before\n",
    "\n",
    "df_scores = pd.DataFrame(score_list, columns=[\n",
    "                         'model', 'estimators', 'train_mse_cv', 'train_mse', 'test_mse'])\n",
    "\n",
    "df_scores.sort_values(by='test_mse', ascending=False).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 271,
       "width": 396
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Finally, let's plot the scores for each model in a chart\n",
    "\n",
    "groups = df_scores.groupby('model')\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for group in groups.groups.keys():\n",
    "    \n",
    "    groups.get_group(group).plot(x='estimators', y='train_mse_cv', ax=ax,\n",
    "                                 label='training cv '+group, lw=3, fontsize=14, logx=True)\n",
    "    groups.get_group(group).plot(x='estimators', y='train_mse', ax=ax,\n",
    "                                 label='training '+group, lw=3, ls='--', fontsize=14, logx=True)\n",
    "    groups.get_group(group).plot(x='estimators', y='test_mse', ax=ax,\n",
    "                                 label='test ' + group, lw=3, ls='-.', fontsize=14, logx=True)\n",
    "\n",
    "plt.ylabel('MSE')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}