Interpretability

Interpretability#

“Explainable AI” is just AI that won’t make you sweat when the CEO asks, “So… why did it reject our top customer?”

🕵️‍♂️ The Great Mystery of Black Boxes#

Most machine learning models are like teenagers:

  • They do things.

  • They won’t tell you why.

  • And when you press them, they mumble something about “nonlinearities” and leave.

Interpretability helps you shine a light into that black box so you can:

  • Build trust (“No, Karen, the model isn’t biased against people named Karen.”)

  • Debug decisions (“Oh, it thought age 999 was valid. Cool.”)

  • Stay compliant (because regulators really don’t like mysterious math.)

🧰 1. Feature Importance: Who Wore It Best?#

The OG method — just ask the model which features mattered most.

🪄 Scikit-learn Style#

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier().fit(X_train, y_train)
feat_importances = pd.Series(model.feature_importances_, index=X_train.columns)
feat_importances.nlargest(10).plot(kind='barh')
plt.title("Top 10 Important Features")
plt.show()

🎯 Use this when:

  • You have tabular data

  • You’re OK with “importance” meaning “correlation-ish magic”

🔍 2. SHAP – The Philosopher of Machine Learning#

SHAP (SHapley Additive exPlanations) answers:

“How much did each feature contribute to this specific prediction?”

It’s like credit assignment in a group project, except now the math is fair, and the lazy feature doesn’t get all the glory.

import shap

explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test)

💬 Interpretation: Each feature gets a “vote” on the prediction — positive or negative — with the magnitude showing how loud that vote was.

💡 3. LIME – “Explain This One, Please”#

LIME (Local Interpretable Model-agnostic Explanations) builds a tiny, simple model around one prediction so you can explain that particular decision without unboxing the entire monster.

Example:

from lime.lime_tabular import LimeTabularExplainer

explainer = LimeTabularExplainer(X_train.values, feature_names=X_train.columns)
exp = explainer.explain_instance(X_test.iloc[0].values, model.predict_proba)
exp.show_in_notebook()

🧠 Great for:

  • Explaining one weird case

  • Looking smart in Jupyter notebooks during demos

🪞 4. Partial Dependence Plots – “What Happens If…”#

Think of PDPs as “What if?” charts:

  • “What if the customer’s income increased?”

  • “What if we gave everyone free shipping?”

They show how changing one feature affects predictions — assuming all else stays the same (which, of course, it never does).

from sklearn.inspection import plot_partial_dependence
plot_partial_dependence(model, X_train, ['income', 'age'])

🧠 5. Counterfactuals – “What Would Change the Prediction?”#

Counterfactual explanations answer:

“What’s the smallest change that would flip this decision?”

For example:

  • “If the customer’s balance was $300 higher, they wouldn’t churn.”

  • “If the applicant waited two years, their loan would be approved.”

You can use libraries like Alibi or DiCE to generate these.

📊 6. Global vs Local Interpretability#

Type

What It Explains

Example

Global

Model behavior overall

Feature importance, PDPs

Local

One specific prediction

SHAP, LIME, Counterfactuals

Think of it like:

  • Global = “Why are humans generally bad at parallel parking?”

  • Local = “Why did you just hit that cone?”

⚖️ 7. Ethics & Bias Auditing#

Interpretability isn’t just about cool charts — it’s also about fairness. Use Fairlearn, Aequitas, or Evidently AI to audit bias and equity metrics.

Because nothing ruins a product launch like discovering your AI is racist after it goes live. 😬

🧩 8. Tool Belt Summary#

Goal

Tool

Notes

Global importance

feature_importances_, SHAP summary

For overall model insights

Local explanation

SHAP, LIME

For specific decisions

Scenario simulation

PDP, ICE plots

For business “what if”s

Bias check

Fairlearn, Aequitas

For peace of mind and legal survival

🤹 Final Thoughts#

Interpretability is like parenting an AI model:

  • You love it.

  • You guide it.

  • And when it says something stupid, you’d better be able to explain why.

# Your code here
Contents