Permutation Importance - Feature Attribution Methods | OneNoughtOne

0/328

Machine LearningML Interpretability & Fairness

Feature Attribution Methods

LevelAdvanced

Duration90 mins

TopicML Interpretability & Fairness

1 / 5

Permutation Importance

The Feature Importance Question

When a machine learning model makes a prediction, a natural question arises: which features actually mattered for this prediction? Understanding feature importance isn't merely academic curiosity—it's essential for model debugging, stakeholder communication, regulatory compliance, and scientific discovery.

Consider a loan approval model that rejects an application. The applicant, regulators, and the development team all want to know: Was it income? Credit history? Employment status? Without answers, the model is a black box—trusted by no one, understood by no one, and potentially harboring discriminatory patterns invisible to human oversight.

Permutation importance offers an elegant, model-agnostic solution to this problem. The core insight is beautifully simple: if a feature truly matters, scrambling its values should hurt model performance. If a feature is irrelevant, shuffling it should have no effect. This intuition, when formalized, provides a powerful tool for understanding any supervised learning model.

What You Will Learn

By the end of this page, you will understand permutation importance from mathematical foundations to production implementation. You'll know how to compute it correctly, interpret it rigorously, recognize its limitations, and apply it effectively across different model types and problem domains.

Conceptual Foundations

Permutation importance belongs to a family of model-agnostic interpretability methods—techniques that work on any model regardless of its internal architecture. This universality is both a strength and a constraint we'll examine carefully.

The Core Intuition

Imagine you're playing a game where you must predict house prices using various features: square footage, number of bedrooms, location, and the color of the front door. Intuitively, you know square footage matters much more than door color.

Now consider this experiment:

Train a model on the original data
Shuffle the 'square footage' column randomly, breaking its relationship with prices
Measure how much worse the model performs
Repeat for every feature

Features that cause severe performance drops when shuffled are important. Features that can be scrambled with minimal impact are unimportant (to this model, on this data).

Why Permutation?

Permutation preserves the marginal distribution of feature values while destroying conditional relationships. When we shuffle a feature:

Preserved: The range, mean, variance, and overall distribution of values
Destroyed: The relationship between this feature and the target, and correlations with other features

This is precisely what we want. We're asking: What would happen if this feature provided no information about the target? Permutation creates that counterfactual world while keeping the feature statistically realistic.

The Break-It-To-Understand-It Philosophy

Permutation importance embodies a fundamental interpretability principle: to understand a system's dependencies, strategically break them and observe the consequences. This 'ablation' approach appears throughout machine learning—from dropout regularization to neural network pruning experiments.

Historical Context

While the intuition is simple, permutation importance has a precise intellectual lineage:

Leo Breiman (2001) introduced permutation importance in the context of Random Forests, proposing it as a variable importance measure that leverages the out-of-bag (OOB) samples naturally available in bagging. His insight was that OOB error increases could quantify feature relevance without additional data splitting.

Fisher, Rudin, and Dominici (2019) generalized this into "Model Reliance," formalizing permutation importance for any model and providing theoretical guarantees about its behavior.

Today, permutation importance is implemented in major ML libraries (scikit-learn, mlr3, etc.) and serves as a standard baseline for feature attribution.

Mathematical Formalization

Let's formalize permutation importance with mathematical precision. Understanding the formal definition reveals both the method's power and its subtleties.

Setup and Notation

Consider:

A trained model $f: \mathcal{X} \rightarrow \mathcal{Y}$
A dataset $D = {(x_i, y_i)}_{i=1}^n$ where $x_i \in \mathbb{R}^p$
A performance metric $L(y, \hat{y})$ (e.g., MSE, accuracy, AUC)
Feature $j$ with values $x_{:,j} = (x_{1,j}, x_{2,j}, ..., x_{n,j})$

Let $s = L(y, f(X))$ denote the original model performance on dataset $D$.

Permutation Operation

For feature $j$, let $\pi$ be a random permutation of indices ${1, 2, ..., n}$. Define the permuted dataset:

$$X^{\pi_j} = (x_1^{\pi_j}, x_2^{\pi_j}, ..., x_n^{\pi_j})$$

where $x_i^{\pi_j}$ equals $x_i$ with its $j$-th component replaced by $x_{\pi(i),j}$.

Permutation Importance Definition

The permutation importance of feature $j$ is:

$$PI_j = s^{\pi_j} - s = L(y, f(X^{\pi_j})) - L(y, f(X))$$

Or in ratio form:

$$PI_j^{ratio} = \frac{s^{\pi_j}}{s}$$

For metrics where higher is better (accuracy, AUC), the difference is negated or the ratio inverted.

Metric Direction Matters

For error metrics (MSE, MAE), higher importance means larger increase in error after permutation. For performance metrics (accuracy, R²), higher importance means larger decrease in performance. Always verify the sign convention in your implementation.

Variance Reduction: Multiple Permutations

A single permutation introduces randomness—the importance estimate varies with the specific shuffle. To reduce variance, we average over $K$ permutations:

$$\overline{PI}j = \frac{1}{K} \sum{k=1}^{K} PI_j^{(k)}$$

With standard error:

$$SE(PI_j) = \frac{\sigma_{PI_j}}{\sqrt{K}}$$

where $\sigma_{PI_j}$ is the standard deviation across permutations. This enables confidence intervals:

$$CI_{95%}(PI_j) = \overline{PI}_j \pm 1.96 \cdot SE(PI_j)$$

Typical values: $K = 10$ to $K = 100$ permutations suffice for stable estimates in most applications. Extremely high-dimensional data may require larger $K$.

Computational Complexity

For $p$ features, $K$ permutations, and $n$ samples:

Time: $O(p \cdot K \cdot T_{predict})$ where $T_{predict}$ is model inference time on $n$ samples
Space: $O(n)$ for storing permuted feature column

This makes permutation importance tractable for most models, though it can become expensive for very slow inference (e.g., large neural networks) or very high-dimensional data ($p > 10,000$).

Computational Cost Comparison
Model Type	Inference Speed	1000 Features, 10 Permutations	Practical Time Estimate
Linear Regression	Very Fast	O(10,000 × n)	Seconds
Random Forest	Fast	O(10,000 × n × trees)	Minutes
Gradient Boosting	Fast	O(10,000 × n × rounds)	Minutes
Deep Neural Network	Slow (GPU batch)	O(10,000 × batches)	10–60 minutes
Large Transformer	Very Slow	O(10,000 × batches)	Hours

Algorithm and Implementation

Let's translate the mathematical definition into a concrete algorithm and production-ready implementation.

The Core Algorithm

The permutation importance algorithm is elegantly simple:

permutation_importance_algorithm.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
ALGORITHM: Permutation Importance
INPUT: 
  - Trained model f
  - Dataset (X, y) with n samples and p features
  - Performance metric L
  - Number of permutations K
 
OUTPUT:
  - Importance scores (PI_1, PI_2, ..., PI_p)
  - Standard errors (SE_1, SE_2, ..., SE_p)
 
1. Compute baseline performance:
   s_baseline ← L(y, f(X))
 
2. For each feature j in {1, 2, ..., p}:
   a. Initialize: importance_scores ← empty list
   
   b. For k in {1, 2, ..., K}:
      i.   Create X_permuted ← copy of X
      ii.  Generate random permutation π of {1, ..., n}
      iii. X_permuted[:, j] ← X[π, j]  // Shuffle column j
      iv.  s_permuted ← L(y, f(X_permuted))
      v.   importance_scores.append(s_permuted - s_baseline)
   
   c. PI_j ← mean(importance_scores)
   d. SE_j ← std(importance_scores) / sqrt(K)
 
3. Return (PI_1, ..., PI_p), (SE_1, ..., SE_p)

Python Implementation from Scratch

Here's a complete, annotated implementation that handles edge cases and provides confidence intervals:

permutation_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import numpy as np
from typing import Callable, Tuple, Dict, List
from sklearn.base import BaseEstimator
 
def permutation_importance(
    model: BaseEstimator,
    X: np.ndarray,
    y: np.ndarray,
    scoring: Callable[[np.ndarray, np.ndarray], float],
    n_repeats: int = 10,
    random_state: int = 42,
    higher_is_better: bool = True
) -> Dict[str, np.ndarray]:
    """
    Compute permutation importance for a trained model.
    
    Parameters
    ----------
    model : trained model with predict/predict_proba method
    X : ndarray of shape (n_samples, n_features)
    y : ndarray of shape (n_samples,)
    scoring : callable(y_true, y_pred) -> score
    n_repeats : number of permutations per feature
    random_state : random seed for reproducibility
    higher_is_better : True if higher scores are better
    
    Returns
    -------
    dict with keys:
        'importances_mean': mean importance per feature
        'importances_std': std deviation per feature
        'importances': (n_features, n_repeats) raw importance scores
    """
    rng = np.random.RandomState(random_state)
    n_samples, n_features = X.shape
    
    # Compute baseline score
    y_pred = model.predict(X)
    baseline_score = scoring(y, y_pred)
    
    # Initialize storage
    importances = np.zeros((n_features, n_repeats))
    
    for feat_idx in range(n_features):
        # Store original column
        original_column = X[:, feat_idx].copy()
        
        for rep_idx in range(n_repeats):
            # Generate random permutation
            perm_indices = rng.permutation(n_samples)
            
            # Apply permutation to feature column (in-place)
            X[:, feat_idx] = original_column[perm_indices]
            
            # Score with permuted feature
            y_pred_perm = model.predict(X)
            permuted_score = scoring(y, y_pred_perm)
            
            # Compute importance (direction depends on metric)
            if higher_is_better:
                importances[feat_idx, rep_idx] = baseline_score - permuted_score
            else:
                importances[feat_idx, rep_idx] = permuted_score - baseline_score
        
        # Restore original column
        X[:, feat_idx] = original_column
    
    return {
        'importances_mean': importances.mean(axis=1),
        'importances_std': importances.std(axis=1),
        'importances': importances,
        'baseline_score': baseline_score
    }
 
 
# Example usage
if __name__ == "__main__":
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.datasets import make_classification
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # Generate synthetic data
    X, y = make_classification(
        n_samples=1000, n_features=10, n_informative=5,
        n_redundant=2, n_clusters_per_class=1, random_state=42
    )
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=42
    )
    
    # Train model
    model = RandomForestClassifier(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    
    # Compute permutation importance on test set
    importance_result = permutation_importance(
        model, X_test, y_test,
        scoring=accuracy_score,
        n_repeats=30,
        higher_is_better=True
    )
    
    # Display results
    print("
Permutation Importance Results:")
    print("-" * 50)
    for idx in np.argsort(importance_result['importances_mean'])[::-1]:
        mean_imp = importance_result['importances_mean'][idx]
        std_imp = importance_result['importances_std'][idx]
        print(f"Feature {idx:2d}: {mean_imp:.4f} ± {std_imp:.4f}")

In-Place Modification Trap

The implementation above modifies X in-place for efficiency. Always restore the original column after each feature's computation. Failure to do so corrupts subsequent importance calculations. For safety, consider working with X.copy() if memory permits.

Using Scikit-learn's Implementation

For production use, scikit-learn provides an optimized implementation:

sklearn_permutation_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from sklearn.inspection import permutation_importance
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
 
# Load data
housing = fetch_california_housing()
X_train, X_test, y_train, y_test = train_test_split(
    housing.data, housing.target, test_size=0.3, random_state=42
)
 
# Train model
model = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
model.fit(X_train, y_train)
 
# Compute permutation importance on TEST set
result = permutation_importance(
    model, X_test, y_test,
    n_repeats=30,
    random_state=42,
    n_jobs=-1,           # Parallelize across CPU cores
    scoring='r2'         # or custom scorer
)
 
# Sort features by importance
sorted_idx = result.importances_mean.argsort()[::-1]
 
# Visualization with error bars
fig, ax = plt.subplots(figsize=(10, 6))
ax.boxplot(
    result.importances[sorted_idx].T,
    vert=False,
    labels=np.array(housing.feature_names)[sorted_idx]
)
ax.set_title("Permutation Importance (California Housing)")
ax.set_xlabel("Decrease in R² Score")
plt.tight_layout()
plt.show()
 
# Statistical significance: features whose CI excludes 0
print("
Statistically Significant Features (95% CI excludes 0):")
for idx in sorted_idx:
    mean = result.importances_mean[idx]
    std = result.importances_std[idx]
    ci_lower = mean - 1.96 * std
    if ci_lower > 0:
        print(f"  {housing.feature_names[idx]}: {mean:.4f} [{ci_lower:.4f}, {mean + 1.96*std:.4f}]")

Train vs Test Set: A Critical Distinction

One of the most common mistakes in computing permutation importance is using the training set. This distinction is not merely technical—it has profound implications for interpretation.

Why This Matters

Training set importance tells you which features the model learned to rely on during training—even if those relationships don't generalize.

Test set importance tells you which features the model uses to make accurate predictions on unseen data—what actually matters in deployment.

These can differ dramatically when models overfit.

Training Set Importance

•Shows what the model memorized
•Inflated importance for overfit features
•Noise features may appear important
•Doesn't reflect generalization
•Can mislead about true relationships

Test Set Importance

•Shows what generalizes to new data
•Accurate importance estimates
•Noise features correctly ranked low
•Reflects deployment behavior
•Reveals true feature-target relationships

Demonstration: The Danger of Training Set Importance

train_vs_test_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split
 
# Create data with a noise feature that can be memorized
np.random.seed(42)
n_samples = 500
 
# True signal: X0 and X1 are informative
X_informative = np.random.randn(n_samples, 2)
 
# X2 is pure noise - no relationship with y
X_noise = np.random.randn(n_samples, 1)
 
# X3 is an ID column - unique to each sample (maximally overfit-prone)
X_id = np.arange(n_samples).reshape(-1, 1).astype(float)
 
X = np.hstack([X_informative, X_noise, X_id])
y = 3 * X[:, 0] + 2 * X[:, 1] + np.random.randn(n_samples) * 0.5
 
feature_names = ['X_signal_0', 'X_signal_1', 'X_noise', 'X_id']
 
# Split BEFORE fitting
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
 
# Train a deep forest (prone to overfitting)
model = RandomForestRegressor(
    n_estimators=200, 
    max_depth=None,  # Deep trees can memorize
    min_samples_leaf=1,  # Allows memorization
    random_state=42
)
model.fit(X_train, y_train)
 
print(f"Train R²: {model.score(X_train, y_train):.4f}")  # Will be ~1.0
print(f"Test R²:  {model.score(X_test, y_test):.4f}")   # Lower due to overfitting
 
# Compute importance on TRAINING set (wrong!)
train_importance = permutation_importance(
    model, X_train, y_train, n_repeats=30, random_state=42
)
 
# Compute importance on TEST set (correct!)
test_importance = permutation_importance(
    model, X_test, y_test, n_repeats=30, random_state=42
)
 
print("
" + "="*60)
print("TRAINING SET IMPORTANCE (Misleading!)")
print("="*60)
for idx in np.argsort(train_importance.importances_mean)[::-1]:
    print(f"{feature_names[idx]:15s}: {train_importance.importances_mean[idx]:.4f}")
 
print("
" + "="*60)
print("TEST SET IMPORTANCE (Correct)")
print("="*60)
for idx in np.argsort(test_importance.importances_mean)[::-1]:
    print(f"{feature_names[idx]:15s}: {test_importance.importances_mean[idx]:.4f}")
 
# Expected output:
# Training set will show X_id as HIGHLY important (model memorized it!)
# Test set correctly shows X_id and X_noise as unimportant

Never Use Training Set for Final Importance

Training set importance can show ID columns, random noise, and overfit features as 'highly important.' Always use held-out data (validation or test set) for importance that reflects generalization. The only exception is exploratory analysis during model debugging.

Interpretation Guidelines

Permutation importance is intuitive but requires careful interpretation. Here are comprehensive guidelines for understanding your results.

What High Importance Means

A feature with high permutation importance means the model's performance deteriorates significantly when that feature's values are scrambled. This tells us:

The model relies on this feature for accurate predictions
The feature carries predictive information that the model has learned to use
Breaking the feature-target relationship hurts generalization

Importantly, high importance does not mean:

The feature causes the outcome (correlation ≠ causation)
The feature is the most informative in isolation
Other features couldn't substitute if this one were removed

What Low Importance Means

Low permutation importance indicates the model doesn't rely on this feature. But interpretation requires nuance:

Interpreting Low Feature Importance
Scenario	What's Happening	Action to Take
Feature is truly irrelevant	No predictive signal for the target	Consider removing to simplify model
Feature is redundant	Information captured by correlated features	Keep if interpretability favors it
Model couldn't learn to use it	Nonlinear relationship model missed	Try different model architecture
Insufficient data	Signal exists but sample size too small	Collect more data, reduce dimensions
Feature engineering needed	Raw feature not useful; transformed version might be	Create derived features

The Correlated Features Problem

This is the most important limitation to understand. When features are correlated, permutation importance can:

Underestimate both features' importance: If A and B are correlated and both predictive, shuffling A doesn't hurt much because B still provides the information
Split importance arbitrarily: The importance gets distributed between correlated features in unstable ways
Vary between runs: Small changes in training can flip which correlated feature gets the importance

correlated_features_demo.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.inspection import permutation_importance
 
np.random.seed(42)
n = 1000
 
# Feature A is the true signal
X_A = np.random.randn(n)
 
# Feature B is a noisy copy of A (correlation ~0.95)
X_B = X_A + np.random.randn(n) * 0.3
 
# Target depends only on A
y = 2 * X_A + np.random.randn(n) * 0.5
 
X = np.column_stack([X_A, X_B])
 
# Train random forest
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X, y)
 
# Permutation importance
result = permutation_importance(model, X, y, n_repeats=30, random_state=42)
 
print("Feature Correlation:", np.corrcoef(X_A, X_B)[0, 1])
print(f"
Feature A (true signal): {result.importances_mean[0]:.4f}")
print(f"Feature B (correlated):  {result.importances_mean[1]:.4f}")
 
# Both features show importance because:
# 1. When A is shuffled, B still carries most of A's information
# 2. When B is shuffled, A is unchanged
# Result: Both appear moderately important, neither shows full importance

Correlated Features Dilute Importance

When features are highly correlated, their individual importance scores underestimate their collective importance. Consider using grouped permutation importance (shuffle correlated features together) or SHAP values with appropriate grouping for accurate attribution.

Statistical Significance

Not all non-zero importance is meaningful. Use confidence intervals:

Statistically significant if 95% CI excludes zero
Practically significant if effect size is meaningful for your application
Rank stability: Important features should have consistent rankings across different data subsets

Best Practices for Interpretation

•Always report confidence intervals, not just point estimates
•Compute importance on test/validation data, never training data alone
•Examine feature correlations before interpreting individual importance
•Use multiple random seeds to assess stability of rankings
•Compare relative importance within a model, not across different models
•Consider domain knowledge when importance seems counterintuitive

Comparison with Model-Specific Importance

Tree-based models provide built-in feature importance metrics that are often confused with permutation importance. Understanding their differences is crucial for choosing the right tool.

Mean Decrease Impurity (MDI)

Random Forest's default feature_importances_ attribute uses Mean Decrease Impurity (also called Gini importance):

Computed during training as average impurity decrease across all splits using a feature
Fast: no additional computation after training
Biased toward high-cardinality features (more split points = more chances to reduce impurity)
Biased toward features appearing in many splits (which can happen by chance)

Permutation Importance (PI)

Computed on held-out data after training
Model-agnostic: works on any model
Measures actual predictive contribution
Correctly handles high-cardinality features
More computationally expensive

mdi_vs_permutation.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split
 
np.random.seed(42)
n = 2000
 
# X_informative: low cardinality, truly predictive
X_informative = np.repeat([0, 1, 2], n//3 + 1)[:n].astype(float)
 
# X_random_id: high cardinality, noise (unique per sample)
X_random_id = np.arange(n).astype(float) + np.random.randn(n) * 0.1
 
# X_noise: low cardinality, noise
X_noise = np.random.randint(0, 3, n).astype(float)
 
X = np.column_stack([X_informative, X_random_id, X_noise])
y = X_informative * 2 + np.random.randn(n) * 0.5  # Only X_informative matters
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
 
# Train deep random forest
model = RandomForestRegressor(n_estimators=100, max_depth=None, random_state=42)
model.fit(X_train, y_train)
 
# MDI (biased toward high-cardinality)
mdi_importance = model.feature_importances_
 
# Permutation importance (correct)
perm_importance = permutation_importance(
    model, X_test, y_test, n_repeats=30, random_state=42
)
 
print("Feature Importance Comparison")
print("="*55)
print(f"{'Feature':<20} {'MDI':>12} {'Permutation':>12}")
print("-"*55)
names = ['X_informative', 'X_random_id (noise)', 'X_noise']
for i, name in enumerate(names):
    print(f"{name:<20} {mdi_importance[i]:>12.4f} {perm_importance.importances_mean[i]:>12.4f}")
 
# MDI will show X_random_id as important (high cardinality = many split opportunities)
# Permutation correctly shows only X_informative matters

MDI vs Permutation Importance
Property	MDI (Gini Importance)	Permutation Importance
Computation time	Free (from training)	O(K × p × predict time)
Model types	Trees only	Any model
Data required	Training data (implicit)	Test/validation data
High-cardinality bias	Yes (overestimates)	No
Correlation handling	Spreads importance	Spreads importance
Overfitting detection	No (uses train data)	Yes (uses test data)
Randomness	Deterministic	Requires multiple permutations

When to Use Each

Use MDI for fast, rough feature screening during model development. Use permutation importance for final feature importance reports, model documentation, and any stakeholder communication. When they disagree, trust permutation importance.

Advanced Variations

Several extensions address limitations of basic permutation importance.

Grouped Permutation Importance

For correlated features, permute groups together to measure their combined importance:

grouped_permutation_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import numpy as np
from typing import List, Dict
 
def grouped_permutation_importance(
    model, X, y, feature_groups: Dict[str, List[int]], 
    scoring, n_repeats=10, random_state=42
):
    """
    Compute permutation importance for groups of features.
    
    Parameters
    ----------
    feature_groups : dict mapping group_name -> list of feature indices
        e.g., {'demographics': [0, 1, 2], 'financials': [3, 4, 5]}
    """
    rng = np.random.RandomState(random_state)
    n_samples = X.shape[0]
    
    y_pred = model.predict(X)
    baseline = scoring(y, y_pred)
    
    group_importances = {}
    
    for group_name, feature_indices in feature_groups.items():
        scores = []
        for _ in range(n_repeats):
            X_perm = X.copy()
            perm = rng.permutation(n_samples)
            
            # Shuffle ALL features in the group together
            # This preserves within-group correlations while breaking target relationship
            for idx in feature_indices:
                X_perm[:, idx] = X[perm, idx]
            
            y_pred_perm = model.predict(X_perm)
            scores.append(baseline - scoring(y, y_pred_perm))
        
        group_importances[group_name] = {
            'mean': np.mean(scores),
            'std': np.std(scores)
        }
    
    return group_importances
 
# Example usage
feature_groups = {
    'customer_demographics': [0, 1, 2],      # age, gender, location
    'financial_history': [3, 4, 5, 6],       # income, credit_score, debt, savings
    'behavioral_signals': [7, 8, 9],         # page_views, click_rate, time_on_site
}
 
# group_imp = grouped_permutation_importance(model, X, y, feature_groups, accuracy_score)

Conditional Permutation Importance

Standard permutation breaks marginal distributions. Conditional permutation maintains realistic feature relationships by permuting only within groups of similar samples:

Idea: Instead of random global shuffling, swap feature values only between samples with similar other feature values. This creates "realistic" counterfactuals.

Implementation: Discretize correlated features into bins, permute within bins.

This is computationally more expensive but provides importance estimates that better reflect causal influence rather than mere predictive association.

Leave-One-Feature-Out (LOFO) Importance

An alternative approach: train the model without each feature and measure performance degradation:

Train full model, measure baseline performance
For each feature j: retrain model without feature j, measure performance
Importance = baseline performance - performance without feature

Pros: Measures the irreplaceable information content of each feature Cons: Requires retraining p times (expensive for large models)

Permutation Importance with Cross-Validation

For small datasets, combine with cross-validation:

cv_permutation_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
from sklearn.model_selection import cross_val_score, KFold
from sklearn.base import clone
import numpy as np
 
def cv_permutation_importance(model, X, y, scoring, cv=5, n_repeats=10, random_state=42):
    """
    Permutation importance with cross-validation for more stable estimates.
    """
    rng = np.random.RandomState(random_state)
    kf = KFold(n_splits=cv, shuffle=True, random_state=random_state)
    
    n_features = X.shape[1]
    all_importances = []
    
    for train_idx, test_idx in kf.split(X):
        X_train, X_test = X[train_idx], X[test_idx]
        y_train, y_test = y[train_idx], y[test_idx]
        
        # Clone and fit model
        fold_model = clone(model)
        fold_model.fit(X_train, y_train)
        
        # Baseline score
        y_pred = fold_model.predict(X_test)
        baseline = scoring(y_test, y_pred)
        
        fold_importance = np.zeros((n_features, n_repeats))
        
        for feat_idx in range(n_features):
            orig_col = X_test[:, feat_idx].copy()
            for rep in range(n_repeats):
                X_test[:, feat_idx] = rng.permutation(orig_col)
                y_pred_perm = fold_model.predict(X_test)
                fold_importance[feat_idx, rep] = baseline - scoring(y_test, y_pred_perm)
            X_test[:, feat_idx] = orig_col
        
        all_importances.append(fold_importance.mean(axis=1))
    
    all_importances = np.array(all_importances)
    return {
        'importances_mean': all_importances.mean(axis=0),
        'importances_std': all_importances.std(axis=0),
        'importances_by_fold': all_importances
    }

Production Considerations

Deploying permutation importance in production systems requires addressing several practical challenges.

Computational Budget

For real-time importance computation (e.g., explaining individual predictions programmatically), permutation importance is often too slow. In production:

Precompute global importance during model training and store with model artifacts
Cache importance results for common feature configurations
Use approximations: compute importance on a representative subsample
Consider faster alternatives: SHAP TreeExplainer for tree models, linear model coefficients for linear models

production_importance.py
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import json
import numpy as np
from pathlib import Path
from datetime import datetime
 
class ModelWithImportance:
    """Wrapper that stores and serves precomputed importance."""
    
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names
        self.global_importance = None
        self.importance_metadata = {}
    
    def compute_and_store_importance(self, X_test, y_test, scoring, n_repeats=30):
        """Compute importance during training pipeline and store."""
        from sklearn.inspection import permutation_importance
        
        result = permutation_importance(
            self.model, X_test, y_test, 
            n_repeats=n_repeats, 
            random_state=42
        )
        
        self.global_importance = {
            name: {
                'mean': float(result.importances_mean[i]),
                'std': float(result.importances_std[i])
            }
            for i, name in enumerate(self.feature_names)
        }
        
        self.importance_metadata = {
            'computed_at': datetime.now().isoformat(),
            'n_samples': X_test.shape[0],
            'n_repeats': n_repeats,
            'model_score': float(self.model.score(X_test, y_test))
        }
    
    def save_importance(self, path: Path):
        """Save importance to JSON for serving."""
        data = {
            'feature_importance': self.global_importance,
            'metadata': self.importance_metadata
        }
        path.write_text(json.dumps(data, indent=2))
    
    def get_top_features(self, n=5):
        """API endpoint: return top n features by importance."""
        sorted_features = sorted(
            self.global_importance.items(),
            key=lambda x: x[1]['mean'],
            reverse=True
        )
        return sorted_features[:n]

Monitoring Importance Drift

Feature importance can change over time as data distributions shift. Monitor for:

Importance ranking changes: If previously top features become unimportant (or vice versa), investigate data drift or concept drift
Importance magnitude changes: Decreasing importance across all features may indicate model degradation
Sudden spikes: May indicate data quality issues or distribution shift

Production Checklist

•Compute importance on held-out test set, never training data
•Use enough permutations (≥10) for stable estimates
•Store importance with model version for reproducibility
•Document the scoring metric used for importance calculation
•Monitor importance drift as part of model monitoring
•For correlated features, document grouping decisions
•Include confidence intervals in any importance reports
•Validate importance makes domain sense before deployment

Summary

Permutation importance provides a model-agnostic, intuitive method for measuring feature importance. Let's consolidate the key insights:

Key Takeaways

•Core concept: Measure importance by shuffling a feature and observing performance drop
•Model-agnostic: Works on any model with a predict method and a performance metric
•Always use test data: Training set importance is misleading due to overfitting
•Correlation pitfall: Correlated features split importance; consider grouped permutation
•Statistical rigor: Use multiple permutations and report confidence intervals
•MDI comparison: Tree-based default importance (MDI) has high-cardinality bias; prefer permutation importance for final analysis
•Computational cost: O(p × K × inference time); precompute for production

Ready for SHAP

You now understand permutation importance—a powerful baseline method for feature attribution. Next, we'll explore SHAP values, which provide a theoretically principled framework based on game theory that addresses several limitations of permutation importance while enabling local (per-prediction) explanations.