09_random_forests/images/feature_importance_demo.png 09_random_forests/README.md # Random Forests This exercise focuses on ensemble methods using decision trees. In particular we will explore Random...

1 answer below »

In Readme.md for both E09 and E10 there are questions that needs to be answered by sending in code, plots or text. This is all explained in the “Readme.md” for E09 and E10


There are 18 questions in E09 and 7 questions in E10












09_random_forests/images/feature_importance_demo.png 09_random_forests/README.md # Random Forests This exercise focuses on ensemble methods using decision trees. In particular we will explore Random Forests and Extremely Randomized Trees which are methods that take extra steps in creating variety in the base learner, the decision trees, in the ensemble. In this assignment we will continue to use the cancer dataset that we used in the previous assignment. ## Section 1 In the first section we will take steps towards ensemble classifier methods using vanilla decision trees. ### Section 1.1 Before we try out an ensemble classifier based on trees, let's first apply a single decision tree to see what we can improve on. In this assignment we will be using the class `CancerClassifier` to carry out experiments. The only two input arguments to `CancerClassifier` is `classifier` and `train_ratio`. In general, `classifier` can be any type of `sklearn` classifier like `sklearn.tree.DecisionTreeClassifier`. To start with, finish implementing the following methods of the `CancerClassifier` class: * `confusion_matrix()` * `accuracy()` * `precision()` * `recall()` * `cross_validation_accuracy()` The last method should perform 10-fold cross validation on the entire cancer dataset and return the average accuracy of those 10 folds. Example of usage: ``` classifier_type = sklearn.some.Classifier(param=3) cc = CancerClassifier(classifier_type) print(cc.accuracy()) ``` ### Section 1.2 *This question should be answered on Mimir* Now run `CancerClassifier` with a `DecisionTreeClassifier`. and evaluate the performance with the methods that you have finished implementing. Answer the following questions: 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy) 2. What does the precision and recall tell us that the accuracy can't? 3. What could possibly explain the difference between accuracy and cross validation accuracy? 4. How would you suggest a confusion matrix, precision and recall for cross validation would be formulated? ## Section 2 Bagging where the base learners are decision trees are often referred to as *tree bagging*. Each decision tree is trained using a bootstrap subset of the training set to create variety amongst the base learners. Random forests go even further and create more variety by sampling the features when making splits in each node in each decision tree. This means that in a given node, instead of using for example all $D=10$ features, the algorithm will choose a subset of a set value, say $d=3$ , in this instance features 4, 6 and 10. Another node would be a different subset, say features 2, 5 and 7. A typical choice of $d$ is $\sqrt{D}$ or $\text{log}_2(D)$. The number of features (attributes) for our problem is of course 30, the dimensionality of each feature vector in the dataset. ### Section 2.1 *This question should be answered via Mimir* Implement a vanilla random forest and apply to the problem in the same way that the decision tree was evaluated, using your `CancerClassifier`. 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy) 2. What is the best combination of a total number of trees in the forest (`n_estimators`) and the maximum number of features considered in each split (`max_features`) that you can find? What are the metric results for this parameter selection? ### Section 2.2. Add a method to your class called `feature_importance` that plots a bar plot of feature importances for the random forest and returns a list of feature indices sorted by importance (highest first). You can access feature importance of a `sklearn` classifier with `classifier.feature_importances_`. Example inputs and outputs: ``` cc = CancerClassifier(my_classifier) feature_idx = cc.feature_importance() ``` First a plot should appear then when the user has escaped the plot window the user can access the feature indexes. ``` >> feature_idx [22, 6, 7, ...] ``` For the first 5 features, this plot looks like the following: ![Feature Importance](images/feature_importance_demo.png) Upload your plot as `2_2_1.png` ### Section 2.3 *This question should be answered via Mimir* 1. Describe how feature importance is calculated 2. Which feature is the most important and which is the least important. Use information from either [assignment 8](../08_SVM/README.md) or [here](https://www.kaggle.com/uciml/breast-cancer-wisconsin-data) to name these features. ### Section 2.4 [OOB Errors for Random Forests](https://scikit-learn.org/stable/auto_examples/ensemble/plot_ensemble_oob.html#sphx-glr-auto-examples-ensemble-plot-ensemble-oob-py) is the average error for each training example calculated using predictions from the trees that do not contain that training sample in their respective bootstrap sample. This means that a Random forest can be trained and validated simultaneously. The validation data is precisely the data that is **not** used to determine the parameters in the decision trees. Let's examine the development of the out-of-bag error as we increase the size of the forest. Adapt the code in the link to the cancer dataset and generate the plot. You can use `_plot_oob_error` for this. Turn in your plot as `2_4_1.png`. ### Section 2.5 *This question should be answered via Mimir* 1. What can be said about the relationship between the OOB error rate and the number of estimators? 2. Do all three types of ensembles follow this correlation? ## Section 3 Extremely Randomized Trees are just like Random Forests in that they are an ensemble of decision trees that are trained on bootstrap subsets of the training data and in each split a random subset of features are taken into consideration. But instead of searching for an optimum threshold amongst the candidate features in each split, random thresholds are tested, one per candidate feature, and then the best split is chosen amongst those. ### Section 3.1 *This question should be answered via Mimir* Now run `CancerClassifier` with a `ExtraTreesClassifier` Plot the same feature importance bar plot as before. Upload it as `3_1_1.png`. 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy) 2. What is the most important feature and the least important feature? ### Section 3.2 Now make a similar plot to the one in section 2.4 but now with extremely randomized trees. You can use `_plot_extreme_oob_error` for this. Upload your plot as `3_2_1.png`. ### Independent section This is an open ended independent section. You are welcome to analyze these models further, test them out on other datasets, compare parameters w.r.t. accuracy, recall, etc. 09_random_forests/template.py import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_breast_cancer from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import train_test_split, cross_val_score from sklearn.metrics import (confusion_matrix, accuracy_score, recall_score, precision_score) from collections import OrderedDict class CancerClassifier: ''' A general class to try out different sklearn classifiers on the cancer dataset ''' def __init__(self, classifier, train_ratio: float = 0.7): self.classifier = classifier cancer = load_breast_cancer() self.X = cancer.data # all feature vectors self.t = cancer.target # all corresponding labels self.X_train, self.X_test, self.t_train, self.t_test =\ train_test_split( cancer.data, cancer.target, test_size=1-train_ratio, random_state=109) # Fit the classifier to the training data here ... def confusion_matrix(self) -> np.ndarray: '''Returns the confusion matrix on the test data ''' ... def accuracy(self) -> float: '''Returns the accuracy on the test data ''' ... def precision(self) -> float: '''Returns the precision on the test data ''' ... def recall(self) -> float: '''Returns the recall on the test data ''' ... def cross_validation_accuracy(self) -> float: '''Returns the average 10-fold cross validation accuracy on the entire dataset. ''' ... def feature_importance(self) -> list: ''' Draw and show a barplot of feature importances for the current classifier and return a list of indices, sorted by feature importance (high to low). ''' ... def _plot_oob_error(): RANDOM_STATE = 1337 ensemble_clfs = [ ("RandomForestClassifier, max_features='sqrt'", RandomForestClassifier( n_estimators=100, warm_start=True, oob_score=True, max_features="sqrt", random_state=RANDOM_STATE)), ("RandomForestClassifier, max_features='log2'", RandomForestClassifier( n_estimators=100, warm_start=True, max_features='log2', oob_score=True, random_state=RANDOM_STATE)),
09randomforests-opsi1avi.7z 10boosting-hzs0goxh.7z
Answered 3 days AfterOct 18, 2021

Answer To: 09_random_forests/images/feature_importance_demo.png 09_random_forests/README.md # Random Forests...

Vicky answered on Oct 22 2021
123 Votes
09_random_forests/.ipynb_checkpoints/Untitled-checkpoint.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"from sklearn.datasets import load_breast_cancer\n",
"\n",
"from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier\n",
"from sklearn.tree import DecisionTreeClassifier\n",
"from sklearn.model_selection import train_test_split, cross_val_score\n",
"from sklearn.metrics import (confusion_matrix, accuracy_score, recall_score,\n",
" precision_score)\n",
"\n",
"from collections import OrderedDict\n",
"\n",
"\n",
"class CancerClassifier:\n",
" '''\n",
" A general class to try out different sklearn classifiers\n",
" on the cancer dataset\n",
" '''\n",
" def __init__(self, classifier, train_ratio: float = 0.7):\n",
" self.classifier = classifier\n",
" cancer = load_breast_cancer()\n",
" self.X = cancer.data # all feature vectors\n",
" self.t = cancer.target # all corresponding labels\n",
" self.X_train, self.X_test, self.t_train, self.t_test =\\\n",
" train_test_split(\n",
" cancer.data, cancer.target,\n",
" test_size=1-train_ratio, random_state=109)\n",
"\n",
" # Fit the classifier to the training data here\n",
" self.classifier.fit(self.X_train, self.t_train)\n",
"\n",
" def confusion_matrix(self) -> np.ndarray:\n",
" '''Returns the confusion matrix on the test data\n",
" '''\n",
" return confusion_matrix(self.t_test, self.classifier.predict(self.X_test))\n",
" \n",
"\n",
" def accuracy(self) -> float:\n",
" '''Returns the accuracy on the test data\n",
" '''\n",
" return accuracy_score(self.t_test, self.classifier.predict(self.X_test))\n",
"\n",
" def precision(self) -> float:\n",
" '''Returns the precision on the test data\n",
" '''\n",
" return precision_score(self.t_test, self.classifier.predict(self.X_test))\n",
"\n",
" def recall(self) -> float:\n",
" '''Returns the recall on the test data\n",
" '''\n",
" return recall_score(self.t_test, self.classifier.predict(self.X_test))\n",
"\n",
" def cross_validation_accuracy(self) -> float:\n",
" '''Returns the average 10-fold cross validation\n",
" accuracy on the entire dataset.\n",
" '''\n",
" return np.mean(cross_val_score(self.classifier,self.X,self.t,cv=10))\n",
"\n",
" def feature_importance(self) -> list:\n",
" '''\n",
" Draw and show a barplot of feature importances\n",
" for the current classifier and return a list of\n",
" indices, sorted by feature importance (high to low).\n",
" '''\n",
" plt.bar(range(len(self.classifier.feature_importances_[:5])), self.classifier.feature_importances_[:5])\n",
" plt.xlabel(\"Feature index\")\n",
" plt.ylabel(\"Feature importance\")\n",
" plt.show()\n",
" return np.argsort(self.classifier.feature_importances_)[::-1]\n",
"\n",
"\n",
"def _plot_oob_error():\n",
" RANDOM_STATE = 1337\n",
" ensemble_clfs = [\n",
" (\"RandomForestClassifier, max_features='sqrt'\",\n",
" RandomForestClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" oob_score=True,\n",
" max_features=\"sqrt\",\n",
" random_state=RANDOM_STATE)),\n",
" (\"RandomForestClassifier, max_features='log2'\",\n",
" RandomForestClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" max_features='log2',\n",
" oob_score=True,\n",
" random_state=RANDOM_STATE)),\n",
" (\"RandomForestClassifier, max_features=None\",\n",
" RandomForestClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" max_features=None,\n",
" oob_score=True,\n",
" random_state=RANDOM_STATE))]\n",
"\n",
" # Map a classifier name to a list of (, ) pairs.\n",
" error_rate = OrderedDict((label, []) for label, _ in ensemble_clfs)\n",
"\n",
" min_estimators = 30\n",
" max_estimators = 175\n",
"\n",
" for label, clf in ensemble_clfs:\n",
" for i in range(min_estimators, max_estimators + 1):\n",
" clf.set_params(n_estimators=i)\n",
" cancer = load_breast_cancer()\n",
" clf.fit(cancer.data, cancer.target) # Use cancer data here\n",
" oob_error = 1 - clf.oob_score_\n",
" error_rate[label].append((i, oob_error))\n",
"\n",
" # Generate the \"OOB error rate\" vs. \"n_estimators\" plot.\n",
" for label, clf_err in error_rate.items():\n",
" xs, ys = zip(*clf_err)\n",
" plt.plot(xs, ys, label=label)\n",
"\n",
" plt.xlim(min_estimators, max_estimators)\n",
" plt.xlabel(\"n_estimators\")\n",
" plt.ylabel(\"OOB error rate\")\n",
" plt.legend(loc=\"upper right\")\n",
" plt.show()\n",
"\n",
"\n",
"def _plot_extreme_oob_error():\n",
" RANDOM_STATE = 1337\n",
" ensemble_clfs = [\n",
" (\"ExtraTreesClassifier, max_features='sqrt'\",\n",
" ExtraTreesClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" bootstrap=True,\n",
" oob_score=True,\n",
" max_features=\"sqrt\",\n",
" random_state=RANDOM_STATE)),\n",
" (\"ExtraTreesClassifier, max_features='log2'\",\n",
" ExtraTreesClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" bootstrap=True,\n",
" max_features='log2',\n",
" oob_score=True,\n",
" random_state=RANDOM_STATE)),\n",
" (\"ExtraTreesClassifier, max_features=None\",\n",
" ExtraTreesClassifier(\n",
" n_estimators=100,\n",
" warm_start=True,\n",
" bootstrap=True,\n",
" max_features=None,\n",
" oob_score=True,\n",
" random_state=RANDOM_STATE))]\n",
"\n",
" # Map a classifier name to a list of (, ) pairs.\n",
" error_rate = OrderedDict((label, []) for label, _ in ensemble_clfs)\n",
"\n",
" min_estimators = 30\n",
" max_estimators = 175\n",
"\n",
" for label, clf in ensemble_clfs:\n",
" for i in range(min_estimators, max_estimators + 1):\n",
" clf.set_params(n_estimators=i)\n",
" cancer = load_breast_cancer()\n",
" clf.fit(cancer.data, cancer.target) # Use cancer data here\n",
" oob_error = 1 - clf.oob_score_\n",
" error_rate[label].append((i, oob_error))\n",
"\n",
" # Generate the \"OOB error rate\" vs. \"n_estimators\" plot.\n",
" for label, clf_err in error_rate.items():\n",
" xs, ys = zip(*clf_err)\n",
" plt.plot(xs, ys, label=label)\n",
"\n",
" plt.xlim(min_estimators, max_estimators)\n",
" plt.xlabel(\"n_estimators\")\n",
" plt.ylabel(\"OOB error rate\")\n",
" plt.legend(loc=\"upper right\")\n",
" plt.show()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Now run `CancerClassifier` with a `DecisionTreeClassifier`. and evaluate the performance with the methods that you have finished implementing. Answer the following questions:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 59 4]\n",
" [ 3 105]]\n",
"0.9590643274853801\n",
"0.963302752293578\n",
"0.9722222222222222\n",
"0.9209586466165414\n"
]
}
],
"source": [
"classifier_type = sklearn.tree.DecisionTreeClassifier()\n",
"cc = CancerClassifier(classifier_type)\n",
"print(cc.confusion_matrix())\n",
"print(cc.accuracy())\n",
"print(cc.precision())\n",
"print(cc.recall())\n",
"print(cc.cross_validation_accuracy())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Confusion Matrix = [[ 59 4]\n",
" [ 3 105]]\n",
" \n",
"Accuracy = 0.9590643274853801\n",
"\n",
"Precision = 0.963302752293578\n",
"\n",
"Recall = 0.9722222222222222\n",
"\n",
"Cross Validation Accuracy = 0.9209586466165414"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. What does the precision and recall tell us that the accuracy can't?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Recall: The ability of a model to find all the relevant cases within a data set. Mathematically, we define recall as the number of true positives divided by the number of true positives plus the number of false negatives.\n",
"\n",
"Precision: The ability of a classification model to identify only the relevant data points. Mathematically, precision the number of true positives divided by the number of true positives plus the number of false positives."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. What could possibly explain the difference between accuracy and cross validation accuracy?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The Accuracy of the model is the average of the accuracy of each fold. That cross validation is a procedure used to avoid overfitting and estimate the skill of the model on new data. There are common tactics that you can use to select the value of k for your dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. How would you suggest a confusion matrix, precision and recall for cross validation would be formulated?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Confusion Matrix = [[TP FP] \n",
"[FN TN]]\n",
"\n",
"Precision = TP/(TP+FP)\n",
"\n",
"Recall = TP/(TP+FN)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 58 5]\n",
" [ 0 108]]\n",
"0.9707602339181286\n",
"0.9557522123893806\n",
"1.0\n",
"0.9596491228070176\n"
]
}
],
"source": [
"classifier_type = sklearn.ensemble.RandomForestClassifier()\n",
"cc = CancerClassifier(classifier_type)\n",
"print(cc.confusion_matrix())\n",
"print(cc.accuracy())\n",
"print(cc.precision())\n",
"print(cc.recall())\n",
"print(cc.cross_validation_accuracy())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Confusion Matrix = [[ 58 5]\n",
" [ 0 108]]\n",
" \n",
"Accuracy = 0.9707602339181286\n",
"\n",
"Precision = 0.9557522123893806\n",
"\n",
"Recall = 1.0\n",
"\n",
"Cross Validation Accuracy = 0.9596491228070176"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. What is the best combination of a total number of trees in the forest (`n_estimators`) and the maximum number of features considered in each split (`max_features`) that you can find? What are the metric results for this parameter selection?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"n_exstimators = 135, max_features=None"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"array([ 7, 27, 6, 22, 20, 23, 26, 3, 0, 2, 13, 1, 24, 21, 5, 25, 19,\n",
" 10, 28, 4, 12, 11, 29, 16, 9, 17, 14, 15, 8, 18], dtype=int64)"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"cc = CancerClassifier(classifier_type)\n",
"feature_idx = cc.feature_importance()\n",
"feature_idx"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Describe how feature importance is calculated"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Feature importance is calculated as the decrease in node impurity weighted by the probability of reaching that node. The node probability can be calculated by the number of samples that reach the node, divided by the total number of samples. The higher the value the more important the feature."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Which feature is the most important and which is the least important. Use information from either [assignment 8](../08_SVM/README.md) or [here](https://www.kaggle.com/uciml/breast-cancer-wisconsin-data) to name these features."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Feature 7,27,6,22,20 are most important and feature 17,14,15,8,18 are least important."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"_plot_oob_error()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. What can be said about the relationship between the OOB error rate and the number of estimators?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As number of estimators increases, the OOB error rate decreases."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Do all three types of ensembles follow this correlation?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Yes, as overall all three types of ensembles follow this correlation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Upload the result for each metric (confusion matrix, accuracy, precision, recall, cross validation accuracy)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 59 4]\n",
" [ 0 108]]\n",
"0.9766081871345029\n",
"0.9642857142857143\n",
"1.0\n",
"0.9683583959899748\n"
]
}
],
"source": [
"classifier_type = sklearn.ensemble.ExtraTreesClassifier()\n",
"cc = CancerClassifier(classifier_type)\n",
"print(cc.confusion_matrix())\n",
"print(cc.accuracy())\n",
"print(cc.precision())\n",
"print(cc.recall())\n",
"print(cc.cross_validation_accuracy())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Confusion Matrix = [[ 59 4]\n",
" [ 0 108]]\n",
" \n",
"Accuracy = 0.9766081871345029\n",
"\n",
"Precision = 0.9642857142857143\n",
"\n",
"Recall = 1.0\n",
"\n",
"Cross Validation Accuracy = 0.9683583959899748"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. What is the most important feature and the least important feature?"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"image/png":...
SOLUTION.PDF
SOLUTION.PDF

Answer To This Question Is Available To Download

Related Questions & Answers

More Questions »

Submit New Assignment

Copy and Paste Your Assignment Here
Have files?