Decision Trees and Rule Lists in Explainable AI (XAI)

The Big Question — Why Does Explainability Matter?

Explainable AI (XAI) is the field of building machine learning systems whose predictions can be understood, audited, and trusted by human beings — not just measured. It sits at the intersection of data science, ethics, law, and cognitive psychology.

The XAI Landscape — Where Decision Trees Live

XAI methods fall into two broad camps: models that are intrinsically interpretable (transparent by design), and post-hoc explanation methods that try to shed light on opaque models after training.

Decision Trees — The Anatomy of Interpretability

A Decision Tree is a hierarchical model that partitions the feature space through a sequence of binary splits. Each internal node tests one feature against one threshold. Each leaf node contains a prediction. The path from root to leaf is the explanation.

The tree above encodes the following human-readable rules that a loan officer could verify in seconds:

How Trees Learn — Splitting Criteria

The heart of decision tree learning is the split selection function. At every internal node, the algorithm searches over all features and all thresholds to find the split that produces the purest child nodes. The three most important measures of impurity are:

The Interpretability–Accuracy Trade-off & Pruning

Two main approaches control tree complexity and restore generalisability:

Decision Tree in Python — Full Worked Example

The following example trains an interpretable decision tree on the UCI Heart Disease dataset, applies post-pruning via ccp_alpha, and visualises the tree. Notice how every parameter is chosen with interpretability as the priority.

# ── Decision Tree for Heart Disease Prediction ────────────────
# Goal: maximum interpretability, not maximum accuracy

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt

# 1. Load data
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3. Find optimal ccp_alpha via cross-validation post-pruning
raw_tree = DecisionTreeClassifier(random_state=42)
path = raw_tree.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas = path.ccp_alphas[:-1]  # exclude trivial last node

cv_scores = []
for alpha in ccp_alphas:
    clf = DecisionTreeClassifier(ccp_alpha=alpha, random_state=42)
    scores = cross_val_score(clf, X_train, y_train, cv=5)
    cv_scores.append(scores.mean())

best_alpha = ccp_alphas[np.argmax(cv_scores)]
print(f"Best ccp_alpha: {best_alpha:.5f}")

# 4. Train the final interpretable tree
dt = DecisionTreeClassifier(
    criterion='gini',
    max_depth=4,          # hard cap for readability
    min_samples_leaf=10,  # avoid tiny, noisy leaves
    ccp_alpha=best_alpha,  # post-pruning
    random_state=42
)
dt.fit(X_train, y_train)

# 5. Evaluate
print(classification_report(y_test, dt.predict(X_test),
      target_names=data.target_names))
print(f"Tree depth:  {dt.get_depth()}")
print(f"Leaf count:  {dt.get_n_leaves()}")

# 6. Print human-readable text representation
print(export_text(dt, feature_names=list(feature_names)))

Rule Lists — Ordered Rules for Crystal-Clear Logic

A Rule List (also called a decision list) has the form:

The key difference from a decision tree is mutual exclusivity + order: each patient is classified by the first matching rule. No traversal of branches — just read down the list.

CORELS — Certifiably Optimal Rule Lists

Most rule-learning algorithms are greedy — they build rules one at a time and never look back. CORELS (Certifiable Optimal RulE ListS), developed by Angelino et al. (2017), solves this by using branch-and-bound search with mathematical optimality guarantees. CORELS finds the globally optimal rule list for a given regularisation parameter.

Rule Learning Algorithms — RIPPER, BRL, FRL

Several well-established algorithms learn rule lists from data. Each makes different trade-offs between optimality, speed, and model complexity.

Rule Lists in Python — iModels Library

# pip install imodels
# ── CORELS + RIPPER Rule Lists on Heart Disease Data ─────────

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, roc_auc_score
from imodels import RuleFitClassifier, GreedyRuleListClassifier, SkopeRulesClassifier
from imodels import BayesianRuleListClassifier

# 1. Data prep
data = load_breast_cancer()
X, y = data.data, data.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 2. Greedy Rule List (fast, interpretable)
grl = GreedyRuleListClassifier(max_depth=4)
grl.fit(X_train, y_train, feature_names=data.feature_names)
grl_preds = grl.predict(X_test)
print("=== Greedy Rule List ===")
print(grl)  # prints the rule list in human-readable format
print(f"Accuracy: {accuracy_score(y_test, grl_preds):.4f}")

# 3. RuleFit — combines linear model with rules as features
rf_clf = RuleFitClassifier(max_rules=10, random_state=42)
rf_clf.fit(X_train, y_train, feature_names=data.feature_names)
rf_preds = rf_clf.predict(X_test)
print("\n=== RuleFit Rules ===")
rules_df = rf_clf.get_rules()
print(rules_df[rules_df['coef'] != 0][['rule', 'coef', 'support']].head(8))

# 4. Compare all models
models = {
    'Greedy Rule List': grl,
    'RuleFit':         rf_clf,
}
print("\n{:<25} {:>10} {:>10}".format("Model", "Accuracy", "AUC"))
print("-" * 47)
for name, model in models.items():
    p = model.predict(X_test)
    pp = model.predict_proba(X_test)[:, 1]
    print(f"{name:<25} {accuracy_score(y_test,p):>10.4f} {roc_auc_score(y_test,pp):>10.4f}")

Decision Trees vs Rule Lists — Complete XAI Comparison

Feature Importance from Decision Trees — MDI & Permutation

Beyond the tree structure itself, decision trees give us feature importance — a global explanation of which features the model relies on most. Two main flavours exist:

from sklearn.inspection import permutation_importance
import pandas as pd

# MDI Importance (fast, built-in)
mdi_imp = pd.Series(dt.feature_importances_, index=feature_names).sort_values(ascending=False)
print("Top 5 features (MDI):")
print(mdi_imp.head(5))

# Permutation Importance (slower, unbiased)
perm = permutation_importance(
    dt, X_test, y_test,
    n_repeats=30,
    random_state=42
)
perm_df = pd.DataFrame({
    'feature': feature_names,
    'importance_mean': perm.importances_mean,
    'importance_std':  perm.importances_std
}).sort_values('importance_mean', ascending=False)

print("\nTop 5 features (Permutation):")
print(perm_df.head(5).to_string(index=False))

Counterfactual Explanations & Actionable Recourse

For decision trees and rule lists, counterfactuals are trivially readable from the model structure. For a black-box model, you need specialised algorithms (DiCE, Wachter et al.) that may not be faithful to the model.

Scorecard Models — Rule Lists' Clinical Cousin

A Scorecard is an XAI model closely related to rule lists: it assigns integer point values to features, and the prediction is based on whether the total score crosses a threshold. Scorecards are the most interpretable ML models and are the de facto standard in credit scoring, clinical risk tools (APACHE, SOFA, CURB-65), and fraud detection.

Common XAI Pitfalls — What Can Go Wrong

Full XAI Pipeline — End-to-End Decision Tree + Rule List

# ── Complete XAI Pipeline: Train → Explain → Audit → Report ──

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import StratifiedKFold, cross_validate
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
from sklearn.inspection import permutation_importance
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

# ── 1. Load & Prepare ─────────────────────────────────────────
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target
feature_names = data.feature_names

# ── 2. Find Optimal Pruning ────────────────────────────────────
def find_best_alpha(X_arr, y_arr, cv=5):
    raw = DecisionTreeClassifier(random_state=42)
    path = raw.cost_complexity_pruning_path(X_arr, y_arr)
    best, best_score = 0, 0
    for alpha in path.ccp_alphas[:-1]:
        clf = DecisionTreeClassifier(ccp_alpha=alpha, random_state=42)
        scores = []
        skf = StratifiedKFold(n_splits=cv, shuffle=True, random_state=42)
        for tr, va in skf.split(X_arr, y_arr):
            clf.fit(X_arr[tr], y_arr[tr])
            scores.append(accuracy_score(y_arr[va], clf.predict(X_arr[va])))
        mean_score = np.mean(scores)
        if mean_score > best_score:
            best_score, best = mean_score, alpha
    return best, best_score

best_alpha, best_cv = find_best_alpha(X.values, y)
print(f"Best α: {best_alpha:.5f}  |  CV Accuracy: {best_cv:.4f}")

# ── 3. Train Final Interpretable Model ────────────────────────
dt_final = DecisionTreeClassifier(
    criterion='gini',
    max_depth=4,
    min_samples_leaf=10,
    ccp_alpha=best_alpha,
    class_weight='balanced',
    random_state=42
)
dt_final.fit(X.values, y)

# ── 4. Human-Readable Rule Extraction ─────────────────────────
rules_text = export_text(dt_final, feature_names=list(feature_names))
print("\n── DECISION TREE RULES ──────────────────────")
print(rules_text)

# ── 5. Global Feature Importance ──────────────────────────────
imp_df = pd.DataFrame({
    'feature':    feature_names,
    'mdi':        dt_final.feature_importances_,
}).sort_values('mdi', ascending=False).head(5)
print("\nTop 5 Features by MDI Importance:")
print(imp_df.to_string(index=False))

# ── 6. Model Complexity Report (XAI Card) ─────────────────────
print(f"\n── XAI MODEL CARD ───────────────────────────")
print(f"Algorithm     : Decision Tree (CART)")
print(f"Depth         : {dt_final.get_depth()}")
print(f"Leaf nodes    : {dt_final.get_n_leaves()}")
print(f"Split features: {(dt_final.feature_importances_ > 0).sum()}")
print(f"CCP Alpha     : {best_alpha:.5f}")
print(f"CV Accuracy   : {best_cv:.4f}")
print(f"Explanation   : Root-to-leaf path (intrinsic)")
print(f"Legal coverage: GDPR Art.22 compliant")

Golden Rules — XAI with Decision Trees & Rule Lists

Summary — When to Use What