"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"\n",
""
],
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# code for loading the format for the notebook\n",
"import os\n",
"\n",
"# path : store the current path to convert back to it later\n",
"path = os.getcwd()\n",
"os.chdir(os.path.join('..', 'notebook_format'))\n",
"from formats import load_style\n",
"load_style(css_style = 'custom2.css', plot_style = False)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ethen 2018-09-15 14:53:27 \n",
"\n",
"CPython 3.6.4\n",
"IPython 6.4.0\n",
"\n",
"numpy 1.14.1\n",
"pandas 0.23.0\n",
"matplotlib 2.2.2\n",
"sklearn 0.19.1\n"
]
}
],
"source": [
"os.chdir(path)\n",
"\n",
"# 1. magic for inline plot\n",
"# 2. magic to print version\n",
"# 3. magic so that the notebook will reload external python modules\n",
"# 4. magic to enable retina (high resolution) plots\n",
"# https://gist.github.com/minrk/3301035\n",
"%matplotlib inline\n",
"%load_ext watermark\n",
"%load_ext autoreload\n",
"%autoreload 2\n",
"%config InlineBackend.figure_format = 'retina'\n",
"\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.metrics import mean_squared_error\n",
"from sklearn.model_selection import train_test_split, GridSearchCV\n",
"from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier\n",
"from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor\n",
"\n",
"%watermark -a 'Ethen' -d -t -v -p numpy,pandas,matplotlib,sklearn"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Ensemble Trees"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Some of the materials builds on top of the [previous documentation/implementation on decision trees](http://nbviewer.jupyter.org/github/ethen8181/machine-learning/blob/master/trees/decision_tree.ipynb), thus it might be best to walk through that one first.\n",
"\n",
"Ensembling is a very popular method for improving the predictive performance of machine learning models. Let's pretend that instead of building a single model to solve a binary classification problem, you created **five independent models**, and each model was correct about 70% of the time. If you combined these models into an \"ensemble\" and used their majority vote as a prediction, how often would the ensemble be correct?"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.713\n",
"0.665\n",
"0.717\n",
"0.712\n",
"0.687\n"
]
}
],
"source": [
"# generate 1000 random numbers (between 0 and 1) for each model, \n",
"# representing 1000 observations\n",
"np.random.seed(1234)\n",
"mod1 = np.random.rand(1000)\n",
"mod2 = np.random.rand(1000)\n",
"mod3 = np.random.rand(1000)\n",
"mod4 = np.random.rand(1000)\n",
"mod5 = np.random.rand(1000)\n",
"\n",
"# each model independently predicts 1 (the \"correct response\") \n",
"# if random number was at least 0.3\n",
"preds1 = np.where(mod1 > 0.3, 1, 0)\n",
"preds2 = np.where(mod2 > 0.3, 1, 0)\n",
"preds3 = np.where(mod3 > 0.3, 1, 0)\n",
"preds4 = np.where(mod4 > 0.3, 1, 0)\n",
"preds5 = np.where(mod5 > 0.3, 1, 0)\n",
"\n",
"# how accurate was each individual model?\n",
"print(preds1.mean())\n",
"print(preds2.mean())\n",
"print(preds3.mean())\n",
"print(preds4.mean())\n",
"print(preds5.mean()) "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.841\n"
]
}
],
"source": [
"# average the predictions, and then round to 0 or 1\n",
"# you can also do a weighted average, as long as the weight adds up to 1 \n",
"ensemble_preds = np.round((preds1 + preds2 + preds3 + preds4 + preds5) / 5).astype(int)\n",
"\n",
"# how accurate was the ensemble?\n",
"print(ensemble_preds.mean())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Bagging"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The primary weakness of decision trees is that they don't tend to have the best predictive accuracy and the result can be very unstable. This is partially due to the fact that we were using greedy algorithm to choose the rule/feature to split the tree. Hence a small variations in the data might result in a completely different tree being generated. Fortunately, this problem can be mitigated by training an ensemble of decision trees and use these trees to form a \"forest\".\n",
"\n",
"This first idea we'll introduce is **Bagging**. **Bagging**, short for **bootstrap aggregation** is a general procedure for reducing the variance of a machine learning algorithm, although it can used with any type of method, it is most commonly applied to tree-based models. The way it works is: \n",
"\n",
"Given a training set $X = x_1, ..., x_n$ with responses $Y = y_1, ..., y_n$, bagging repeatedly ($B$ times) selects a random sample with replacement (a.k.a bootstrap sample) of the training set and fits trees to these newly generated samples:\n",
"\n",
"For $b = 1, ..., B$:\n",
" \n",
"1. Sample, with replacement, $n$ training examples from $X$, $Y$; call these $X_b$, $Y_b$. Note that the bootstrap sample should be the same size as the original training set\n",
"2. Train a tree, $f_b$, on $X_b$, $Y_b$. For these individual tree, we should allow them to grow deeper (increase the max_depth parameter) so that they have low bias/high variance\n",
"\n",
"After training, predictions for unseen samples $x'$ can be made by averaging the predictions from all the individual regression trees on $x'$:\n",
"\n",
"\n",
"$$\n",
"\\begin{align}\n",
"f' = \\frac {1}{B}\\sum _{b=1}^{B}{f}_{b}(x')\n",
"\\end{align}\n",
"$$\n",
"\n",
"Or by taking the majority vote in the case of classification trees. If you are wondering why bootstrapping is a good idea, the rationale is:\n",
"\n",
"We wish to ask a question of a population but we can't. Instead, we take a sample and ask the question to it instead. Now, how confident we should be that the sample answer is close to the population answer obviously depends on the structure of population. One way we might learn about this is to take samples from the population again and again, ask them the question, and see how variable the sample answers tended to be. But often times this isn't possible (we wouldn't relaunch the Titanic and crash it into another iceberg), thus we can use the information in the sample we actually have to learn about it.\n",
"\n",
"This is a reasonable thing to do because not only is the sample you have the best and the only information you have about what the population actually looks like, but also because most samples will, if they're randomly chosen, look quite like the population they came from. In the end, sampling with replacement is just a convenient way to treat the sample like it's a population and to sample from it in a way that reflects its shape."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Random Forest\n",
"\n",
"Random Forest is very similar to bagged trees. Exactly like bagging, we create an ensemble of decision trees using bootstrapped samples of the training set. When building each tree, however, each time a split is considered, a random sample of $m$ features is chosen as split candidates from the full set of $p$ features. The split is only allowed to use one of those $m$ features to generate the best rule/feature to split on. \n",
"\n",
"- For **classification**, $m$ is typically chosen to be, $\\sqrt{p}$, the square root of $p$.\n",
"- For **regression**, $m$ is typically chosen to be somewhere between $p/3$ and $p$.\n",
"\n",
"The whole point of choosing a new random sample of features for every single tree at every single split is to correct for decision trees' habit of overfitting to their training set. Suppose there is one very strong feature in the data set, when using bagged trees, most of the trees will use that feature as the top split, resulting in an ensemble of similar trees that are highly correlated. By randomly leaving out candidate features from each split, Random Forest \"decorrelates\" the trees, such that the averaging process can further reduce the variance of the resulting model."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Implementation"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here, we will use the [Wine Quality Data Set](https://archive.ics.uci.edu/ml/datasets/Wine+Quality) to test our implementation. This [link](https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv) should download the .csv file. The task is to predict the quality of the wine (a scale of 1 ~ 10) given some of its features. We'll build three types of regression model, decision tree, bagged decision tree and random forest on the training set and compare the result on the test set."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dimension of the dataset: (4898, 12)\n"
]
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
fixed acidity
\n",
"
volatile acidity
\n",
"
citric acid
\n",
"
residual sugar
\n",
"
chlorides
\n",
"
free sulfur dioxide
\n",
"
total sulfur dioxide
\n",
"
density
\n",
"
pH
\n",
"
sulphates
\n",
"
alcohol
\n",
"
quality
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
7.0
\n",
"
0.27
\n",
"
0.36
\n",
"
20.7
\n",
"
0.045
\n",
"
45.0
\n",
"
170.0
\n",
"
1.0010
\n",
"
3.00
\n",
"
0.45
\n",
"
8.8
\n",
"
6
\n",
"
\n",
"
\n",
"
1
\n",
"
6.3
\n",
"
0.30
\n",
"
0.34
\n",
"
1.6
\n",
"
0.049
\n",
"
14.0
\n",
"
132.0
\n",
"
0.9940
\n",
"
3.30
\n",
"
0.49
\n",
"
9.5
\n",
"
6
\n",
"
\n",
"
\n",
"
2
\n",
"
8.1
\n",
"
0.28
\n",
"
0.40
\n",
"
6.9
\n",
"
0.050
\n",
"
30.0
\n",
"
97.0
\n",
"
0.9951
\n",
"
3.26
\n",
"
0.44
\n",
"
10.1
\n",
"
6
\n",
"
\n",
"
\n",
"
3
\n",
"
7.2
\n",
"
0.23
\n",
"
0.32
\n",
"
8.5
\n",
"
0.058
\n",
"
47.0
\n",
"
186.0
\n",
"
0.9956
\n",
"
3.19
\n",
"
0.40
\n",
"
9.9
\n",
"
6
\n",
"
\n",
"
\n",
"
4
\n",
"
7.2
\n",
"
0.23
\n",
"
0.32
\n",
"
8.5
\n",
"
0.058
\n",
"
47.0
\n",
"
186.0
\n",
"
0.9956
\n",
"
3.19
\n",
"
0.40
\n",
"
9.9
\n",
"
6
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" fixed acidity volatile acidity citric acid residual sugar chlorides \\\n",
"0 7.0 0.27 0.36 20.7 0.045 \n",
"1 6.3 0.30 0.34 1.6 0.049 \n",
"2 8.1 0.28 0.40 6.9 0.050 \n",
"3 7.2 0.23 0.32 8.5 0.058 \n",
"4 7.2 0.23 0.32 8.5 0.058 \n",
"\n",
" free sulfur dioxide total sulfur dioxide density pH sulphates \\\n",
"0 45.0 170.0 1.0010 3.00 0.45 \n",
"1 14.0 132.0 0.9940 3.30 0.49 \n",
"2 30.0 97.0 0.9951 3.26 0.44 \n",
"3 47.0 186.0 0.9956 3.19 0.40 \n",
"4 47.0 186.0 0.9956 3.19 0.40 \n",
"\n",
" alcohol quality \n",
"0 8.8 6 \n",
"1 9.5 6 \n",
"2 10.1 6 \n",
"3 9.9 6 \n",
"4 9.9 6 "
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"wine = pd.read_csv('winequality-white.csv', sep = ';')\n",
"\n",
"# train/test split the features and response column\n",
"y = wine['quality'].values\n",
"X = wine.drop('quality', axis = 1).values\n",
"X_train, X_test, y_train, y_test = train_test_split(\n",
" X, y, test_size = 0.2, random_state = 1234)\n",
"\n",
"print('dimension of the dataset: ', wine.shape)\n",
"wine.head()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original: [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]\n",
"bootstrap: [ 6 12 13 9 10 12 6 16 1 17 2 13 8 14 7 19 6 19 12 11]\n"
]
}
],
"source": [
"# this cell simply demonstrates how to create boostrap samples\n",
"# we create an array of numbers from 1 to 20\n",
"# create the boostrap sample on top of that\n",
"np.random.seed(1)\n",
"nums = np.arange(1, 21)\n",
"print('original:', nums)\n",
"print('bootstrap: ', np.random.choice(nums, size = 20, replace = True))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"class RandomForest:\n",
" \"\"\"\n",
" Regression random forest using scikit learn's \n",
" decision tree as the base tree\n",
" \n",
" Parameters\n",
" ----------\n",
" n_estimators: int \n",
" the number of trees that you're going built\n",
" on the bagged sample (you can even shutoff\n",
" the bagging procedure for some packages)\n",
" \n",
" max_features: int \n",
" the number of features that you allow\n",
" when deciding which feature to split on \n",
" \n",
" all the other parameters for a decision tree like\n",
" max_depth or min_sample_split also applies to Random Forest, \n",
" it is just not used here as that is more\n",
" related to a single decision tree\n",
" \"\"\" \n",
"\n",
" def __init__(self, n_estimators, max_features):\n",
" self.n_estimators = n_estimators\n",
" self.max_features = max_features\n",
" \n",
" def fit(self, X, y):\n",
" # for each base-tree models:\n",
" # 1. draw bootstrap samples from the original data\n",
" # 2. train the tree model on that bootstrap sample, and\n",
" # during training, randomly select a number of features to \n",
" # split on each node\n",
" self.estimators = []\n",
" for i in range(self.n_estimators):\n",
" boot = np.random.choice(y.shape[0], size = y.shape[0], replace = True)\n",
" X_boot, y_boot = X[boot], y[boot]\n",
" tree = DecisionTreeRegressor(max_features = self.max_features)\n",
" tree.fit(X_boot, y_boot)\n",
" self.estimators.append(tree)\n",
" \n",
" return self\n",
"\n",
" def predict(self, X):\n",
" # for the prediction, we average the\n",
" # predictions made by each of the bagged tree\n",
" pred = np.empty((X.shape[0], self.n_estimators))\n",
" for i, tree in enumerate(self.estimators):\n",
" pred[:, i] = tree.predict(X)\n",
" \n",
" pred = np.mean(pred, axis = 1)\n",
" return pred"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"tree: 0.7908163265306123\n",
"bagged tree: 0.40405469387755105\n",
"random forest: 0.39058653061224485\n",
"random forest library: 0.3984877551020408\n"
]
}
],
"source": [
"# compare the results between a single decision tree,\n",
"# bagging and random forest, the lower the mean square\n",
"# error, the better\n",
"tree = DecisionTreeRegressor()\n",
"tree.fit(X_train, y_train)\n",
"tree_y_pred = tree.predict(X_test)\n",
"print('tree: ', mean_squared_error(y_test, tree_y_pred))\n",
"\n",
"# bagged decision tree\n",
"# max_feature = None simply uses all features\n",
"bag = RandomForest(n_estimators = 50, max_features = None)\n",
"bag.fit(X_train, y_train)\n",
"bag_y_pred = bag.predict(X_test)\n",
"print('bagged tree: ', mean_squared_error(y_test, bag_y_pred))\n",
"\n",
"# random forest using a random one third of the features at every split\n",
"rf = RandomForest(n_estimators = 50, max_features = 1 / 3)\n",
"rf.fit(X_train, y_train)\n",
"rf_y_pred = rf.predict(X_test)\n",
"print('random forest: ', mean_squared_error(y_test, rf_y_pred))\n",
"\n",
"# use library to confirm results are comparable\n",
"rf_reg = RandomForestRegressor(n_estimators = 50, max_features = 1 / 3)\n",
"rf_reg.fit(X_train, y_train)\n",
"rf_reg_y_pred = rf_reg.predict(X_test)\n",
"print('random forest library: ', mean_squared_error(y_test, rf_reg_y_pred))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Feature Importance"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When using Bagging with decision tree or using Random Forest, we can increase the predictive accuracy of individual tree. These methods, however, do decrease model interpretability, because it is no longer possible to visualize all the trees that are built to form the \"forest\". Fortunately, we can still obtain an overall summary of feature importance from these models. The way feature importance works is as follows (there are many ways to do it, this is the implementation that scikit-learn uses):\n",
"\n",
"We first compute the feature importance values of a single tree:\n",
"\n",
"- We can initialize an array `feature_importances` of all zeros with size `n_features`\n",
"- We start building the tree and for each internal node that splits on feature $i$ we compute the information gain (error reduction) of that node multiplied by the proportion of samples that were routed to the node and add this quantity to `feature_importances[i]`\n",
"\n",
"The information gain (error reduction) depends on the impurity criterion that you use (e.g. Gini, Entropy for classification, MSE for regression). Its the impurity of the set of examples that gets routed to the internal node minus the sum of the impurities of the two partitions created by the split.\n",
"\n",
"Now, recall that these Ensemble Tree models simply consists of a bunch of individual trees, hence after computing the `feature_importance` values across all individual trees, we sum them up and take the average across all of them (normalize the values to sum up to 1 if necessary). \n",
"\n",
"Building on top of the [previous documentation/implementation on decision trees](http://nbviewer.jupyter.org/github/ethen8181/machine-learning/blob/master/trees/decision_tree.ipynb), we add the code to compute the feature importance. The code is not shown here, but can be obtained [here](https://github.com/ethen8181/machine-learning/blob/master/trees/tree.py) for those that are interested in the implementation."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 0. 0.07060267 0.92939733]\n",
"[0. 0. 0.07060267 0.92939733]\n"
]
}
],
"source": [
"from tree import Tree\n",
"\n",
"\n",
"# load a sample dataset\n",
"iris = load_iris()\n",
"iris_X = iris.data\n",
"iris_y = iris.target\n",
"\n",
"# train model and print the feature importance\n",
"tree = Tree()\n",
"tree.fit(iris_X, iris_y)\n",
"print(tree.feature_importance)\n",
"\n",
"# use library to confirm result\n",
"# note that the result might not always be the same\n",
"# because of decision tree's high variability\n",
"clf = DecisionTreeClassifier(criterion = 'entropy', min_samples_split = 10, max_depth = 3)\n",
"clf.fit(iris_X, iris_y)\n",
"print(clf.feature_importances_)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For ensemble tree, we simply sum all the feauture importance up and take the average (normalize it to sum up to 1 if necessary). Thus, we will not go through the process of building that from scratch, we'll simply visualize the feature importance of the regression Random Forest that we've previously trained on the wine dataset."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"def vis_importance(estimator, feature_names, threshold = 0.05):\n",
" \"\"\"\n",
" Visualize the relative importance of predictors.\n",
"\n",
" Parameters\n",
" ----------\n",
" estimator : sklearn-like ensemble tree model\n",
" A tree estimator that contains the attribute\n",
" ``feature_importances_``.\n",
"\n",
" feature_names : str 1d array or list[str]\n",
" Feature names that corresponds to the\n",
" feature importance.\n",
"\n",
" threshold : float, default 0.05\n",
" Features that have importance scores lower than this\n",
" threshold will not be presented in the plot, this assumes\n",
" the feature importance sum up to 1.\n",
" \"\"\"\n",
" if not hasattr(estimator, 'feature_importances_'):\n",
" msg = '{} does not have the feature_importances_ attribute'\n",
" raise ValueError(msg.format(estimator.__class__.__name__))\n",
"\n",
" imp = estimator.feature_importances_\n",
" feature_names = np.asarray(feature_names)\n",
" mask = imp > threshold\n",
" importances = imp[mask]\n",
" idx = np.argsort(importances)\n",
" scores = importances[idx]\n",
" names = feature_names[mask]\n",
" names = names[idx]\n",
"\n",
" y_pos = np.arange(1, len(scores) + 1)\n",
" if hasattr(estimator, 'estimators_'):\n",
" # apart from the mean feature importance, for scikit-learn we can access\n",
" # each individual tree's feature importance and compute the standard deviation\n",
" tree_importances = np.asarray([tree.feature_importances_\n",
" for tree in estimator.estimators_])\n",
" importances_std = np.std(tree_importances[:, mask], axis = 0)\n",
" scores_std = importances_std[idx]\n",
" plt.barh(y_pos, scores, align = 'center', xerr = scores_std)\n",
" else:\n",
" plt.barh(y_pos, scores, align = 'center')\n",
"\n",
" plt.yticks(y_pos, names)\n",
" plt.xlabel('Importance')\n",
" plt.title('Feature Importance Plot')"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"image/png": {
"height": 392,
"width": 582
}
},
"output_type": "display_data"
}
],
"source": [
"# change default figure and font size\n",
"plt.rcParams['figure.figsize'] = 8, 6 \n",
"plt.rcParams['font.size'] = 12\n",
"\n",
"\n",
"# visualize the feature importance of every variable\n",
"vis_importance(rf_reg, wine.columns[:-1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Caveat:**\n",
"\n",
"One thing to keep in mind when using the impurity based feature importance ranking is that when the dataset has two (or more) correlated features, then from the model's point of view, any of these correlated features can be used as the predictor, with no preference of one over the others. But once one of them is used, the importance of others is significantly reduced since the impurity they can effectively remove has already been removed by the first feature. As a consequence, they will have a lower reported importance. This is not an issue when we want to use feature selection to reduce overfitting, since it makes sense to remove features that are mostly duplicated by other features. But when we're interpreting the data, it can lead to incorrect conclusions that one of the variables is a strong predictor while the others in the same group are unimportant, while actually they are very close in terms of their relationship with the response variable.\n",
"\n",
"The effect of this phenomenon for Random Forest is somewhat reduced thanks to random selection of features at each node creation, but in general the effect is not removed completely. In the following example, we have three correlated variables $X_0$, $X_1$, $X_2$, and no noise in the data, with the output variable being the sum of the three features:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Scores for X0, X1, X2: [0.272 0.548 0.179]\n"
]
}
],
"source": [
"size = 10000\n",
"np.random.seed(10)\n",
"X_seed = np.random.normal(0, 1, size)\n",
"X0 = X_seed + np.random.normal(0, 0.1, size)\n",
"X1 = X_seed + np.random.normal(0, 0.1, size)\n",
"X2 = X_seed + np.random.normal(0, 0.1, size)\n",
"X_012 = np.array([ X0, X1, X2 ]).T\n",
"Y = X0 + X1 + X2\n",
"\n",
"rf = RandomForestRegressor(n_estimators = 20, max_features = 2)\n",
"rf.fit(X_012, Y)\n",
"print('Scores for X0, X1, X2:', np.round(rf.feature_importances_, 3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When we compute the feature importances, we see that some of the features have higher importance than the others, while their “true” importance should be very similar. One thing to point out though is that the difficulty of interpreting the importance/ranking of correlated variables is not Random Forest specific, but applies to most model based feature selection methods. This is why it often best practice to remove correlated features prior to training the model.\n",
"\n",
"**Advantages of Random Forests:**\n",
"\n",
"- Require very little feature engineering (e.g. standardization)\n",
"- Easy to use, as it rarely requires parameter tuning to achieve compelling and robust performance\n",
"- Provides a more reliable estimate of feature importance compare to other black-box methods (e.g. deep learning, support vector machine)\n",
"- Performance and computation wise, it is very competitive. Although you can typically find a model that beats Random Forest for any given dataset (typically a deep learning or gradient boosting algorithm), it’s never by much, and it usually takes much longer to train and tune those model"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Extra Trees"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What distinguishes Extra Trees from Random Forest is:\n",
"\n",
"- We use the entire training set instead of a bootstrap sample of the training set (but can also be trained on a bootstrapped sample as well if we wish)\n",
"- Just like Random Forest, when choosing rules/features at a split, a random subset of candidate features is used, but now, instead of looking at all the thresholds to find the best the best split, thresholds (for the split) are chosen completely at random for each candidate feature and the best of these randomly generated thresholds is picked as the splitting rule. We all know that tree-based methods employ a greedy algorithm when choosing the feature to split on. Thus, we can think of this as taking an extra step in trying to migitate this drawback\n",
"\n",
"> Based on [Stackoverflow: RandomForestClassifier vs ExtraTreesClassifier in scikit learn](http://stackoverflow.com/questions/22409855/randomforestclassifier-vs-extratreesclassifier-in-scikit-learn?rq=1)\n",
"> In practice, RFs are often more compact than ETs. ETs are generally cheaper to train from a computational point of view but can grow much bigger. ETs can sometime generalize better than RFs but it's hard to guess when it's the case without trying both first (and tuning n_estimators, max_features and min_samples_split by cross-validated grid search)."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"image/png": {
"height": 378,
"width": 522
}
},
"output_type": "display_data"
}
],
"source": [
"# grid search on a range of max features and compare \n",
"# the performance between Extra Trees and Random Forest\n",
"param_name = 'max_features'\n",
"max_features_options = np.arange(4, 10)\n",
"fit_param = {param_name: max_features_options}\n",
"\n",
"rf_reg = RandomForestRegressor(n_estimators = 30)\n",
"et_reg = ExtraTreesRegressor(n_estimators = 30)\n",
"gs_rf = GridSearchCV(rf_reg, fit_param, n_jobs = -1)\n",
"gs_et = GridSearchCV(et_reg, fit_param, n_jobs = -1)\n",
"gs_rf.fit(X_train, y_train)\n",
"gs_et.fit(X_train, y_train)\n",
"\n",
"# visualize the performance on the cross validation test score\n",
"gs_rf_mean_score = gs_rf.cv_results_['mean_test_score']\n",
"gs_et_mean_score = gs_et.cv_results_['mean_test_score']\n",
"mean_scores = [gs_rf_mean_score, gs_et_mean_score]\n",
"labels = ['RF', 'ET']\n",
"\n",
"for score, label in zip(mean_scores, labels):\n",
" plt.plot(max_features_options, score, label = label)\n",
"\n",
"plt.legend()\n",
"plt.ylabel('MSE')\n",
"plt.xlabel(param_name)\n",
"plt.xlim( np.min(max_features_options), np.max(max_features_options) )\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is not always the case that Random Forest will outperform Extra Trees making it a method that's worth trying. As for interpretation, Extra Trees is simply another kind of Ensemble Tree method, hence we can still access the `feature_importance_` attribute to see which predictors were contributing a lot to explaining the response."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Reference"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- [Notebook: Ensembling](http://nbviewer.jupyter.org/github/justmarkham/DAT8/blob/master/notebooks/18_ensembling.ipynb)\n",
"- [Notebook: useR machine learning tutorial Random Forest](http://nbviewer.jupyter.org/github/ledell/useR-machine-learning-tutorial/blob/master/random-forest.ipynb)\n",
"- [Blog: Selecting good features – Part III: random forests](http://blog.datadive.net/selecting-good-features-part-iii-random-forests/)\n",
"- [Blog: The Unreasonable Effectiveness of Random Forests](https://medium.com/rants-on-machine-learning/the-unreasonable-effectiveness-of-random-forests-f33c3ce28883#.pv7i5ien9)\n",
"- [StackExchange: Explaining to laypeople why bootstrapping works](http://stats.stackexchange.com/questions/26088/explaining-to-laypeople-why-bootstrapping-works/)\n",
"- [Stackoverflow: RandomForestClassifier vs ExtraTreesClassifier in scikit learn](http://stackoverflow.com/questions/22409855/randomforestclassifier-vs-extratreesclassifier-in-scikit-learn?rq=1)\n",
"- [Stackoverflow: How are feature_importances in RandomForestClassifier determined?](http://stackoverflow.com/questions/15810339/how-are-feature-importances-in-randomforestclassifier-determined)"
]
}
],
"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.4"
},
"toc": {
"nav_menu": {
"height": "145px",
"width": "252px"
},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": true,
"toc_position": {},
"toc_section_display": "block",
"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": 1
}