Explanations of model predictions with live and breakDown packages

Complex models are commonly used in predictive modeling. In this paper we present R packages that can be used to explain predictions from complex black box models and attribute parts of these predictions to input features. We introduce two new approaches and corresponding packages for such attribution, namely live and breakDown. We also compare their results with existing implementations of state of the art solutions, namely lime that implements Locally Interpretable Model-agnostic Explanations and ShapleyR that implements Shapley values.


Introduction
Predictive modeling is a very exciting field with a wide variety of applications. Lots of algorithms have been developed in this area. As proven in many Kaggle competitions (Fogg, 2016), winning solutions are often obtained with the use of elastic tools like random forest, gradient boosting or neural networks.
These algorithms have many strengths but they also share a major weakness, which is deficiency in interpretability of a model structure. A single random forest, an xgboost model or a neural network may be parameterized with thousands of parameters which make these models hard to understand. Lack of interpretability results in the lack of trust in model predictions. Lack of trust is a major obstacle when one thinks about applications in regulated areas such as personalized medicine or similar fields. An interesting example of a situation in which trust issues are fully justified is presented in Tulio Ribeiro et al. (2016b). Authors compare two classifiers that were trained to recognize whether a text describes Christianity or Atheism. After explanations were provided, it turned out that the model with superior performance in the test set often based its prediction on irrelevant words, for example prepositions. To overcome this problem, the interpretability of complex machine learning models has been a subject of much research, devoted partially also to model visualization. Find some examples in Štrumbelj and Kononenko (2011); Tzeng and Ma (2005); Zeiler and Fergus (2014).
The general approach to interpretability is to identify important variables (features) in the model and then learn the expected model response for a single variable. A description of a general framework of permutation-based variable importance rankings may be found in Altmann et al. (2010). An interesting and widely adopted tool for estimation of marginal model response are Partial Dependency Plots (see Friedman (2001)), that presents the marginal relation between the variable of interest and a single variable from the model. An effective and very elastic implementation of this method is available in the pdp package for R (see Greenwell (2017)). This method has many extensions such as for example Individual Conditional Expectations (Goldstein et al. (2015)). The ICE method allows for tracing predictions for individual variables and it is very useful for identification of interactions. On the other hand, ALE plots (Apley (2016)) were proposed as a superior tool for handling strongly correlated predictors by describing conditional distribution of predicted values. This method can be used to assess both main effects and interactions between predictors. All these methods are focused on the effect of a single variable or small set of variables within the black box model.
A different approach is presented in the article Tulio Ribeiro et al. (2016b). The authors propose LIME (Locally Interpretable Model agnostic Explanations) as a method for explaining black box predictions by fitting an interpretable model locally around a prediction of interest. This methodology was illustrated with examples from image and text classification areas. Later, it was extended by Puri et al. (2017) to MAGIX methodology (Model Agnostic Globally Interpretable Explanations) and modified by the authors of the original article to aLIME (anchor-LIME) in Tulio Ribeiro et al. (2016a).
So far, two implementations of the method have been found. Python library was developed by the authors of the original article and it is available on GitHub at https://github.com/marcotcr/lime. It works for any text or image classifier as well as for tabular data. Regression models can be explained using simple linear regression. The R package lime which is a port to the original Python package is maintained by Thomas Lin Pedersen. This package works with tabular and text data and handles all models supported by either caret or mlr package and it can be easily extended to work with other models. Neither of the packages implements sp-LIME algorithm that was proposed in the original article to choose representative observations that would explain the behavior of the model globally.
In this article we give a short overview of methods for explaining predictions made by complex models. We also introduce two new methods implemented in R packages live and breakDown.

Related work
In this section we present two most recognized methods for explanations of a single prediction from a complex black box model.

Locally Interpretable Model-agnostic Explanations (LIME)
In 2016 Tulio Ribeiro et al. (2016b) proposed LIME method for explaining prediction for a single observation which takes a significantly different approach compared to the methods described above. The algorithm is designed to explain predictions of any classifier and it works primarily for image and text data. First, original observation of interest is transformed into simplified input space of binary vectors (for example presence or absence of words). Then a dataset of similar observations is created by sampling features that are present in the representation of the explained instance. Closeness of these observations to the original observations is measured via specified similarity kernel. This distance is taken into account while the explanation model is fitted to the new dataset. The interpretable model can be penalized to assure that it does not become too complex itself.

Shapley values (SHAP)
In 2017 Lundberg and Lee (2017) introduced a general framework for explaining machine learning models that encompasses LIME among other methods. The method is associated with some specific visualization techniques that present how predictors contribute to the predicted values. In this framework, observations are transformed into the space of simplified inputs. Explanation models are restricted to the so-called additive feature attributions methods, what means that values predicted by the explanation model are linear combinations of these binary input vectors. Formally, if z = (z 1 , . . . , z p ) is a vector in simplified inputs space and g is the explanation model, then where φ j , j = 0, . . . , M are weights. These weights measure how each feature contributes to the prediction. Authors prove that in this class of explanation models Shapley values provide unique solutions to the problem of finding optimal weights φ j that assure that the model has desirable properties of local accuracy and consistency. For formal treatment and examples, please refer to the original article Lundberg and Lee (2017). SHAP values cannot currently be computed using any R package available on CRAN, but a development version of the package can be found on https://github.com/redichh/ShapleyR.

Local Interpretable Visual Explanations (LIVE)
The next two sections introduce two alternative approaches to explaining model predictions. Both of them are implemented in R packages, live and breakDown, respectively.

Motivation
live is an alternative implementation of LIME for regression problems, which emphasizes the role of model visualization in understanding of complex models. In comparison with the original LIME, both the method of local exploration and handling of interpretable inputs are changed. Dataset for local exploration is simulated by perturbing the explained instance one feature at a time. The process is described in section 2.3.2. All generated observations are treated as similar to the observation of interest and thus the identity kernel is used. Original variables are used as interpretable inputs. Interpretability of the local explanation comes from a tractable relationship between inputs and the predicted response. Variable selection is optional for linear regression when sparsity is required.
One of the main purposes of live is to provide tools for model visualization, which is why in this package emphasis is put on models that are easy to visualize. For linear models, waterfall plots can be drawn to present how predictors contribute to the overall model score for a given prediction, while forest plots (Kennedy, 2017) can be drawn to summarize the structure of local linear approximation. Examples clarifying both techniques are given in section 2.5. Other interpretable models that are equipped with generic plot function can be visualized, too. In particular, decision trees which can be plotted using partykit package are well suited for this task, as they can help discover interactions. The package uses the mlr interface to handle machine learning algorithms, hence any classifier or regression method supported by mlr can be used as a black box model and similarly any classifier or regression method can be used as an interpretable model.

Methodology
live package uses a two-step procedure to explain prediction of a selected black box model in the point x. First, an artificial dataset X is created around point x. Second, the white box model is fitted to the model predictions in points X . The first step is described by the Algorithm 1. When the number of predictors is smaller than or equal to the desired size of the simulated dataset for local exploration, it is created in accordance with the following procedure. When the number of predictors is bigger than the size of fake dataset, a Algorithm 1 Simulating X -surroundings around the selected x. For the remaining n -p observations, proceed as in case p > n.

13:
end for 14: end if random subset of n predictors is chosen, where n is the number of observations, and the procedure described above is performed on this subset. In other words, the procedure amounts to iterating over the set of n observations identical to a given instance and changing the value of one variable at each step. Current implementation of this algorithm relies on data.table package for performance (Dowle and Srinivasan, 2017).

Model agnostic greedy explanations of model predictions (breakDown)
Motivation live package approximates the local structure of the black box model around a single point in the feature space. The idea behind the breakDown is different. In case of that package the main goal is to decompose model predictions into parts that can be attributed to particular variables. It is straightforward for linear (and more general: additive) models. Below we present a model agnostic approach that works also for nonlinear models.
Let us use the following notation: x = (x 1 , x 2 , ..., x p ) ∈ X ⊂ R p is a vector in feature space X. f : X → R is a scoring function for the model under consideration, that may be used for regression of classification problems. X train is a training dataset with n observations. For a single observation x new the model prediction is equal to f (x new ). Our goal is to attribute parts of this score to variables (dimensions) in the X space.

The lm-break: version for additive models
For linear models (and also generalized linear models) the scoring function (e.g. link function) may be expressed as linear combination of feature vectors.
In this case it is easy to attribute the impact of feature x i to prediction f (x new ). The most straightforward approach would be to use the x new i β i as the attribution. However, it is easier to interpret variable attributions if they are invariant to scale-location transformations of x i , such as change of the unit or origin. This is why for linear models the lm-break variable attributions are defined as (x new i −x i )β i . The equation 1 may be rewritten as follows: Components (x new i −x i )β i are all expressed in the same units. For lm and glm models these values are calculated and plotted by the generic broken() function from the breakDown package.

The ag-break: model agnostic approach
Interpretation of lm-break attributions is straightforward, but limited only to additive models. In this section we present an extension for non-additive models. This extension uses additive attributions to explain predictions from non-additive models thus some information about the model structure will be lost. Still, for many models such attribution may be useful. For additive models the ag-break approach gives the same results as lm-break approach.
The intuition behind ag-break approach is to identify components of x new that cannot be changed without a significant change in the prediction f (x new ). In order to present this approach in a more formal way, we first need to introduce some definitions.

Definition 2.4.1 (Relaxed model prediction)
Thus f IndSet (x new ) is an expected value for model response conditioned on variables from set IndSet in such a a way, that ∀ i∈IndSet the intuition behind relaxed prediction is that we are interested in an average model response for observations that are equal to x new for features from IndSet C set and follow the population distribution for features from IndSet set. Clearly, two extreme cases are which is the case of no relaxation, and which corresponds to full relaxation. We will say that a variable was relaxed, when we do not fix its value and we let it follow the population distribution. This will play a crucial part in the algorithm presented in this section.
Since we do not know the joint distribution of x, we will use its estimate instead.
We will omit the dashes to simplify the notation.
Definition 2.4.2 (Distance to relaxed model prediction) Let us define the distance between model prediction and relaxed model prediction for a set of indexes IndSet.
It is the difference between model prediction for observation x new and observation relaxed on features indSet. The smaller the difference, the less important are variables in the indSet set.

Definition 2.4.3 (Added feature contribution)
For j-th feature we define its contribution relative to a set of indexes IndSet (added contribution) as It is the change in model prediction for x new after relaxation on j.
The model agnostic feature contribution is based on distances to relaxed model predictions. In this approach we look for a series of variables that can be relaxed in such a way so as to move model prediction from f (x new ) to a fully relaxed prediction E[ f (x)] (expected value for all model predictions). The order of features in this series is important. But here we use a greedy strategy in which we add features to the indSet iteratively (one feature per iteration) and minimize locally the distance to relaxed model prediction.
This approach can be seen as an approximation of Shapley values where feature contribution is linked with the average effect of a feature across all possible relaxations. These approaches are identical for additive models. For non-additive models the additive attribution is just an approximation in both cases, yet the greedy strategy produces explanations that are easier to interpret. It is worth noting that similar decomposition of predictions and measures of contribution for classifiers have been examined in Robnik-Šikonja and Kononenko (2008).
The greedy search can start from a null set of indexes (then in each step a single feature is being relaxed) or it can start from a full set of relaxed features (then in each step a single feature is removed from the set). The above approaches are called step-up and step-down, respectively. They are presented in algorithms 2 and 3.
The algorithm 2 presents the procedure that generates a sequence of variables with increasing contributions. This sequence corresponds to variables that can be relaxed in such a way so as to minimize the distance to the original prediction. The resulting sequence of Contributions and Variables may be plotted with Break Down Plots, see an example in Figure 2. Figure 1 summarizes the idea behind algorithm 2. By relaxing consecutive variables one finds a path between single prediction and average model prediction.
One can also consider an opposite strategy -instead of starting from IndSet = {1, . . . , p} one can start with IndSet = ∅. That strategy is called step-up approach and it is presented in Algorithm 3.
Algorithm 2 Model agnostic break down of model predictions. The step-down approach. Find and remove j that minimizes loss 10: j min ← arg min j dist(j) 11: Variables ( Find and add j that maximize distance 10:

Case study: How good is this red wine?
Wine quality data (Cortez et al., 2009) is a well-known dataset which is commonly used as an example in predictive modeling. The main objective associated with this dataset is to predict the quality of some variants of Portuguese "Vinho Verde" on the basis of 11 chemical properties. A single observation from the dataset can be found in Table 1. According to the results from the original article, the Support Vector Machine (SVM) model performs better than other models including linear regression, neural networks and others.
In this section we will show how live package can be used to fit linear regression model locally and generate a visual explanation for the black box model as well as how breakDown package can be used to attribute parts of the final prediction to particular features. The SVM model used in this example is trained with the use of e1071 package.
l i b r a r y ( " e1071 " ) wine_svm_model <− svm ( q u a l i t y~. , data = wine ) Different approaches for explaining single predictions are illustrated on the basis of the prediction for the fifth wine from this dataset, the one presented in table 1. The actual quality of this wine is 5, while the quality predicted by the SVM model is 5.03.

The live package
The live package approximates black box model (here SVM model) with a simpler white box model (here linear regression model) to explain the local structure of a black box model and in consequence to assess how features contribute to a single prediction.
To do this, we first need to generate artificial observations around the selected observation x new for local exploration. We use sample_locally function from live package. If multiple models are to be explained, there is no need to generate multiple artificial datasets. Predictions of each model on a single simulated dataset can be added with the use of add_predictions function. A different object should be created for each model, but the same result of a call to sample_locally function should be used as the to_explain argument. Black box model can be passed as a model object or as a name of mlr learner. While the object created by sample_locally function stores the dataset and the name of the response variable, the object returned by add_predictions function also stores the fitted black box model. The result of applying sample_locally functions does not contain the response but the result of add_predictions contains a column with model predictions, which has the same name as response in the original dataset.
Once the artificial data points around x new are generated, we may fit the white box model to them. In this example we fit a linear regression model using fit_explanation function.
wine_expl <− f i t _ e x p l a n a t i o n ( l i v e _ o b j e c t = s i m i l a r , white_box = " r e g r . lm " )  p l o t _ e x p l a n a t i o n ( model = wine_expl , r e g r _ p l o t _ t y p e = " f o r e s t p l o t " , e x p l a i n e d _ i n s t a n c e = wine [ 5 , ] ) p l o t _ e x p l a n a t i o n ( model = wine_expl , r e g r _ p l o t _ t y p e = " w a t e r f a l l p l o t " , e x p l a i n e d _ i n s t a n c e = wine [ 5 , ] ) In case of datasets with larger number of variables, we could obtain sparse results by setting selection = TRUE in the fit_explanation function. This option allows for performance of variable selection based on LASSO implemented in glmnet ((Friedman et al., 2010), (Simon et al., 2011)). When using Generalized Linear Model as a white box model it is possible to set family argument to one of the distribution families available in glm and glmnet functions via response_family argument to fit_explanation.

The lime package
The LIME method is implemented in the R package lime (Pedersen and Benesty, 2017). It produces sparse explanations by default.
In the first step a lime object is created for a specified dataset and a fitted black box model. l i b r a r y ( " lime " ) wine_expl <− lime ( nobs , wine_svm_model ) Then we use the explain function, which in case of regression takes the observation of interest, lime object and the number of top features to be used for explanation. In this case data is low dimensional, hence we can use all predictors. Alternatively, we could set feature_select to none to skip the selection part. model_type . svm <− f u n c t i o n ( x , . . . ) " r e g r e s s i o n " svm_explained <− e x p l a i n ( nobs , wine_expl , n _ f e a t u r e s = 1 1 ) p l o t _ e x p l a n a t i o n ( svm_explained ) Results produced by the plot_explanation function are presented in Figure 5.

The breakDown package
The breakDown package directly calculates variable attributions for a selected observation. It does not use any surrogate model.
The broken() function is used to calculate feature attributions. Generic functions print() and plot() show feature attributions as texts or waterfall plots. The baseline argument specifies the origin of a waterfall plot. By default, it is 0. Use baseline = "intercept" to set the origin to average model prediction.  The only R package for Shapley values is at the development stage. It can be found at the address https://github.com/redichh/ShapleyR. So far, it allows user to compute Shapley values. It uses the mlr interface to train models, what means that first, we need to create mlr task, and then pass it to shapley function along with the row number of an observation for which we explain the prediction and an mlr object with fitted model. l i b r a r y ( s h a p l e y r ) t s k <− makeRegrTask ( " wine " , wine , " q u a l i t y " ) shp <− shapley ( 5 , model = t r a i n ( " r e g r . svm " , t s k ) , t a s k = t s k ) In

Discussion
In this paper we presented four approaches and four R packages that can be used for explanations of predictions from complex black box models. Two of them have already been introduced in literature, while live and brakDown were introduced in this article for the first time.
All four approaches are model agnostic in a sense that, the method does not depend on any particular structure of black box model. Yet there are also some differences between these approaches.
• Surrogate models vs. conditional expected responses. live and lime packages use surrogate models (the so-called white box models) that approximate local structure of the complex black box model. Coefficients of these surrogate models are used for explanations. Unlike them, breakDown and shapleyr construct feature attributions on the basis of conditional responses of a black box model.
• live and lime packages differ in terms of the manner in which the surrounding of x new is defined. This task is highly non-trivial especially for mixed data with continuous and categorical features. live does not use interpretable input space (and so does not fall under the additive feature attribution methods category), but approximates the black box model directly in the data space, what can be considered a more effective use of data. It comes with no theoretical guarantees that are provided for Shapley values, but apart from being very intuitive, it offers several tools for visual inspection of the model.
• shapleyr and breakDown take conditional expectation of the predictor function with respect to explanatory features. They differ in terms of the manner in which conditioning is applied to calculating feature attributions. shapleyr is based on results from game theory; in this package contribution of a single feature is averaged across all possible conditionings. breakDown uses a greedy approach in which only a single series of nested conditionings is considered. The greedy approach is easier to interpret and faster to compute. Moreover, exact methods of computing Shapley values exist only for linear regression and tree ensemble models. Approximate computations are also problematic, as they require the choice of number of samples of subsets of predictors which will be used. These two methods produce nearly identical results for linear models (see table Table 2), but for more complex models the estimated contributions can be very different, even pointing in opposite directions. An advantage of Shapley values are proven theoretical properties, though they are restricted to explanation models that belong to the additive feature attribution methods class.
• When parameters (kernel and regularization term) are chosen as in Lundberg and Lee (2017), lime produces estimates of Shapley values, while other choices of kernel and penalty term lead to inconsistent results. The fact that the suggested penalty term is equal to 0 can be considered a huge limitation of LIME and SHAP, because in this setting they will not produce sparse explanations.
• All presented methods decompose final prediction into additive components attributed to particular features. This approach will not work well for models with heavy components related to interactions between features.
Comparison of the methods presented in the previous section is far from being comprehensive. More research is needed to better understand differences between these approaches and new approaches are needed to overcome constraints listed above. Nevertheless, the availability of the mentioned packages creates an opportunity for further studies on model exploration.