diff --git a/.ipynb_checkpoints/chp17_ModelInterpretation-checkpoint.ipynb b/.ipynb_checkpoints/chp17_ModelInterpretation-checkpoint.ipynb index 363fcab..b706d14 100644 --- a/.ipynb_checkpoints/chp17_ModelInterpretation-checkpoint.ipynb +++ b/.ipynb_checkpoints/chp17_ModelInterpretation-checkpoint.ipynb @@ -1,6 +1,3578 @@ { - "cells": [], - "metadata": {}, + "cells": [ + { + "cell_type": "markdown", + "id": "375766d2-b798-4b29-9fdf-158075519d67", + "metadata": {}, + "source": [ + "`White box` models are transparent and interpretable, meaning that their workings are completely understood and can be explained in terms of the input features and mathematical operations used to make predictions. \n", + "\n", + "`Black box` models, on the other hand, are not transparent or interpretable, meaning that their workings are not easily understood and it is difficult to explain how they make predictions. \n", + "\n", + "Decision tree models are white box models while XGBoost models are considered black box models. \n", + "\n", + "## 17.1 Logistic Regression Interpretation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6a078be8-e798-4fb4-a67b-6425e60cf40b", + "metadata": {}, + "outputs": [], + "source": [ + "import dtreeviz\n", + "from feature_engine import encoding, imputation\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn import base, compose, datasets, ensemble, metrics, model_selection, pipeline, preprocessing, tree\n", + "import scikitplot\n", + "import xgboost as xgb\n", + "import yellowbrick.model_selection as ms\n", + "from yellowbrick import classifier\n", + "import urllib\n", + "import zipfile\n", + "from hyperopt import fmin, tpe, hp, Trials\n", + "from EffectiveXGBoost import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5c581eaf-ffba-4d07-82f1-b85f7344dc69", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "G:\\My Drive\\SisengAI\\AlgorithmicTrading\\code_rebuilding\\MattHarrison\\EffectiveXGBoost\\EffectiveXGBoost_MyTake\\EffectiveXGBoost.py:62: DtypeWarning: Columns (0,2,8,10,21,23,24,25,26,27,28,44,56,64,83,85,87,107,109,123,125,150,157,172,174,194,210,218,219,223,246,249,262,264,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,304,306,325,326,329,341,368,371,384,385,389,390,391,393,394) have mixed types. Specify dtype option on import or set low_memory=False.\n" + ] + }, + { + "data": { + "text/html": [ + "
XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n",
+       "              colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n",
+       "              early_stopping_rounds=None, enable_categorical=False,\n",
+       "              eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n",
+       "              importance_type=None, interaction_constraints='',\n",
+       "              learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n",
+       "              max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n",
+       "              missing=nan, monotone_constraints='()', n_estimators=100,\n",
+       "              n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n",
+       "              reg_alpha=0, reg_lambda=1, ...)
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": [ + "XGBClassifier(base_score=0.5, booster='gbtree', callbacks=None,\n", + " colsample_bylevel=1, colsample_bynode=1, colsample_bytree=1,\n", + " early_stopping_rounds=None, enable_categorical=False,\n", + " eval_metric=None, gamma=0, gpu_id=-1, grow_policy='depthwise',\n", + " importance_type=None, interaction_constraints='',\n", + " learning_rate=0.300000012, max_bin=256, max_cat_to_onehot=4,\n", + " max_delta_step=0, max_depth=6, max_leaves=0, min_child_weight=1,\n", + " missing=nan, monotone_constraints='()', n_estimators=100,\n", + " n_jobs=0, num_parallel_tree=1, predictor='auto', random_state=0,\n", + " reg_alpha=0, reg_lambda=1, ...)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "path_url = 'https://github.com/mattharrison/datasets/raw/master/data/kaggle-survey-2018.zip'\n", + "file_name = 'kaggle-survey-2018.zip'\n", + "dataset = 'multipleChoiceResponses.csv'\n", + "\n", + "raw = extract_dataset(path_url, file_name, dataset)\n", + "\n", + "# Create raw X and raw y\n", + "kag_X, kag_y = prepX_y(raw, 'Q6')\n", + "\n", + "# Split data\n", + "kag_X_train, kag_X_test, kag_y_train, kag_y_test = (model_selection\n", + " .train_test_split(kag_X, \n", + " kag_y, \n", + " test_size=.3, \n", + " random_state=42, \n", + " stratify=kag_y)\n", + " )\n", + "\n", + "\n", + "# Transform X with pipeline\n", + "pline = pipeline.Pipeline(\n", + " [('tweak', PrepDataTransformer()),\n", + " ('cat', encoding.OneHotEncoder(top_categories=5, drop_last=True,\n", + " variables=['Q1', 'Q3', 'major'])),\n", + " ('num_impute', imputation.MeanMedianImputer(imputation_method='median',\n", + " variables=['education', 'years_exp']))]\n", + " )\n", + "\n", + "X_train = pline.fit_transform(kag_X_train)\n", + "X_test = pline.transform(kag_X_test)\n", + "\n", + "# Transform y with label encoder\n", + "label_encoder = preprocessing.LabelEncoder()\n", + "label_encoder.fit(kag_y_train)\n", + "y_train = label_encoder.transform(kag_y_train)\n", + "y_test = label_encoder.transform(kag_y_test)\n", + "\n", + "# Combined Data for cross validation/etc\n", + "X = pd.concat([X_train, X_test], axis='index')\n", + "y = pd.Series([*y_train, *y_test], index=X.index)\n", + "\n", + "# Default training\n", + "xg = xgb.XGBClassifier()\n", + "xg.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4adb845e-45b1-4c65-a986-1a5f8faa9668", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7337016574585635" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import linear_model, preprocessing\n", + "std = preprocessing.StandardScaler()\n", + "lr = linear_model.LogisticRegression(penalty='none')\n", + "lr.fit(std.fit_transform(X_train), y_train)\n", + "lr.score(std.transform(X_test), y_test)" + ] + }, + { + "cell_type": "markdown", + "id": "076c7d39-5f33-481e-a6b8-f40397e6fe1b", + "metadata": {}, + "source": [ + "Seems like the logistic regression gave similar results as the xgboost model. We would use the simpler model instead. Let us look more closely at the weights of the model using the `'.coef_'`attribute. Following scikit learn’s convention of adding an\n", + "underscore to the attribute learned while training the model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "52d900fc-1061-4513-8af4-525d78434671", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1.59051061e-01, -4.02827023e-01, 6.06203075e-01,\n", + " -1.45922113e-01, -8.12626418e-02, -6.05916337e-01,\n", + " 3.18051156e-02, 3.15043497e-02, -3.13556662e-02,\n", + " -4.75174987e-04, -8.04790381e-03, -5.22558905e-02,\n", + " -5.08749356e-03, 1.01987638e-01, 3.50075802e-01,\n", + " -1.79333801e-01, 2.44937585e-02, -3.38714464e-01]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "051e217f-914b-4845-9e3d-77b41a2b2c59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "\n", + "(pd.Series(lr.coef_[0], index=X_train.columns)\n", + ".sort_values()\n", + ".plot.barh(ax=ax)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2b51f56c-55b6-4db8-b2ac-2bc6d04194b0", + "metadata": {}, + "source": [ + "The wider the bar, the higher the impact of the feature. Positive values push towards\n", + "the positive label (or Software Engineer). Negative labels push towards the negative\n", + "label (or Data Scientist). The 'years_exp' (years of experience) column correlates with software engineering,\n", + "and using the R language (found in the 'r' column) correlates with data science. Also, the 'Q1_Prefer not to say' feature\n", + "does not have much impact on this model.\n", + "\n", + "Maybe we should make an even simpler model that only considers features that have an _absolute_ value above 0.2.\n", + "\n", + "## 17.2 Decision Tree Interpretation\n", + "\n", + "Another white box model. Let us train one with a depth of 7." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a7d09b59-6b6e-4bda-92e9-7fdf9c95aec2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.7337016574585635" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree7 = tree.DecisionTreeClassifier(max_depth=7)\n", + "tree7.fit(X_train, y_train)\n", + "tree7.score(X_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d1c4c0d1-63b8-4f61-8d39-046ec38adae7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.05822293, 0.09703777, 0.16172175, 0.08914157, 0.00303678,\n", + " 0.28834526, 0.01570148, 0.00530231, 0.00684056, 0.00372007,\n", + " 0. , 0.05648182, 0.00414392, 0.0060086 , 0.17292726,\n", + " 0.00133682, 0.01253835, 0.01749275])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tree7.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "24e5df60-d1c7-42df-8e45-21d56acd4cdb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "\n", + "_=(pd.Series(tree7.feature_importances_, index=X_train.columns)\n", + ".sort_values()\n", + ".plot.barh(ax=ax)\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ffded519-2464-4043-8414-5ef46a5d1f02", + "metadata": {}, + "source": [ + "Seems like in this case the feature importances of the decision tree are not necessarily\n", + "the same as the coefficients of the logistic regression model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "95187d35-645d-4095-9f02-ae35eda56406", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\ricky\\miniconda3\\lib\\site-packages\\sklearn\\base.py:450: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "G\n", + "\n", + "\n", + "cluster_legend\n", + "\n", + "\n", + "\n", + "node2\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:04.911566\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \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", + "node5\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.073574\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + "leaf3\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.007560\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node2->leaf3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf4\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.057286\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node2->leaf4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf6\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.106513\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node5->leaf6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf7\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.164217\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node5->leaf7\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node1\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.229903\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + "node1->node2\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node1->node5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node8\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.717206\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + "\n", + "node9\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.390078\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + " \n", + " \n", + "\n", + "\n", + "\n", + "node12\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.552468\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + "\n", + "\n", + "\n", + "leaf10\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.317563\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node9->leaf10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf11\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.368712\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node9->leaf11\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf13\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.419276\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node12->leaf13\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "leaf14\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:06.469026\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "node12->leaf14\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node8->node9\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node8->node12\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "node0\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:05.890345\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + " \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", + " \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", + " \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", + "node0->node1\n", + "\n", + "\n", + "  ≤\n", + "\n", + "\n", + "\n", + "node0->node8\n", + "\n", + "\n", + "  >\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "legend\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2023-04-28T09:03:04.512600\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.5.1, https://matplotlib.org/\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", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#import dtreeviz\n", + "dt3 = tree.DecisionTreeClassifier(max_depth=3)\n", + "dt3.fit(X_train, y_train)\n", + "viz = dtreeviz.model(dt3, X_train=X_train, y_train=y_train,\n", + "feature_names=list(X_train.columns), target_name='Job',\n", + "class_names=['DS', 'SE'])\n", + "viz.view()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ee2a2cbe-75a0-4aa2-bd7c-e44f4ed9a810", + "metadata": {}, + "source": [ + "## 17.3 XGBoost Feature Importance" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f8620676-5fe4-44ac-9954-cdfb520dd79d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xgb_def = xgb.XGBClassifier()\n", + "xgb_def.fit(X_train, y_train)\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "\n", + "_=(pd.Series(xgb_def.feature_importances_, index=X_train.columns)\n", + ".sort_values()\n", + ".plot.barh(ax=ax)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8cb3801a-cddb-4524-b21c-9498fca7f293", + "metadata": {}, + "source": [ + "XGBoost models using the `.plot_importance` method. This method has an `importance_type` parameter that allows you to change how importance is measured. The different types of feature importance are:\n", + "\n", + "- **Gain**: This measures the total gain in the model's performance that results from using a feature. It is calculated as the average gain of splits that use the feature.\n", + "- **Weight**: This measures the number of times a feature is used in the model. It is calculated as the number of times a feature is used to split the data across all trees.\n", + "- **Cover**: This measures the number of samples that are affected by a feature. It is calculated as the average coverage of splits that use the feature.\n", + "\n", + "These different types of feature importance provide different perspectives on the importance of features in an XGBoost model." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "88febc50-9433-4646-afd0-d4a160a6b857", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 4))\n", + "_=xgb.plot_importance(xgb_def, importance_type='cover', ax=ax)" + ] + }, + { + "cell_type": "markdown", + "id": "64750505-3455-42ca-a7f6-a24b99604ee6", + "metadata": {}, + "source": [ + "## 17.4 Surrogate Models\n", + "\n", + "Another way to tease apart the XGBoost model is to train a decision tree to its predictions and\n", + "then explore the interpretable decision tree. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bfb91913-29fb-4186-a80f-9f7aa2d4042c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
DecisionTreeRegressor(max_depth=4)
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": [ + "DecisionTreeRegressor(max_depth=4)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import tree\n", + "sur_reg_sk = tree.DecisionTreeRegressor(max_depth=4)\n", + "sur_reg_sk.fit(X_train, xgb_def.predict_proba(X_train)[:,-1])" + ] + }, + { + "cell_type": "markdown", + "id": "30be8053-b8ca-47de-86c3-0b4f17ad572f", + "metadata": {}, + "source": [ + "We are going to export the tree to examine it. using the `export_graphviz` function so the image goes from left to right. We will convert the `.dot `file to a `.png` before generating it." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "257d5fde-96de-4954-8f8d-7a04c25af211", + "metadata": {}, + "outputs": [], + "source": [ + "# to convert DOT to PNG\n", + "tree.export_graphviz(sur_reg_sk, \n", + " out_file='img/sur-sk.dot',\n", + " feature_names=X_train.columns, \n", + " filled=True, rotate=True,fontname='Roboto Condensed')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "12261bfe-d3eb-415a-9f6b-e4e951e4dcc8", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "cannot assign to operator (3541661493.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Input \u001b[1;32mIn [22]\u001b[1;36m\u001b[0m\n\u001b[1;33m dot -Gdpi=300 -Tpng -oimg/sur-sk.png img/sur-sk.dot # HIDE\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to operator\n" + ] + } + ], + "source": [ + "dot -Gdpi=300 -Tpng -oimg/sur-sk.png img/sur-sk.dot # HIDE" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "44f4572d-bb25-4f32-b773-42edf58d5e08", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (4146176678.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[1;36m Input \u001b[1;32mIn [21]\u001b[1;36m\u001b[0m\n\u001b[1;33m dot -Tpng img/sur-sk.dot -o img/sur-sk.png\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "dot -Tpng img/sur-sk.dot -o img/sur-sk.png" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "cbb93ac6-305e-4abe-ab67-d4d41aa539eb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "(dot.exe:27028): Pango-WARNING **: couldn't load font \"Roboto Condensed Not-Rotated 14\", falling back to \"Sans Condensed Not-Rotated 14\", expect ugly output.\n", + "\n", + "(dot.exe:27028): Pango-WARNING **: couldn't load font \"Sans Condensed Not-Rotated 14\", falling back to \"Sans Not-Rotated 14\", expect ugly output.\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Tree\n", + "\n", + "\n", + "\n", + "0\n", + "\n", + "r <= 0.5\n", + "squared_error = 0.121\n", + "samples = 2110\n", + "value = 0.454\n", + "\n", + "\n", + "\n", + "1\n", + "\n", + "major_cs <= 0.5\n", + "squared_error = 0.103\n", + "samples = 1484\n", + "value = 0.559\n", + "\n", + "\n", + "\n", + "0->1\n", + "\n", + "\n", + "True\n", + "\n", + "\n", + "\n", + "16\n", + "\n", + "major_cs <= 0.5\n", + "squared_error = 0.074\n", + "samples = 626\n", + "value = 0.203\n", + "\n", + "\n", + "\n", + "0->16\n", + "\n", + "\n", + "False\n", + "\n", + "\n", + "\n", + "2\n", + "\n", + "Q3_United States of America <= 0.5\n", + "squared_error = 0.115\n", + "samples = 718\n", + "value = 0.429\n", + "\n", + "\n", + "\n", + "1->2\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "9\n", + "\n", + "years_exp <= 3.5\n", + "squared_error = 0.061\n", + "samples = 766\n", + "value = 0.681\n", + "\n", + "\n", + "\n", + "1->9\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "3\n", + "\n", + "major_stat <= 0.5\n", + "squared_error = 0.086\n", + "samples = 322\n", + "value = 0.564\n", + "\n", + "\n", + "\n", + "2->3\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "6\n", + "\n", + "years_exp <= 4.5\n", + "squared_error = 0.111\n", + "samples = 396\n", + "value = 0.319\n", + "\n", + "\n", + "\n", + "2->6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "4\n", + "\n", + "squared_error = 0.072\n", + "samples = 285\n", + "value = 0.603\n", + "\n", + "\n", + "\n", + "3->4\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "5\n", + "\n", + "squared_error = 0.098\n", + "samples = 37\n", + "value = 0.265\n", + "\n", + "\n", + "\n", + "3->5\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "7\n", + "\n", + "squared_error = 0.071\n", + "samples = 294\n", + "value = 0.237\n", + "\n", + "\n", + "\n", + "6->7\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "8\n", + "\n", + "squared_error = 0.153\n", + "samples = 102\n", + "value = 0.554\n", + "\n", + "\n", + "\n", + "6->8\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "10\n", + "\n", + "age <= 27.5\n", + "squared_error = 0.052\n", + "samples = 525\n", + "value = 0.625\n", + "\n", + "\n", + "\n", + "9->10\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "13\n", + "\n", + "education <= 17.0\n", + "squared_error = 0.057\n", + "samples = 241\n", + "value = 0.803\n", + "\n", + "\n", + "\n", + "9->13\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "11\n", + "\n", + "squared_error = 0.041\n", + "samples = 460\n", + "value = 0.65\n", + "\n", + "\n", + "\n", + "10->11\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "12\n", + "\n", + "squared_error = 0.1\n", + "samples = 65\n", + "value = 0.453\n", + "\n", + "\n", + "\n", + "10->12\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "14\n", + "\n", + "squared_error = 0.027\n", + "samples = 113\n", + "value = 0.885\n", + "\n", + "\n", + "\n", + "13->14\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "15\n", + "\n", + "squared_error = 0.072\n", + "samples = 128\n", + "value = 0.73\n", + "\n", + "\n", + "\n", + "13->15\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "17\n", + "\n", + "years_exp <= 7.5\n", + "squared_error = 0.043\n", + "samples = 443\n", + "value = 0.123\n", + "\n", + "\n", + "\n", + "16->17\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "24\n", + "\n", + "years_exp <= 4.5\n", + "squared_error = 0.096\n", + "samples = 183\n", + "value = 0.397\n", + "\n", + "\n", + "\n", + "16->24\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "18\n", + "\n", + "education <= 14.5\n", + "squared_error = 0.03\n", + "samples = 382\n", + "value = 0.105\n", + "\n", + "\n", + "\n", + "17->18\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "21\n", + "\n", + "education <= 19.5\n", + "squared_error = 0.11\n", + "samples = 61\n", + "value = 0.236\n", + "\n", + "\n", + "\n", + "17->21\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "19\n", + "\n", + "squared_error = 0.0\n", + "samples = 1\n", + "value = 0.873\n", + "\n", + "\n", + "\n", + "18->19\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "20\n", + "\n", + "squared_error = 0.029\n", + "samples = 381\n", + "value = 0.103\n", + "\n", + "\n", + "\n", + "18->20\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "22\n", + "\n", + "squared_error = 0.133\n", + "samples = 40\n", + "value = 0.32\n", + "\n", + "\n", + "\n", + "21->22\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "23\n", + "\n", + "squared_error = 0.027\n", + "samples = 21\n", + "value = 0.074\n", + "\n", + "\n", + "\n", + "21->23\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "25\n", + "\n", + "education <= 17.0\n", + "squared_error = 0.071\n", + "samples = 144\n", + "value = 0.34\n", + "\n", + "\n", + "\n", + "24->25\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "28\n", + "\n", + "education <= 17.0\n", + "squared_error = 0.131\n", + "samples = 39\n", + "value = 0.609\n", + "\n", + "\n", + "\n", + "24->28\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "26\n", + "\n", + "squared_error = 0.061\n", + "samples = 69\n", + "value = 0.43\n", + "\n", + "\n", + "\n", + "25->26\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "27\n", + "\n", + "squared_error = 0.066\n", + "samples = 75\n", + "value = 0.257\n", + "\n", + "\n", + "\n", + "25->27\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "29\n", + "\n", + "squared_error = 0.035\n", + "samples = 13\n", + "value = 0.862\n", + "\n", + "\n", + "\n", + "28->29\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "30\n", + "\n", + "squared_error = 0.131\n", + "samples = 26\n", + "value = 0.482\n", + "\n", + "\n", + "\n", + "28->30\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import graphviz\n", + "# Load the DOT file\n", + "with open('img/sur-sk.dot') as f:\n", + " dot_graph = f.read()\n", + "\n", + "# Create a graph from the DOT data\n", + "graph = graphviz.Source(dot_graph)\n", + "\n", + "# Display the graph in the Jupyter notebook\n", + "graph\n" + ] + }, + { + "cell_type": "markdown", + "id": "db6a3fc0-52d0-4e75-b0fe-5d37a22d997d", + "metadata": {}, + "source": [ + "The warnings you're seeing indicate that the `dot` command-line tool from Graphviz is unable to find the specified font (\"Roboto Condensed\") on your system. As a result, it's falling back to a default font (\"Sans\"), which may result in suboptimal output.\n", + "\n", + "To fix this issue, you can try installing the \"Roboto Condensed\" font on your system. The process for doing this varies depending on your operating system. On Windows, you can download the font from the Google Fonts website (https://fonts.google.com/specimen/Roboto+Condensed) and then double-click the downloaded file to install it. On macOS, you can use the Font Book application to install the font. On Linux, the process varies depending on your distribution and desktop environment.\n", + "\n", + "Alternatively, you can modify the code that generates the DOT file to use a different font that is already installed on your system. For example, you can change the `fontname` parameter of the `export_graphviz` function to specify a different font:\n", + "\n", + "```python\n", + "tree.export_graphviz(sur_reg_sk, out_file='img/sur-sk.dot',\n", + " feature_names=X_train.columns, filled=True,\n", + " rotate=True, fontname='Arial')\n", + "```\n", + "\n", + "This will generate a DOT file that uses the \"Arial\" font instead of \"Roboto Condensed\". You can then use the `dot` command-line tool or the `graphviz` Python library to generate an image from the DOT file as described in my previous responses.\n", + "\n", + "## Summary\n", + "\n", + "\n", + "1. **What is the difference between white box and black box models regarding interpretation?**\n", + " - White box models are interpretable, meaning that their internal workings and decision-making processes can be easily understood and explained.\n", + " - Black box models, on the other hand, are more opaque and their decision-making processes are not as easily understood or explained.\n", + " - This means that white box models are generally easier to interpret and understand than black box models.\n", + "\n", + "2. **How is logistic regression used to make predictions and how can the coefficients be interpreted to understand the model’s decision-making process?**\n", + " - Logistic regression is a type of generalized linear model that is used for binary classification problems.\n", + " - The model makes predictions by calculating a weighted sum of the input features and passing the result through a sigmoid function to produce a probability value between 0 and 1.\n", + " - The coefficients of the logistic regression model represent the importance of each feature in making predictions. A positive coefficient indicates that an increase in the value of that feature increases the probability of a positive outcome, while a negative coefficient indicates that an increase in the value of that feature decreases the probability of a positive outcome.\n", + "\n", + "3. **How can decision trees be interpreted, and how do they visualize the model’s decision-making process?**\n", + " - Decision trees are a type of white box model that can be easily interpreted and visualized.\n", + " - The tree structure represents the decision-making process of the model, with each node representing a test on a feature and each branch representing an outcome of that test.\n", + " - By following the branches of the tree from the root to a leaf node, one can see how the model makes decisions based on the values of the input features.\n", + "\n", + "4. **What are some potential limitations of using interpretation techniques to understand the decision-making process of a machine learning model?**\n", + " - Interpretation techniques can provide valuable insights into how a machine learning model makes decisions, but they are not always perfect and may have limitations.\n", + " - For example, some interpretation techniques may only provide an approximate or partial understanding of the model's decision-making process.\n", + " - Additionally, interpretation techniques may not always be applicable or effective for all types of models or datasets.\n", + "\n", + "5. **How can the feature importance attribute be used to interpret the decision-making process of a black box model?**\n", + " - Feature importance is a measure of how much each feature contributes to making predictions with a machine learning model.\n", + " - For black box models, feature importance can provide some insight into which features are most important for making predictions.\n", + " - However, it's important to note that feature importance does not provide a complete understanding of how the model makes decisions and should be used in conjunction with other interpretation techniques.\n", + "\n", + "6. **In what situations might it be more appropriate to use a white box model over a black box model, and vice versa?**\n", + " - White box models may be more appropriate in situations where interpretability and explainability are important. For example, in regulated industries or when making decisions that have significant consequences for individuals or society.\n", + " - Black box models may be more appropriate in situations where predictive performance is more important than interpretability. For example, when making predictions in complex domains where it may be difficult to build an interpretable model with high accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fff02e4-0a9e-4a11-8116-d28e6cca688b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, "nbformat": 4, "nbformat_minor": 5 } diff --git a/chp17_ModelInterpretation.ipynb b/chp17_ModelInterpretation.ipynb index eb06abc..b706d14 100644 --- a/chp17_ModelInterpretation.ipynb +++ b/chp17_ModelInterpretation.ipynb @@ -3510,7 +3510,39 @@ " rotate=True, fontname='Arial')\n", "```\n", "\n", - "This will generate a DOT file that uses the \"Arial\" font instead of \"Roboto Condensed\". You can then use the `dot` command-line tool or the `graphviz` Python library to generate an image from the DOT file as described in my previous responses." + "This will generate a DOT file that uses the \"Arial\" font instead of \"Roboto Condensed\". You can then use the `dot` command-line tool or the `graphviz` Python library to generate an image from the DOT file as described in my previous responses.\n", + "\n", + "## Summary\n", + "\n", + "\n", + "1. **What is the difference between white box and black box models regarding interpretation?**\n", + " - White box models are interpretable, meaning that their internal workings and decision-making processes can be easily understood and explained.\n", + " - Black box models, on the other hand, are more opaque and their decision-making processes are not as easily understood or explained.\n", + " - This means that white box models are generally easier to interpret and understand than black box models.\n", + "\n", + "2. **How is logistic regression used to make predictions and how can the coefficients be interpreted to understand the model’s decision-making process?**\n", + " - Logistic regression is a type of generalized linear model that is used for binary classification problems.\n", + " - The model makes predictions by calculating a weighted sum of the input features and passing the result through a sigmoid function to produce a probability value between 0 and 1.\n", + " - The coefficients of the logistic regression model represent the importance of each feature in making predictions. A positive coefficient indicates that an increase in the value of that feature increases the probability of a positive outcome, while a negative coefficient indicates that an increase in the value of that feature decreases the probability of a positive outcome.\n", + "\n", + "3. **How can decision trees be interpreted, and how do they visualize the model’s decision-making process?**\n", + " - Decision trees are a type of white box model that can be easily interpreted and visualized.\n", + " - The tree structure represents the decision-making process of the model, with each node representing a test on a feature and each branch representing an outcome of that test.\n", + " - By following the branches of the tree from the root to a leaf node, one can see how the model makes decisions based on the values of the input features.\n", + "\n", + "4. **What are some potential limitations of using interpretation techniques to understand the decision-making process of a machine learning model?**\n", + " - Interpretation techniques can provide valuable insights into how a machine learning model makes decisions, but they are not always perfect and may have limitations.\n", + " - For example, some interpretation techniques may only provide an approximate or partial understanding of the model's decision-making process.\n", + " - Additionally, interpretation techniques may not always be applicable or effective for all types of models or datasets.\n", + "\n", + "5. **How can the feature importance attribute be used to interpret the decision-making process of a black box model?**\n", + " - Feature importance is a measure of how much each feature contributes to making predictions with a machine learning model.\n", + " - For black box models, feature importance can provide some insight into which features are most important for making predictions.\n", + " - However, it's important to note that feature importance does not provide a complete understanding of how the model makes decisions and should be used in conjunction with other interpretation techniques.\n", + "\n", + "6. **In what situations might it be more appropriate to use a white box model over a black box model, and vice versa?**\n", + " - White box models may be more appropriate in situations where interpretability and explainability are important. For example, in regulated industries or when making decisions that have significant consequences for individuals or society.\n", + " - Black box models may be more appropriate in situations where predictive performance is more important than interpretability. For example, when making predictions in complex domains where it may be difficult to build an interpretable model with high accuracy." ] }, {