SHAP Values for Trees and Linear Models — The Attribution Roast

"If feature importance were a movie, SHAP would be the director's commentary — explaining not just who did what, but why the scene felt thrilling."

You already know about coefficient-based interpretation and permutation importance pitfalls from earlier in this module. Great — because SHAP sits between those worlds and then roasts both. Coefficients give you a global, linear story. Permutation importance gives you a quick-and-dirty importance score that falls on its face with correlated features or fancy interactions. SHAP gives you consistent, additive, and local attributions rooted in game theory — and yes, it has mood swings that you must respect.

---

What is SHAP, really? Short version

• SHAP stands for SHapley Additive exPlanations. It adapts Shapley values from cooperative game theory to machine learning models.
• Intuition: treat the model prediction as the payout of a cooperative game. Each feature is a player who contributed to that payout. SHAP distributes the payout fairly among players based on their marginal contributions across all possible coalitions.
• Result: for any instance, you get per-feature contributions that add up to the difference between the model prediction and a baseline (expected prediction).

Why it matters: SHAP gives local explanations (per-instance) that can be aggregated to global insights, handles nonlinearity and interactions (depending on explainer), and offers an axiomatic foundation that beats the hand-wavy nature of permutation importance.

---

SHAP in two flavors: Trees vs Linear models

Tree SHAP (TreeExplainer)

• Designed for tree ensembles: random forests, XGBoost, LightGBM, CatBoost.
• Big win: computes exact Shapley values in polynomial time for tree models using dynamic programming. That means exact (under model determinism) attributions without exponential cost.
• Pros:
  • Fast and exact for tree ensembles.
  • Can optionally compute interaction values (which pairwise features interact and by how much).
• Cons:
  • Still sensitive to correlated features — Shapley treats feature presence/absence by marginalizing over unknowns, which may produce unintuitive splits if features are dependent.

Linear SHAP (LinearExplainer)

• For linear models, SHAP reduces to a simple decomposition: contribution = coefficient * feature value (after any preprocessing that matters), but with careful baseline handling.
• If the model is a plain linear regression with an intercept, SHAP attributions align with coefficients scaled by the feature values relative to the baseline.
• Pros:
  • Transparent and fast; aligns well with coefficient interpretation but adds the local baseline perspective.
• Cons:
  • If you have feature interactions or nonlinear preprocessing (polynomial features, splines, tree-based transformations), LinearExplainer is no longer appropriate.

---

Quick comparison table

Property	Coefficients	Permutation Importance	SHAP (Tree)	SHAP (Linear)
Local explanations	no	limited	yes	yes
Global summary	yes	yes	yes (aggregate)	yes
Handles interactions	no	no	yes	only if model has them
Robust to correlated features	no	no — breaks	improves interpretability but still nuanced	nuanced
Computational cost	low	medium-high	tree: low, others: high	low

---

Example: how SHAP looks in practice

Imagine a credit scoring model. Baseline default probability is 12%. For Alice, the model predicts 2%. SHAP might give:

• credit_score: -6% (pushed down from baseline)
• long_employment: -3%
• high_income: -5%

• many_recent_inquiries: +4%

These contributions sum to -10%, so 12% + (-10%) = 2% final prediction. That per-instance storytelling is what coefficients alone can't give.

---

Practical recipe: computing SHAP in a pipeline and tracking experiments

You already automated pipelines and experiment tracking. Good. Now add SHAP with reproducibility in mind.

1. Fit model inside your pipeline. Keep the trained model artifact.
2. Save preprocessing objects (scaler, encoder) too. SHAP must see the same feature space used by the model.
3. Use the right explainer: TreeExplainer for tree ensembles, LinearExplainer for pure linear models.
4. Persist SHAP values and summary plots as experiment artifacts (MLflow, DVC, or plain S3). Store the exact seed and library versions.

Example pseudocode (sketch):

# assume sklearn pipeline named pipe and X_train, X_test available
model = pipe.fit(X_train, y_train)
# get raw model for explainer if using wrappers
raw_model = pipe.named_steps['model']
import shap
explainer = shap.TreeExplainer(raw_model)  # or shap.LinearExplainer
shap_values = explainer.shap_values(X_test)
# save shap_values to artifact store
save_artifact('shap_values.npy', shap_values)
# log shap summary plot
shap.summary_plot(shap_values, X_test, show=False)
save_artifact('shap_summary.png')

Note: if your pipeline includes feature selection or complex transformers, run explainer on the transformed features space that the model actually consumes. Document the mapping from raw features to transformed features in the experiment log.

---

Pitfalls, caveats, and the parts where SHAP gets dramatic

• Correlated features: SHAP's marginalization can assign credit in ways that feel arbitrary when features are highly correlated. It follows the math, not what you'd intuitively insist is the "true cause".
• Baseline choice matters: SHAP explanations are relative to a baseline expectation. Different baselines change the story. Be explicit about it.
• Computational cost for non-tree models: Kernel SHAP is model-agnostic but can be slow and approximate. Prefer model-specific explainers when available.
• Feature engineering blindspots: If you feed encoded or interaction features, interpret SHAP in that transformed space — map back carefully if you want raw feature explanations.

Contrast with permutation importance pitfalls: permutation breaks feature relationships and can inflate importance for features that act as proxies. SHAP avoids random permutations but still needs careful interpretation when features co-vary.

---

Advanced goodness: interaction values and aggregation

• TreeExplainer can compute pairwise interaction values, revealing when two features jointly contribute more than the sum of their parts.
• You can aggregate SHAP values across many instances to get global importance, or plot dependence plots to visualize how feature value relates to contribution.

Use cases:

• Debugging a model that relies on a spurious proxy variable.
• Creating human-readable explanations for model outputs in a product.
• Auditing fairness by comparing average SHAP contributions across subgroups.

---

Closing: how SHAP fits into responsible AI workflows

SHAP is not a silver bullet, but it is a powerful, principled tool that complements coefficient interpretation and mitigates many permutation-importance blindspots. Use it to:

• Provide local explanations to end users and stakeholders.
• Diagnose unexpected model behavior during model tuning and ablation experiments.
• Audit models for fairness and feature leakage by tracking SHAP distributions across cohorts.

Final thought:

Coefficients tell you the script; permutation importance flips the set; SHAP gives you the director's cut with commentary, behind-the-scenes footage, and the blooper reel. Treat it like a director — listen, but don't worship. Validate, log, and question.

---

Key takeaways

• SHAP provides additive, local explanations grounded in Shapley values.
• Use TreeExplainer for tree ensembles for exact, fast attributions; use LinearExplainer for plain linear models.
• Always log preprocessing, explainer type, baseline, and SHAP artifacts in your experiment tracking system.
• Be cautious with correlated features and baseline choices — no explanation replaces domain knowledge and sanity checks.

Version note: if you liked coefficient interpretation and hated permutation importance's chaotic tendencies, SHAP will feel like a mature, slightly dramatic friend who tells you the truth — sometimes blunt, always useful.