Explain multioutput predictive models with dalex

This notebook provides examples of working with multiclass classification and other multioutput algorithms, e.g. multioutput regression.

A natural example of such an algorithm is a multilayer perceptron neural network.

For a broad overview of the topic, see a comprehensive introduction in the scikit-learn package's documentation: 1.12. Multiclass and multioutput algorithms.

Introduction to dalex: Explanatory Model Analysis: Explore, Explain, and Examine Predictive Models

https://dalex.drwhy.ai/python

Imports

In [1]:
import dalex as dx

import numpy as np
import pandas as pd

from sklearn import datasets
from sklearn.ensemble import RandomForestRegressor
from sklearn.multioutput import MultiOutputRegressor
from lightgbm import LGBMClassifier, LGBMRegressor

import plotly
plotly.offline.init_notebook_mode()

import warnings
warnings.filterwarnings('ignore')
In [2]:
dx.__version__
Out[2]:
'1.7.0'

Part 1: treating a multioutput model as multiple singleoutput models

One approach is to use each model's output separately, e.g. the predicted probability for a given class in multiclass classification problem.

Part 1A: Multiclass classification

We will use the iris dataset and the LGBMClassifier model for this example.

In [3]:
# data
X, y = datasets.load_iris(return_X_y=True, as_frame=True)

# model 
model = LGBMClassifier(n_estimators=25, verbose=-1)
model.fit(X, y)

# model has 3 outputs
model.predict_proba(X).shape
Out[3]:
(150, 3)

Let's explain the classification for the first class 0. For that, we need to create a custom predict_function.

In [4]:
# custom (binary) predict function
pf_0 = lambda m, d: m.predict_proba(d)[:, 0]

# custom (binary) target values
y_0 = y == 0

# explainer
exp_0 = dx.Explainer(model, X, y_0, predict_function=pf_0, label="LGBMClassifier: class 0")

Preparation of a new explainer is initiated

  -> data              : 150 rows 4 cols
  -> target variable   : Parameter 'y' was a pandas.Series. Converted to a numpy.ndarray.
  -> target variable   : 150 values
  -> model_class       : lightgbm.sklearn.LGBMClassifier (default)
  -> label             : LGBMClassifier: class 0
  -> predict function  : <function <lambda> at 0x2b8457ce0> will be used
  -> predict function  : Accepts pandas.DataFrame and numpy.ndarray.
  -> predicted values  : min = 0.0126, mean = 0.337, max = 0.974
  -> model type        : classification will be used (default)
  -> residual function : difference between y and yhat (default)
  -> residuals         : min = -0.242, mean = -0.00336, max = 0.129
  -> model_info        : package lightgbm

A new explainer has been created!
In [5]:
exp_0.model_performance()
Out[5]:
recall precision f1 accuracy auc
LGBMClassifier: class 0 1.0 1.0 1.0 1.0 1.0
In [6]:
exp_0.model_parts().plot()
exp_0.model_profile().plot()

Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 245.38it/s]

Now, let's explain the classification for all the classes. For that, we can loop over multiple explainers.

In [7]:
exp_list = []

for i in range(len(np.unique(y))):
    # add i parameter to `predict_function` just to do it in a loop
    pf = lambda m, d, i=i: m.predict_proba(d)[:, i]
    e = dx.Explainer(
        model, X, 
        y == i, 
        predict_function=pf,
        label=f'LGBMClassifier: class {i}',
        verbose=False
    )
    exp_list += [e]

exp_list
Out[7]:
[<dalex._explainer.object.Explainer at 0x2bb619cd0>,
 <dalex._explainer.object.Explainer at 0x177404b90>,
 <dalex._explainer.object.Explainer at 0x2bb6ddd60>]
In [8]:
# create multiple explanations
m_profile_list = [e.model_profile() for e in exp_list]

Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 270.11it/s]
Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 233.53it/s]
Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 326.06it/s]
In [9]:
# plot multiple explanations
m_profile_list[0].plot(m_profile_list[1:])
In [10]:
m_parts_list = [e.model_parts() for e in exp_list]
m_parts_list[0].plot(m_parts_list[1:])

We explain predictions in a same way

In [11]:
# choose a data point to explain
observation = X.iloc[[0]]

p_parts_list = [e.predict_parts(observation) for e in exp_list]
p_parts_list[0].plot(p_parts_list[1:], min_max=[-0.1, 1.1])
In [12]:
p_profile_list = [e.predict_profile(observation) for e in exp_list]
p_profile_list[0].plot(p_profile_list[1:])

Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 826.83it/s]
Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 933.88it/s]
Calculating ceteris paribus: 100%|██████████| 4/4 [00:00<00:00, 1025.13it/s]

Part 1B: Multioutput regression

We will use a custom dataset and two models for this example:

  1. RandomForestRegressor, which supports multioutput directly,
  2. LGBMRegressor with MultiOutputRegressor, which involves creating one model for each output independently.

For details, see 1.10.3. Multi-output problems and scikit-learn: Comparing random forests and the multi-output meta estimator.

In [13]:
# create a toy multiregression example
n_outputs = 4
X, y = datasets.make_regression(n_samples=2000, n_features=7, n_informative=5, n_targets=n_outputs, effective_rank=1, noise=0.5, random_state=1)

# summarize the dataset
print(X.shape, y.shape)

(2000, 7) (2000, 4)
In [14]:
# model
model_rf = RandomForestRegressor()
model_rf.fit(X, y)
model_rf.predict(X).shape
Out[14]:
(2000, 4)

The following code returns an error because the LGBMRegressor model does not support multioutput directly.

In [15]:
try:
    model_gbm = LGBMRegressor()
    model_gbm.fit(X, y)
except Exception as e:
    print(f"Error: {e}")

Error: y should be a 1d array, got an array of shape (2000, 4) instead.
In [16]:
# wrap the second model
model_gbm = MultiOutputRegressor(LGBMRegressor(verbose=-1))
model_gbm.fit(X, y)
model_gbm.predict(X).shape
Out[16]:
(2000, 4)

Like in Part 1A, we explain the regression for all the outputs by looping over multiple explainers.

In [17]:
exp_rf_list, exp_gbm_list = [], []

for i in range(n_outputs):
    # add i parameter to `predict_function` just to do it in a loop
    pf = lambda m, d, i=i: m.predict(d)[:, i]

    e_rf = dx.Explainer(
        model_rf, X, 
        y[:, i], 
        predict_function=pf,
        label=f'RF: output {i}',
        verbose=False
    )
    e_gbm = dx.Explainer(
        model_gbm, X, 
        y[:, i], 
        predict_function=pf,
        label=f'GBM: output {i}',
        verbose=False
    )

    exp_rf_list += [e_rf]
    exp_gbm_list += [e_gbm]

exp_rf_list + exp_gbm_list
Out[17]:
[<dalex._explainer.object.Explainer at 0x2c2b82330>,
 <dalex._explainer.object.Explainer at 0x2c306b680>,
 <dalex._explainer.object.Explainer at 0x2c30a8d10>,
 <dalex._explainer.object.Explainer at 0x2c30a8fb0>,
 <dalex._explainer.object.Explainer at 0x2c30680e0>,
 <dalex._explainer.object.Explainer at 0x2c30a8350>,
 <dalex._explainer.object.Explainer at 0x2c306b5f0>,
 <dalex._explainer.object.Explainer at 0x2c2c98260>]

Let's check the models' performance.

In [18]:
m_performance_list = [e.model_performance() for e in exp_rf_list + exp_gbm_list]
pd.concat([mp.result for mp in m_performance_list], axis=0)
Out[18]:
mse rmse r2 mae mad
RF: output 0 0.066228 0.257348 0.979263 0.197098 0.150733
RF: output 1 0.051802 0.227601 0.979225 0.179050 0.147194
RF: output 2 0.052453 0.229026 0.961594 0.180068 0.151624
RF: output 3 0.064954 0.254861 0.980359 0.199861 0.165121
GBM: output 0 0.083923 0.289694 0.973723 0.226224 0.182196
GBM: output 1 0.081460 0.285411 0.967332 0.225156 0.190575
GBM: output 2 0.084242 0.290245 0.938318 0.230180 0.196593
GBM: output 3 0.080827 0.284301 0.975559 0.224692 0.184345
In [19]:
m_performance_list[0].plot(m_performance_list[4:8])

Explain!

In [20]:
m_parts_gbm_list = [e.model_parts(verbose=False) for e in exp_gbm_list]
m_parts_gbm_list[0].plot(m_parts_gbm_list[1::])

If the targets have related values and domains, we could compare their profiles.

In [21]:
m_profile_gbm_list = [e.model_profile(verbose=False) for e in exp_gbm_list]
m_profile_gbm_list[0].plot(m_profile_gbm_list[1::])