Model interpretability (SHAP, LIME) in ML Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding SHAP values

Which statement best describes what SHAP values represent in model interpretability?

A SHAP values show how much each feature contributes to pushing the model output from the average prediction to the current prediction.

B SHAP values are the raw input features used to train the model.

C SHAP values are the predicted probabilities of the model for each class.

D SHAP values are the weights of the neurons in a neural network.

💡 Hint

Think about how SHAP explains individual predictions by comparing to a baseline.

SHAP values quantify the contribution of each feature to the difference between the model's average output and the specific prediction, helping to explain why the model made that prediction.

❓ Predict Output

intermediate

Output of LIME explanation code

What will be the output of the following Python code snippet using LIME for a binary classification model?

ML Python

import numpy as np
from sklearn.linear_model import LogisticRegression
from lime.lime_tabular import LimeTabularExplainer

X_train = np.array([[0,1],[1,1],[0,0],[1,0]])
y_train = np.array([0,1,0,1])
model = LogisticRegression().fit(X_train, y_train)

explainer = LimeTabularExplainer(X_train, feature_names=['f1','f2'], class_names=['class0','class1'], discretize_continuous=False)
exp = explainer.explain_instance(np.array([1,0]), model.predict_proba, num_features=2)
print(exp.as_list())

A [('f2 <= 0.5', 0.5), ('f1 > 0.5', 0.3)]

B [('f1', 0.5), ('f2', -0.1)]

C [('f1', 0.3), ('f2', 0.2)]

D [('f1 = 1', 0.4), ('f2 = 0', 0.6)]

💡 Hint

LIME returns feature contributions as tuples with feature name and weight.

LIME explains the prediction by showing feature contributions with weights. For input [1,0], 'f1' contributes positively around 0.5 and 'f2' slightly negatively.

❓ Model Choice

advanced

Choosing between SHAP and LIME

You want to explain predictions of a complex black-box model on tabular data with many features. Which method is best if you need consistent global and local explanations?

A Use LIME because it provides consistent global explanations for all features.

B Use LIME because it is faster and does not require retraining the model.

C Use SHAP because it provides consistent additive feature attributions for both local and global explanations.

D Use neither; use partial dependence plots instead.

💡 Hint

Consider which method has a solid theoretical foundation for consistent explanations.

SHAP values have a strong theoretical basis ensuring consistent additive explanations that can be aggregated for global insights, unlike LIME which is local and can vary.

❓ Hyperparameter

advanced

Effect of number of samples in LIME

In LIME, increasing the 'num_samples' parameter during explanation will most likely:

A Decrease explanation accuracy and increase speed.

B Cause the model to retrain on more data.

C Have no effect on explanation quality or speed.

D Increase explanation accuracy but increase computation time.

💡 Hint

Think about how sampling affects the local surrogate model fit.

More samples allow LIME to better approximate the local decision boundary, improving explanation accuracy but requiring more computation time.

🔧 Debug

expert

Debugging SHAP value computation error

You run SHAP's TreeExplainer on a scikit-learn RandomForestClassifier but get the error: 'ValueError: Model output type not supported'. What is the most likely cause?

A You used TreeExplainer on a model that is not tree-based.

B You passed a multi-output regression model instead of classification.

C You passed raw model predictions instead of probabilities to SHAP.

D You did not convert the input data to a numpy array.

💡 Hint

Check if the model type matches the explainer requirements.

TreeExplainer only supports tree-based models like RandomForest or XGBoost. Using it on non-tree models causes this error.

Practice

1. What is the main purpose of using SHAP or LIME in machine learning?

easy

A. To improve the speed of model training

B. To reduce the number of features in the dataset

C. To increase the size of the training dataset

D. To explain why a model made a specific prediction

Solution

1. Step 1: Understand model interpretability tools

   SHAP and LIME are designed to explain model predictions by showing feature importance.

2. Step 2: Identify their main use

   They help users understand why a model made a certain prediction, increasing trust.

3. Final Answer:

   To explain why a model made a specific prediction -> Option D

4. Quick Check:

   Interpretability = Explanation [OK]

Hint: SHAP and LIME explain predictions, not speed or data size [OK]

Common Mistakes:

• Confusing interpretability with model training speed
• Thinking SHAP/LIME reduce dataset size
• Assuming they automatically improve model accuracy

2. Which of the following is the correct way to import the SHAP library in Python?

easy

A. from shap import explain

B. import SHAP

C. import shap

D. import SHAP as sp

Solution

1. Step 1: Recall Python import syntax

   Python imports are case-sensitive; the SHAP library is lowercase 'shap'.

2. Step 2: Check each option

   import shap uses correct lowercase import. import SHAP uses uppercase which is invalid. from shap import explain tries to import a non-existent module 'explain'. import SHAP as sp uses uppercase which is invalid.

3. Final Answer:

   import shap -> Option C

4. Quick Check:

   Python imports are case-sensitive [OK]

Hint: Python imports match exact package name in lowercase [OK]

Common Mistakes:

• Using uppercase letters in import statements
• Importing non-existent submodules
• Using uncommon aliases without explanation

3. Given the following Python code using LIME, what will exp.as_list() return?

import lime.lime_tabular
explainer = lime.lime_tabular.LimeTabularExplainer(training_data, feature_names=features)
exp = explainer.explain_instance(test_instance, model.predict_proba)
print(exp.as_list())

medium

A. A list of tuples showing feature names and their importance scores for the test instance

B. The predicted class label for the test instance

C. The training data used to build the explainer

D. A plot object visualizing the model's decision

Solution

1. Step 1: Understand LIME explanation output

   The explain_instance method returns an explanation object. Calling as_list() gives feature importance as a list of (feature, weight) tuples.

2. Step 2: Match output to options

   A list of tuples showing feature names and their importance scores for the test instance correctly describes this list. The predicted class label for the test instance is the predicted label, which as_list() does not return. The training data used to build the explainer is training data, unrelated here. A plot object visualizing the model's decision is a plot, which requires a different method.

3. Final Answer:

   A list of tuples showing feature names and their importance scores for the test instance -> Option A

4. Quick Check:

   LIME explanation list = feature importance [OK]

Hint: LIME's as_list() shows feature importance tuples [OK]

Common Mistakes:

• Confusing explanation list with predicted label
• Expecting training data from explanation
• Thinking as_list() returns a plot

4. You run SHAP on a model but get an error: AttributeError: 'TreeExplainer' object has no attribute 'shap_values'. What is the likely cause?

medium

A. You used an outdated SHAP version missing the shap_values method

B. The model is not a tree-based model supported by TreeExplainer

C. You forgot to import the SHAP library

D. The input data is missing feature names

Solution

1. Step 1: Understand TreeExplainer requirements

   TreeExplainer works only with tree-based models like XGBoost or LightGBM. Using it on unsupported models causes attribute errors.

2. Step 2: Analyze error cause

   The error suggests the method shap_values is missing, likely because the model type is unsupported by TreeExplainer.

3. Final Answer:

   The model is not a tree-based model supported by TreeExplainer -> Option B

4. Quick Check:

   TreeExplainer needs tree models [OK]

Hint: TreeExplainer only supports tree models, else error occurs [OK]

Common Mistakes:

• Assuming missing import causes this error
• Blaming outdated SHAP version without checking model type
• Ignoring model compatibility with explainer

5. You want to explain predictions of a complex neural network on tabular data. Which approach best combines SHAP and LIME to get both global and local interpretability?

hard

A. Use SHAP's DeepExplainer for global feature importance and LIME for local explanations on individual samples

B. Use LIME only, as SHAP does not support neural networks

C. Use SHAP's TreeExplainer for local explanations and LIME for global explanations

D. Use neither; neural networks cannot be interpreted

Solution

1. Step 1: Identify SHAP and LIME strengths

   SHAP's DeepExplainer supports neural networks and provides global feature importance. LIME excels at explaining individual predictions locally.

2. Step 2: Combine for best interpretability

   Using SHAP for global insights and LIME for local explanations gives a full understanding of model behavior.

3. Final Answer:

   Use SHAP's DeepExplainer for global feature importance and LIME for local explanations on individual samples -> Option A

4. Quick Check:

   SHAP global + LIME local = best combo [OK]

Hint: SHAP global + LIME local = full interpretability [OK]

Common Mistakes:

• Thinking SHAP does not support neural networks
• Confusing TreeExplainer with DeepExplainer
• Believing neural networks cannot be interpreted