InterpretML

0.7.8 · active · verified Thu Apr 16

InterpretML is an open-source Python library designed for training inherently interpretable models (glassbox models) and explaining black-box machine learning systems. It provides a unified API for various interpretability techniques, including Explainable Boosting Machines (EBMs), LIME, and SHAP, along with interactive visualizations to help users understand model behavior globally and locally. The library is actively maintained, with frequent minor releases (e.g., several in early 2026), and is currently at version 0.7.8.

Common errors

```
TypeError: 'numpy.ufunc' object is not callable
```
cause This error often occurs when older versions of `interpret` (e.g., <0.7.3) are used with specific data types, leading to a UFuncTypeError in `ShapKernel.explain_local`.

fix Upgrade `interpret` to version 0.7.3 or later. If the issue persists, ensure your data types are compatible with NumPy operations expected by the explainer.
```
TypeError: is_classifier or is_regressor only accepting valid estimators
```
cause This specific error indicates an incompatibility with scikit-learn versions 1.8 and above, where validation functions were tightened.

fix Update `interpret` to version 0.7.4 or newer. This version specifically resolved the issue by adapting to the scikit-learn changes.
```
AttributeError: module 'interpret.ebm.ebm_utils' has no attribute 'merge_models'
```
cause The `merge_models` function in `EBMUtils` was renamed to `merge_ebms` in a past breaking change.

fix Replace `interpret.ebm.ebm_utils.merge_models` with `interpret.ebm.merge_ebms` in your code.
```
NameError: name 'ComputeProvider' is not defined
```
cause The `ComputeProvider` abstraction was removed in version 0.7.3 to simplify the API.

fix Remove any explicit references to `ComputeProvider` as it is no longer part of the public interface. The functionality is now handled internally.

Warnings

breaking The shape of the `bags` parameter in EBM fitting functions changed from `(n_outer_bags, n_samples)` to `(n_samples, n_outer_bags)`.
Fix: Update your code to pass `bags` with the shape `(n_samples, n_outer_bags)`. Version 0.7.0 issues a warning and accepts the old format, but future versions may remove this compatibility.
breaking The `EBMUtils.merge_models` function was renamed to `merge_ebms`.
Fix: Replace calls to `EBMUtils.merge_models` with `interpret.ebm.merge_ebms`.
gotcha Incompatibility with scikit-learn 1.8+ due to changes in `is_classifier` and `is_regressor` only accepting valid estimators.
Fix: Upgrade `interpret` to version 0.7.4 or later, which includes a fix for this incompatibility.
gotcha The `ComputeProvider` abstraction was removed, simplifying the interface.
Fix: If you were explicitly using `ComputeProvider`, you may need to adjust your code as this abstraction has been removed to simplify the API.
gotcha When passing NumPy arrays to explainers, feature names are not automatically inferred. Visualizations might lack descriptive labels.
Fix: Ensure the `feature_names` property is explicitly set when initializing the explainer or manually before calling an explain function. This is automatically handled when using Pandas DataFrames.

Install

pip install interpret Full installation
pip install interpret-core Minimal EBM-only installation
pip install interpret[shap] Install with SHAP support
pip install interpret[lime] Install with LIME support

Imports

ExplainableBoostingClassifier

from interpret.glassbox import ExplainableBoostingClassifier

ExplainableBoostingRegressor

from interpret.glassbox import ExplainableBoostingRegressor

show
wrong:
```
import interpret.show
```
correct:
```
from interpret import show
```
`show` is a top-level function for displaying visualizations, imported directly.

ShapKernel

from interpret.blackbox import ShapKernel

PartialDependence

from interpret.blackbox import PartialDependence

Quickstart

This quickstart demonstrates how to train a glassbox model, specifically an Explainable Boosting Machine (EBM) Classifier, and generate a global explanation using the `interpret` library. It uses the Iris dataset, performs a train-test split, trains the EBM, and then calls `explain_global()` to get model insights. The `show()` function is used for interactive visualization, typically within a Jupyter notebook.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from interpret.glassbox import ExplainableBoostingClassifier
from interpret import show
from sklearn.datasets import load_iris

# Load data
data = load_iris()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = pd.Series(data.target)

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)

# Train an Explainable Boosting Machine (EBM) classifier
ebm = ExplainableBoostingClassifier(random_state=42)
ebm.fit(X_train, y_train)

# Get a global explanation for the model
ebm_global = ebm.explain_global()

# Display the global explanation (typically in a Jupyter environment)
# show(ebm_global)

print("Model training complete. To view explanations, uncomment 'show(ebm_global)' in a Jupyter environment.")

view raw JSON →