NICE: an algorithm for nearest instance counterfactual explanations

Abstract

In this paper we propose a new algorithm, named NICE, to generate counterfactual explanations for tabular data that specifically takes into account algorithmic requirements that often emerge in real-life deployments: (1) the ability to provide an explanation for all predictions, (2) being able to handle any classification model (also non-differentiable ones), (3) being efficient in run time, and (4) providing multiple counterfactual explanations with different characteristics. More specifically, our approach exploits information from a nearest unlike neighbor to speed up the search process, by iteratively introducing feature values from this neighbor in the instance to be explained. We propose four versions of NICE, one without optimization and, three which optimize the explanations for one of the following properties: sparsity, proximity or plausibility. An extensive empirical comparison on 40 datasets shows that our algorithm outperforms the current state-of-the-art in terms of these criteria. Our analyses show a trade-off between on the one hand plausibility and on the other hand proximity or sparsity, with our different optimization methods offering users the choice to select the types of counterfactuals that they prefer. An open-source implementation of NICE can be found at https://github.com/ADMAntwerp/NICE.

A Appendix

1.1 A.1 Examples time complexity

With respect to NICE, recall that the worst case time complexity (Table 3 in Sect. 3.2) is related to both the k and m values of the treated dataset. More specifically, let us consider two datasets from Table 4, namely “adult” where $k=0.8\cdot 48,842=39,073$ and $m=14$ and “clean2” where $k=6598\cdot 0.8=5278$ and $m=168$. in Tables 12 and 13. In both tables, we repeat the worst case time complexity of each of the four variations of NICE, along with the CPU times obtained for both the ANN and RF classifiers. Furthermore, we “fill in” the complexity functions based on the specific k and m values of the two datasets, which results in an Order of #“operations”.

In both tables we observe that the Order of #“operations” can become quite large (we intentionally chose two datasets with some of the largest k and m values), but that the impact on the CPU times remains limited. E.g., for “adult” with the ANN, the CPU times remain below 100 milliseconds. Even with a higher value for m (ANN for “clean2”) the CPU times are still quite small. The only noticeable increase comes from NICE(plaus), which can be attributed to the AE. For the RF classifier, we notice the CPU times are in general larger than those for the ANN, but are still below 2 s, with NICE(plaus) being the only real exception.

In summary, the CPU times remain small, even for some of these larger (in terms of k and m values) datasets. However, the frequent use of an AE for NICE(plaus) can have a negative impact, as can be seen in particular for “clean2” in Table 13 (the constant by which g(x) is multiplied is much larger than for “adult”). Combined with the RF classifier requiring considerable more CPU time than the ANN classifier,⁹ we conclude that the largest CPU times occur for NICE(plaus) with the RF classifier, which can also be observed from Tables 5 and 6, but that NICE’s CPU times remain within reasonable bounds.

1.2 A.2 Hyperparameters classification models

For both classifiers we used the scikit-learn Pedregosa et al. (2011) implementation which is sklearn.ensemble.RandomForestClassifier for an RF and sklearn.neural_network.MLPclassifier for an ANN. A five-fold cross-validation grid search is performed with the values of Table 14 where the best performing model is selected based on the ROC AUC score. For the RF the hyperparameter class_weight is set to “balanced” and all other hyperparameters are set to default. The ANN always consists of one hidden layer for which the number of neurons in the grid is relative to the size of the input layer (k) with a minimum of 2 neurons. For example for dataset clean2, the number of input neurons is 168, which results in the following grid for the hyperparameter hidden_layer_sizes: 2, 25, 50, 76, 101, 126, 151, 176, 202, 227 and 252.

Table 12 Example dataset “adult” ($k=39,073$; $m=14$)

Table 13 Example dataset “clean2” ($k=5278$; $m=168$)

Table 14 Hyperparameter grid used in both cross-validations

1.3 A.3 Multi-class Reward Functions

To apply NICE to multi-class, our reward functions need a more general definition. For binary classification we assumed two classes (-1 and 1) for which a classifier f maps $\mathbb {R}^m$ in the class score vector such that $f(x) \in [-1,1]$. For multi-class classification, it is no longer possible to project the scores of our model in such a one-dimensional vector. Therefore, we assume a m-dimensional feature space $X \subset \mathbb {R}^m$ consisting of both categorical and numerical features, a feature vector $x\in X$ with a corresponding label denoted as $y \in Y = \{0,n\}$ and a trained classification model h that maps $\mathbb {R}^m$ in an n-dimensional class probability vector where $h_i(x)$ corresponds to the probability of x belonging to class i.

There are two options to generate multi-class counterfactual explanations Vermeire et al. (2022). First, one might be interested in a counterfactual explanation from a specific class and second, one might be interested in a counterfactual explanation from any class. We propose the following general reward function for both cases.

$$\begin{aligned} R(x) = \frac{(h_c(x_{i-1,b})-h_o(x_{i-1,b}))-((h_c(x)-h_o(x))}{sparsity(x_{i-1,b},x)} \end{aligned}$$

(5)

Equation (5) can be simplified as follows because the sparsity increase in every step is equal to 1.

$$\begin{aligned} R(x) = h_c(x_{i-1,b})-h_0(x_{i-1,b})-h_c(x)+h_0(x) \end{aligned}$$

(6)

The definition of $h_c$ and $h_o$ is different depending on the type of counterfactual we are looking for. To find a valid counterfactual from a specific class, the probability of this class has to be higher than the probability of all other classes. In this case the counterfactual probability $h_c$ is equal to the probability of this specific class c, and $h_o$ is the maximum probability of all other class probabilities:

$$\begin{aligned} h_o(x)= max\{h_i(x): i \in [0,n ]\sim c\} \end{aligned}$$

(7)

For the second case, where we look for a counterfactual from any class, we want any class probability to be higher than the probability of the original class. In this case we define $h_o$ as the probability of the class for which the original instance to explain had the highest probability and $h_c$ as the maximum probability of all other classes.

$$\begin{aligned} h_c(x)= max\{h_i(x): i \in [0,n ]\sim o\} \end{aligned}$$

(8)

The proposed reward function in Equation (6) can be reduced to our reward function (2) for binary classification. To do this we have to project the probabilities of both classes into the one dimensional score vector [-1,1 ]by taking the following assumptions:

$$\begin{aligned} h_0(x) = \hat{y}\cdot \frac{-f(x)-1}{2} \text { and } h_c(x) = \hat{y}\cdot \frac{f(x)+1}{2} \end{aligned}$$

(9)

Replacing these in Eq. 6 results in:

$$\begin{aligned} R(x)= & {} \hat{y}\cdot \left( \frac{f(x_{i-1,b})+1}{2}-\frac{-f(x_{i-1,b})-1}{2}-\frac{f(x)+1}{2}+\frac{-f(x)-1}{2}\right) \nonumber \\ \end{aligned}$$

(10)

$$\begin{aligned} R(x)= & {} \hat{y}\cdot (f(x_{i-1,b})-f(x)) \end{aligned}$$

(11)

which is equal to our sparsity reward function (2).