{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Top Performers Model \n", "\n", "This notebook documents the process of building a model to predict the top performers in the company. The model will be used to identify the top performers in the company and provide insights into the factors that contribute to their success. \n", "The model will be built using a demo dataset composed of metrics from Viva Insights, and we will be using a random forest classifier from `sklearn` for this purpose. \n", "\n", "## Set-up\n", "\n", "We start off by loading in the required Python packages:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# data cleaning and utility\n", "import numpy as np\n", "import pandas as pd\n", "import vivainsights as vi\n", "import os\n", "\n", "# visualizations\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "from matplotlib.legend_handler import HandlerLine2D\n", "\n", "# machine learning\n", "from sklearn.ensemble import RandomForestClassifier # scikit-learn\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, auc, roc_curve\n", "from sklearn.inspection import permutation_importance" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next step here is to load in the dataset, and then examine the data. In our local directory, we have a demo dataset that has a similar structure to a Person Query, with an additional 5-point scale 'performance' attribute that represents performance scores. \n", "\n", "`vi.import_query()` imports the demo person query data, and performs cleaning on the variable names. An alternative to this is to use `pd.read_csv()`, which does the same thing of reading in the input csv file. " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
PersonIdInternal_network_sizeCollaboration_hoursweekend_collaboration_hoursAfter_hours_call_hoursperformance
08c14b6ac-f043-39a6-9365-2898072a595179130.0430631.1626950.05.0
18c14b6ac-f043-39a6-9365-2898072a595179129.3199531.0000000.05.0
28c14b6ac-f043-39a6-9365-2898072a595179128.9421131.0654720.05.0
38c14b6ac-f043-39a6-9365-2898072a595179128.5463631.0325000.05.0
48c14b6ac-f043-39a6-9365-2898072a595179127.1440631.0975000.05.0
\n", "
" ], "text/plain": [ " PersonId Internal_network_size \\\n", "0 8c14b6ac-f043-39a6-9365-2898072a5951 79 \n", "1 8c14b6ac-f043-39a6-9365-2898072a5951 79 \n", "2 8c14b6ac-f043-39a6-9365-2898072a5951 79 \n", "3 8c14b6ac-f043-39a6-9365-2898072a5951 79 \n", "4 8c14b6ac-f043-39a6-9365-2898072a5951 79 \n", "\n", " Collaboration_hours weekend_collaboration_hours After_hours_call_hours \\\n", "0 130.04306 31.162695 0.0 \n", "1 129.31995 31.000000 0.0 \n", "2 128.94211 31.065472 0.0 \n", "3 128.54636 31.032500 0.0 \n", "4 127.14406 31.097500 0.0 \n", "\n", " performance \n", "0 5.0 \n", "1 5.0 \n", "2 5.0 \n", "3 5.0 \n", "4 5.0 " ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set relative path to go up one directory and into data folder\n", "raw_data = vi.import_query(os.getcwd() + \"\\\\..\\\\data\\\\Top_Performers_Dataset_v2.csv\")\n", "\n", "# Examine the data\n", "raw_data.head() # first 5 rows" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data preparation\n", "\n", "There are typically a number of data preparation and validation procedures involved before fitting a model, such as: \n", "- Handling missing values\n", "- Changing variable types\n", "- Handling outliers and unwanted data\n", "- Splitting data into training and test sets\n", "\n", "In this notebook, we will assume that the dataset is in decent quality, and all that is required are the standard procedures of changing variable types and splitting data into train/test sets. \n", "\n", "We start off by dropping any non-numeric columns (`PersonId` in this case). It is optional, but we also convert the `performance` variable into a binary variable (`perform_cat`), so we would yield a classification model. This step is for demo purposes as there are more use cases where the outcome variable is binary rather than ordinal or continuous. " ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Internal_network_sizeCollaboration_hoursweekend_collaboration_hoursAfter_hours_call_hoursperformanceperform_cat
079130.0430631.1626950.05.01
179129.3199531.0000000.05.01
279128.9421131.0654720.05.01
379128.5463631.0325000.05.01
479127.1440631.0975000.05.01
\n", "
" ], "text/plain": [ " Internal_network_size Collaboration_hours weekend_collaboration_hours \\\n", "0 79 130.04306 31.162695 \n", "1 79 129.31995 31.000000 \n", "2 79 128.94211 31.065472 \n", "3 79 128.54636 31.032500 \n", "4 79 127.14406 31.097500 \n", "\n", " After_hours_call_hours performance perform_cat \n", "0 0.0 5.0 1 \n", "1 0.0 5.0 1 \n", "2 0.0 5.0 1 \n", "3 0.0 5.0 1 \n", "4 0.0 5.0 1 " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "clean_data = raw_data.drop(columns=['PersonId']) # drop PersonId - not required for fitting\n", "# Binary variable where >= 4 indicates High Performance\n", "clean_data['perform_cat'] = np.where(clean_data['performance'] >= 4, 1, 0)\n", "\n", "\n", "clean_data.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `train_test_split()` function from `sklearn.model_selection` makes it easy to split the data into training and test datasets. In the following example, the parameters are provided in this order: (i) data frame containing the predictor variables only, (ii) data frame containing the outcome variable only, and (iii) `test_size` controlling the proportion of the dataset to include in the train split.\n", "\n", "This is assigned to four data frames:\n", "- `x_train` - predictors, train set\n", "- `x_test` - predictors, test set\n", "- `y_train` - outcome, train set\n", "- `y_test` - outcome, test set" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# Split train and test data\n", "outc_var_df = clean_data['perform_cat']\n", "pred_var_df = clean_data.drop(columns=['perform_cat', 'performance'])\n", "\n", "x_train, x_test, y_train, y_test = train_test_split(pred_var_df, outc_var_df, test_size = 0.30)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can run the following to check whether the predictors used in the model is what we would expect:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Columns in `pred_var_df`: Internal_network_size, Collaboration_hours, weekend_collaboration_hours, After_hours_call_hours\n" ] } ], "source": [ "print(\"Columns in `pred_var_df`: \" + ', '.join(pred_var_df.columns))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Fitting the model\n", "\n", "The next step is to fit the random forest model, with `RandomForestClassifer()` from the `sklearn.ensemble` module.\n", "\n", "After initializing the model and assigning to `rf`, we supply `x_train` and `y_train` to `fit()`, where the two variables represent the training data sets for the predictors and the outcome respectively.\n", "\n", "Note that `RandomForestClassifier()` comes with many default parameters, which you can find out more [here](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html). We are using all the default parameters here to `RandomForestClassifier()`. There is a section at the bottom that covers how the hyperparameters can be tuned for the random forest model. \n" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
RandomForestClassifier()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "RandomForestClassifier()" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rf = RandomForestClassifier()\n", "\n", "rf.fit(x_train, y_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluating the model\n", "\n", "If no errors or warnings pop up, then the first iteration of the model is trained. The next step is to understand the model, and then to interpret and evaluate its outputs. \n", "\n", "Here are some metrics for assessing the model, which can all be run from `sklearn.metrics`. The first four metrics below range between 0 and 1, and an idealistic perfect model would return 1, meaning that it makes no errors of the type: \n", "\n", "- **Accuracy**: This is the ratio of correct predictions to the total number of predictions. It's a good measure when the target variable classes in the data are nearly balanced. However, it can be misleading if the classes are imbalanced. \n", "\n", "- **Precision**: Precision is the ratio of true positives (correctly predicted positive observations) to the total predicted positives. It's a measure of a classifier's exactness. A low precision indicates a high number of false positives (Type I errors). \n", "\n", "- **Recall (Sensitivity)**: Recall is the ratio of true positives to the total actual positives. It's a measure of a classifier's completeness. A low recall indicates a high number of false negatives (Type II errors). \n", "\n", "- **F1 Score**: The F1 Score is the weighted average of **Precision** and **Recall**. It tries to balance the two metrics. It's a good measure to use if you need to seek a balance between Precision and Recall and there is an uneven class distribution. It is given by:\n", " ```\n", " F1 = 2 * (precision * recall) / (precision + recall)\n", " ```\n", "\n", "All of these metrics can be calculated directly from a **Confusion Matrix**, which is a table that is often used to describe the performance of a classification model on a set of data for which the true values are known. It contains information about actual and predicted classifications done by the classifier. It's a good way to visualize the performance of the model. \n", "\n", "The choice of metric depends on your business objective. For example, if the cost of having false positives is high, the strategy might be to optimize for precision; this arguably applies to a top performers use case, where it is preferred that the model predicts fewer top performers. If the cost of missing positives (having false negatives) is high, the strategy might be to optimize for recall, which could be more relevant for an attrition use case. " ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Accuracy': [0.99], 'Precision': [0.9904049295774647], 'Recall': [0.99], 'F1 Score': [0.9901525029763593]}\n", "{'True Positives': 14, 'False Positives': 2, 'True Negatives': 283, 'False Negatives': 1}\n" ] } ], "source": [ "# Predict the labels for the test set\n", "y_pred = rf.predict(x_test)\n", "\n", "# Calculate metrics\n", "accuracy = accuracy_score(y_test, y_pred)\n", "precision = precision_score(y_test, y_pred, average='weighted')\n", "recall = recall_score(y_test, y_pred, average='weighted')\n", "f1 = f1_score(y_test, y_pred, average='weighted')\n", "conf_matrix = confusion_matrix(y_test, y_pred)\n", "\n", "# Store metrics in dictionary then print\n", "metrics_dict = {\n", " 'Accuracy': [accuracy],\n", " 'Precision': [precision],\n", " 'Recall': [recall],\n", " 'F1 Score': [f1]\n", "}\n", "\n", "print(metrics_dict)\n", "\n", "# Store confusion matrix in dictionary then print\n", "cm_dict = {\n", " 'True Positives': conf_matrix[1, 1],\n", " 'False Positives': conf_matrix[0, 1],\n", " 'True Negatives': conf_matrix[0, 0],\n", " 'False Negatives': conf_matrix[1, 0]\n", "}\n", "\n", "print(cm_dict)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "See below for a guide on how to interpret the confusion matrix:\n", "\n", "A confusion matrix is a table that is often used to describe the performance of a classification model on a set of data for which the true values are known. In binary classification, the confusion matrix is a 2x2 matrix. Here's how to interpret it:\n", "\n", "- The first row of the matrix represents the instances in the actual class (true class) - in this case, it's the negative class.\n", "- The second row of the matrix represents the instances in the actual class (true class) - in this case, it's the positive class.\n", "- The first column of the matrix represents the instances in the predicted class - in this case, it's the negative class.\n", "- The second column of the matrix represents the instances in the predicted class - in this case, it's the positive class.\n", "\n", "So, the confusion matrix looks like this:\n", "\n", "| | Predicted Negative | Predicted Positive |\n", "|--------------------|--------------------|--------------------|\n", "| **Actual Negative**| True Negative (TN) | False Positive (FP)|\n", "| **Actual Positive**| False Negative (FN)| True Positive (TP) |\n", "\n", "- **True Positives (TP)**: These are cases in which we predicted yes (positive), and the actual was also yes (positive).\n", "- **True Negatives (TN)**: We predicted no (negative), and the actual was also no (negative).\n", "- **False Positives (FP)**: We predicted yes (positive), but the actual was no (negative). Also known as \"Type I error\".\n", "- **False Negatives (FN)**: We predicted no (negative), but the actual was yes (positive). Also known as \"Type II error\".\n", "\n", "The diagonal elements represent the number of points for which the predicted label is equal to the true label, while off-diagonal elements are those that are mislabeled by the classifier. The higher the diagonal values of the confusion matrix, the better, indicating many correct predictions.\n", "\n", "In the above, the confusion matrix is transformed into a dictionary to make it easier for interpretation. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Variable importance\n", "\n", "One of the major outputs of the Random Forest model is **feature importance**. \n", "\n", "Impurity-based feature importance and permutation-based feature importance are two different methods of calculating the importance of features in a machine learning model, each with its own strengths and weaknesses.\n", "\n", "1. **Impurity-based Feature Importance (Mean Decrease Impurity, MDI)**: This method calculates the total amount that each feature decreases the impurity, averaged over all trees in the forest. The impurity decrease from each feature can be interpreted as the importance of that feature. This method is fast to compute and does not require a separate validation set or model re-fitting. However, it tends to inflate the importance of continuous features or high-cardinality categorical variables. It is also biased towards features with more categories.\n", "\n", "2. **Permutation-based Feature Importance (Mean Decrease Accuracy, MDA)**: This method involves permuting the values of each feature one by one and measuring the decrease in the model's performance. The idea is that if a feature is important, permuting its values will drastically degrade the model's performance. This method is more reliable and has less bias towards continuous or high-cardinality features, but it is computationally expensive as it requires re-fitting the model for each feature, and it also requires a separate validation set.\n", "\n", "In the context of Random Forest models in scikit-learn:\n", "\n", "- The `feature_importances_` attribute of the `RandomForestClassifier` or `RandomForestRegressor` gives the impurity-based feature importance.\n", "- The `permutation_importance` function from `sklearn.inspection` can be used to calculate the permutation-based feature importance.\n", "\n", "### Impurity-based feature importance\n", "\n", "Feature importances are provided by the fitted attribute `feature_importances_` and they are computed as the mean and standard deviation of accumulation of the impurity decrease within each tree.\n", "\n", "We can either extract the outputs into a dictionary, or visualize them in a plot: " ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Internal_network_size': 0.08161966374568216, 'Collaboration_hours': 0.6702709388750904, 'weekend_collaboration_hours': 0.23995652140854554, 'After_hours_call_hours': 0.008152875970681817}\n" ] } ], "source": [ "# Get feature importance\n", "importance = rf.feature_importances_\n", "\n", "# Summarize feature importance\n", "forest_importances = pd.Series(importance, index=x_train.columns)\n", "\n", "# Convert the series to a dictionary\n", "forest_importances_dict = forest_importances.to_dict()\n", "\n", "print(forest_importances_dict)\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# get standard deviation of feature importances\n", "std = np.std([tree.feature_importances_ for tree in rf.estimators_], axis=0)\n", "\n", "# Plot feature importance\n", "fig, ax = plt.subplots()\n", "forest_importances.plot.bar(yerr=std, ax=ax)\n", "ax.set_title(\"Feature importances using MDI\")\n", "ax.set_ylabel(\"Mean decrease in impurity\")\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Feature permutation importance\n", "\n", "Permutation feature importance overcomes limitations of the impurity-based feature importance: they do not have a bias toward high-cardinality features and can be computed on a left-out test set.\n", "\n", "However, the computation for full permutation importance is more costly: features are shuffled n times and the model refitted to estimate the importance of it." ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Internal_network_size': -0.0026666666666666505, 'Collaboration_hours': 0.07900000000000001, 'weekend_collaboration_hours': -0.0029999999999999693, 'After_hours_call_hours': 0.0}\n" ] } ], "source": [ "fpi_result = permutation_importance(\n", " rf, x_test, y_test, n_repeats=10, random_state=42, n_jobs=5\n", ")\n", "\n", "forest_importances = pd.Series(fpi_result.importances_mean, index=x_train.columns)\n", "\n", "# Convert the series to a dictionary\n", "forest_importances_dict = forest_importances.to_dict()\n", "\n", "print(forest_importances_dict)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots()\n", "forest_importances.plot.bar(yerr=fpi_result.importances_std, ax=ax)\n", "ax.set_title(\"Feature importances using permutation on full model\")\n", "ax.set_ylabel(\"Mean accuracy decrease\")\n", "fig.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Tuning hyperparameters of the model\n", "\n", "We can then tune the parameters of the random forest model to find the optimal values of the hyperparameters that maximize the performance and accuracy of the model. \n", "\n", "- `n_estimators`: The number of trees in the forest. A higher number of trees can improve the accuracy of the model, but it also increases the computational complexity and the risk of overfitting. Therefore, we need to find the optimal number of trees that balances the trade-off between performance and efficiency.\n", "- `max_depth`: The maximum depth of each tree.\n", "- `min_samples_split`: The minimum number of samples required to split a node.\n", "- `min_samples_leaf`: The minimum number of samples required for a leaf node.\n", "- `max_features`: The number of features to consider when looking for the best split.\n", "- `criterion`: The function to measure the quality of a split.\n", "\n", "Note that a hyperparameter is external to the model, and therefore is not itself an output of the ML model. \n", "\n", "In the following section, we will look at how to tune the number of estimators (trees), the max depth, the minimum samples split, and the minimum samples leaf.\n", "\n", "In all the following plots, they will be measured against the Area Under the Curve (AUC) score, a model performance score ranging from 0 to 1. The AUC represents the likelihood that a classifier will assign a higher predicted probability to the positive class, compared to the negative class. \n", "\n", "To interpret the following plots: \n", "\n", "- Look at how the AUC scores change as the hyperparameter increases. If the AUC score increases with the hyperparameter, it means that increasing that hyperparameter is improving the model's performance.\n", "- Compare the 'Train AUC' and 'Test AUC' series. If the 'Train AUC' is much higher than the 'Test AUC', it could indicate that the model is overfitting to the training data. If both series are close together, it suggests that the model is generalizing well to unseen data.\n", "\n", "## Number of estimators\n", "\n", "The plot below is showing how the Area Under the Curve (AUC) score of a Random Forest model changes as the number of estimators (i.e., the number of trees in the forest) increases. The 'Train AUC' series shows the AUC score on the training data, while the 'Test AUC' series shows the AUC score on the test data." ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{1: 1.0, 2: 0.9827586206896552, 4: 0.9655172413793103, 8: 1.0, 16: 1.0, 32: 1.0, 64: 1.0, 100: 1.0, 200: 1.0}\n", "{1: 0.9947368421052631, 2: 0.9333333333333333, 4: 0.8631578947368421, 8: 0.9614035087719298, 16: 0.9666666666666667, 32: 0.9614035087719298, 64: 0.9614035087719298, 100: 0.9614035087719298, 200: 0.9614035087719298}\n" ] } ], "source": [ "n_estimators = [1, 2, 4, 8, 16, 32, 64, 100, 200]\n", "\n", "train_results = []\n", "test_results = []\n", "\n", "for estimator in n_estimators:\n", " rf = RandomForestClassifier(n_estimators=estimator, n_jobs=-1)\n", " rf.fit(x_train, y_train) \n", " train_pred = rf.predict(x_train) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " train_results.append(roc_auc) \n", " y_pred = rf.predict(x_test) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred)\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " test_results.append(roc_auc)\n", " \n", "# Create dictionary storing tuning results\n", "dict_train_hp_n_estimators = pd.Series(train_results, index = n_estimators).to_dict()\n", "dict_test_hp_n_estimators = pd.Series(test_results, index = n_estimators).to_dict()\n", "\n", "print(dict_train_hp_n_estimators)\n", "print(dict_test_hp_n_estimators)\n", "\n" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create plot \n", "line1, = plt.plot(n_estimators, train_results, 'b', label='Train AUC')\n", "line2, = plt.plot(n_estimators, test_results, 'r', label='Test AUC')\n", "\n", "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n", "plt.ylim(0 , 1.1)\n", "plt.title('Effect of Number of Estimators on AUC Score for Random Forest Model')\n", "plt.ylabel('AUC score')\n", "plt.xlabel('n_estimators')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Max depth\n", "\n", "The plot below is showing how the Area Under the Curve (AUC) score of a Random Forest model changes as the tree depth increases. The 'Train AUC' series shows the AUC score on the training data, while the 'Test AUC' series shows the AUC score on the test data." ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{1: 0.9827586206896552, 2: 1.0, 3: 1.0, 4: 1.0, 5: 1.0, 6: 1.0, 7: 1.0, 8: 1.0, 9: 1.0, 10: 1.0, 11: 1.0, 12: 1.0, 13: 1.0, 14: 1.0, 15: 1.0, 16: 1.0, 17: 1.0, 18: 1.0, 19: 1.0, 20: 1.0, 21: 1.0, 22: 1.0, 23: 1.0, 24: 1.0, 25: 1.0, 26: 1.0, 27: 1.0, 28: 1.0, 29: 1.0, 30: 1.0, 31: 1.0, 32: 1.0}\n", "{1: 0.9614035087719298, 2: 0.9614035087719298, 3: 0.9614035087719298, 4: 0.9614035087719298, 5: 0.9614035087719298, 6: 0.9614035087719298, 7: 0.963157894736842, 8: 0.963157894736842, 9: 0.9614035087719298, 10: 0.9614035087719298, 11: 0.963157894736842, 12: 0.9614035087719298, 13: 0.9614035087719298, 14: 0.9614035087719298, 15: 0.9614035087719298, 16: 0.963157894736842, 17: 0.9614035087719298, 18: 0.9614035087719298, 19: 0.963157894736842, 20: 0.9614035087719298, 21: 0.9614035087719298, 22: 0.963157894736842, 23: 0.9614035087719298, 24: 0.9614035087719298, 25: 0.9614035087719298, 26: 0.9614035087719298, 27: 0.9614035087719298, 28: 0.9614035087719298, 29: 0.9614035087719298, 30: 0.9614035087719298, 31: 0.9614035087719298, 32: 0.9614035087719298}\n" ] } ], "source": [ "max_depths = np.linspace(1, 32, 32, endpoint=True).astype(int)\n", "\n", "train_results = []\n", "test_results = []\n", "\n", "for max_depth in max_depths:\n", " rf = RandomForestClassifier(max_depth=max_depth, n_jobs=-1)\n", " rf.fit(x_train, y_train) \n", " train_pred = rf.predict(x_train) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " train_results.append(roc_auc) \n", " y_pred = rf.predict(x_test) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred) \n", " roc_auc = auc(false_positive_rate, true_positive_rate) \n", " test_results.append(roc_auc)\n", " \n", "# Create dictionary storing tuning results\n", "dict_train_hp_max_depths = pd.Series(train_results, index = max_depths).to_dict()\n", "dict_test_hp_max_depths = pd.Series(test_results, index = max_depths).to_dict()\n", "\n", "print(dict_train_hp_max_depths)\n", "print(dict_test_hp_max_depths)" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create plot\n", "line1, = plt.plot(max_depths, train_results, 'b', label='Train AUC')\n", "line2, = plt.plot(max_depths, test_results, 'r', label='Test AUC')\n", "\n", "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n", "plt.ylim(0 , 1.1)\n", "plt.title('Effect of Tree Depth on AUC Score for Random Forest Model')\n", "plt.ylabel('AUC score')\n", "plt.xlabel('Tree depth')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Minimum samples split\n", "\n", "The following plot shows how the Area Under the Curve (AUC) score of a Random Forest model changes as the minimum samples split parameter changes. The 'Train AUC' series shows the AUC score on the training data, while the 'Test AUC' series shows the AUC score on the test data." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{0.1: 0.9992548435171387, 0.2: 0.9992548435171387, 0.30000000000000004: 0.9992548435171387, 0.4: 0.9992548435171387, 0.5: 0.9992548435171387, 0.6: 0.9992548435171387, 0.7000000000000001: 0.5, 0.8: 0.5, 0.9: 0.5, 1.0: 0.5}\n", "{0.1: 0.9614035087719298, 0.2: 0.9614035087719298, 0.30000000000000004: 0.9614035087719298, 0.4: 0.9614035087719298, 0.5: 0.9614035087719298, 0.6: 0.9614035087719298, 0.7000000000000001: 0.5, 0.8: 0.5, 0.9: 0.5, 1.0: 0.5}\n" ] } ], "source": [ "min_samples_splits = np.linspace(0.1, 1.0, 10, endpoint=True)\n", "\n", "train_results = []\n", "test_results = []\n", "\n", "for min_samples_split in min_samples_splits:\n", " rf = RandomForestClassifier(min_samples_split=min_samples_split)\n", " rf.fit(x_train, y_train) \n", " train_pred = rf.predict(x_train) \n", "\n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n", "\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " train_results.append(roc_auc) \n", "\n", " y_pred = rf.predict(x_test) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred)\n", " \n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " test_results.append(roc_auc)\n", " \n", "# Create dictionary storing tuning results\n", "dict_train_hp_min_samples_splits = pd.Series(train_results, index = min_samples_splits).to_dict()\n", "dict_test_hp_min_samples_splits = pd.Series(test_results, index = min_samples_splits).to_dict()\n", "\n", "print(dict_train_hp_min_samples_splits)\n", "print(dict_test_hp_min_samples_splits) \n", "\n" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create plot\n", "line1, = plt.plot(min_samples_splits, train_results, 'b', label='Train AUC')\n", "line2, = plt.plot(min_samples_splits, test_results, 'r', label='Test AUC')\n", "\n", "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n", "plt.ylim(0 , 1.1)\n", "plt.title('Effect of Minimum Samples Split on AUC Score for Random Forest Model')\n", "plt.ylabel('AUC score')\n", "plt.xlabel('min samples split')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Minimum samples leaf\n", "\n", "The following plot shows how the Area Under the Curve (AUC) score of a Random Forest model changes as the minimum samples leaf parameter changes. The 'Train AUC' series shows the AUC score on the training data, while the 'Test AUC' series shows the AUC score on the test data." ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{0.1: 0.5, 0.2: 0.5, 0.30000000000000004: 0.5, 0.4: 0.5, 0.5: 0.5}\n", "{0.1: 0.5, 0.2: 0.5, 0.30000000000000004: 0.5, 0.4: 0.5, 0.5: 0.5}\n" ] } ], "source": [ "min_samples_leafs = np.linspace(0.1, 0.5, 5, endpoint=True)\n", "train_results = []\n", "test_results = []\n", "\n", "for min_samples_leaf in min_samples_leafs:\n", " rf = RandomForestClassifier(min_samples_leaf=min_samples_leaf)\n", " rf.fit(x_train, y_train) \n", " train_pred = rf.predict(x_train) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " train_results.append(roc_auc) \n", " y_pred = rf.predict(x_test) \n", " false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred)\n", " roc_auc = auc(false_positive_rate, true_positive_rate)\n", " test_results.append(roc_auc)\n", " \n", "# Create dictionary storing tuning results\n", "dict_train_hp_min_samples_leafs = pd.Series(train_results, index = min_samples_leafs).to_dict()\n", "dict_test_hp_min_samples_leafs = pd.Series(test_results, index = min_samples_leafs).to_dict()\n", "\n", "print(dict_train_hp_min_samples_leafs)\n", "print(dict_test_hp_min_samples_leafs) \n" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create plot\n", "line1, = plt.plot(min_samples_leafs, train_results, 'b', label='Train AUC')\n", "line2, = plt.plot(min_samples_leafs, test_results, 'r', label='Test AUC')\n", "\n", "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n", "plt.ylim(0 , 1.1)\n", "plt.title('Effect of Minimum Samples Leaf on AUC Score for Random Forest Model')\n", "plt.ylabel('AUC score')\n", "plt.xlabel('min samples leaf')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To fine tune the hyperparameters of the model, the ones used can be extracted as follows:" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'n_estimators': 100, 'max_depth': None, 'min_samples_split': 2, 'min_samples_leaf': 1}\n" ] } ], "source": [ "hp_dict = {\n", " 'n_estimators': rf.n_estimators,\n", " 'max_depth': rf.max_depth,\n", " 'min_samples_split': rf.min_samples_split,\n", " 'min_samples_leaf': rf.min_samples_leaf\n", "}\n", "\n", "print(hp_dict)" ] } ], "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.12.2" } }, "nbformat": 4, "nbformat_minor": 2 }