LIMEtree: Unified Multi-class Explanations

• LIMEtree is a model-agnostic multi-output surrogate that generates unified, faithful explanations across all classes with coherent counterfactual reasoning.
• It employs a multi-output regression tree to capture cross-class dependencies, offering consistent tree visualizations, feature importances, and decision rules.
• Experimental results indicate up to a 25% improvement in user accuracy for counterfactual queries compared to classic LIME, with lower fidelity loss.

LIMEtree is a model-agnostic local surrogate explanation approach specifically designed to provide faithful and interpretable multi-class explanations for predictions from black-box models. Unlike standard LIME, which fits an independent surrogate per class using linear models, LIMEtree employs a multi-output regression tree to generate a single, unified explanation for all classes relevant to a given prediction. This paradigm shift enables a consistent exploration of cross-class dependencies, coherent counterfactual reasoning, and a substantial expansion of the types of explanations available to end users (Sokol et al., 2020).

1. Motivation for Multi-Class Surrogate Explanations

Standard single-class surrogate explainers such as LIME produce one explanation per class in a one-vs-rest framework, resulting in fragmented or even contradictory evidence across classes. They are fundamentally limited in answering critical decision-support queries, e.g., "Why class A and not class B?", "How would the model’s confidence in class B change if feature $x_1$ were absent?", or "Which features drive the top predictions collectively?" In contrast, the multi-class paradigm, implemented via LIMEtree, aims to answer such queries coherently by modeling the joint dependencies between all predicted classes. A single surrogate structure predicts the probability vector for all classes, ensuring internal consistency and effective cross-class reasoning at the instance level (Sokol et al., 2020).

2. Formal Framework and Algorithmic Structure

LIMEtree operates on a formalized local surrogate objective. Let:

• $\mathcal X \subseteq \mathbb R^m$ denote the original input space;
• $f: \mathcal X \to [0,1]^n$ be the black-box predictor returning the probability vector over $n$ classes;
• $\phi: \mathcal X\to \{0,1\}^d = \mathcal X'$ be a binarizing interpretable representation (IR), such as superpixel presence in images or quantized bin features in tabular data;
• $\phi^{-1}: \mathcal X'\to\mathcal X$ be an (approximate) invertible mapping.

Sampling in the $d$-dimensional IR space produces a set $\{x'_i\}_{i=1}^N \subset \mathcal X'$. For each point, the black-box provides $y_i = f(\phi^{-1}(x'_i))\in [0,1]^n$. The kernelized neighborhood weight is $\omega(x';x'_0) = \kappa(\ell(x',x'_0))$ (e.g., Hamming/cosine distance and a unimodal kernel). LIMEtree then fits a multi-output regression tree $T$ as:

$\min_{T}\,\, \mathcal L(f,T) + \Omega(T)$

where

$$\mathcal L(f,T) = \frac{1}{\sum_{i=1}^N \omega(x'_i;x'_0)} \sum_{i=1}^N \omega(x'_i;x'_0) \|f(\phi^{-1}(x'_i)) - T(x'_i)\|_2^2,$$

and $\Omega(T)$ penalizes tree size or depth to enforce interpretability.

At each node, candidate binary feature splits $j \in \{1,\dots,d\}$ are evaluated by weighted reduction in total MSE across all $n$ outputs. The tree grows until depth reaches the specified maximum $D$ or the leaf-level mean squared loss drops below a threshold $\varepsilon$. Optionally, post-processing ensures model-driven fidelity by assigning leaf predictions based on querying $f$ at minimally activated IR inputs (Sokol et al., 2020).

3. Types of Explanations Enabled by LIMEtree

A single multi-output tree structure provides a unified basis for diverse, consistent, and expressive explanation forms:

• Tree visualization: Subtrees on top-predicted classes illustrate which IR features (e.g., superpixels or tokens) drive changes across class probabilities.
• Tree-based feature importance: Aggregates Gini or MSE impact across all outputs, identifying globally influential features.
• Decision rules (root-to-leaf paths): Conjunctions of binary IR conditions delineate local regions of the input where class probabilities are approximately constant.
• Exemplar explanations: For any leaf, a minimally present IR instance is mapped back to input space, e.g., the most occluded image with still-high class confidence.
• What-if/counterfactual queries: Users can edit IR features and traverse the tree to update predictions, supporting reasoning about hypothetical scenarios.
• Counterfactual extraction: By comparing decision paths, LIMEtree delivers minimal changes necessary to shift from a predicted class A to B, directly addressing "Why A rather than B?" questions.

These explanation forms can all be derived consistently from the same underlying structure, unlike the fragmented output of single-class LIME (Sokol et al., 2020).

4. Experimental Validation and Comparative Results

LIMEtree was evaluated on both synthetic and real-world tasks using image (ImageNet+Inception v3, CIFAR-10+ResNet56, CIFAR-100+RepVGG) and tabular datasets (Wine+LogisticRegression, CoverType+MLP). Results demonstrated:

• At two-thirds of LIME’s complexity (measured, e.g., by tree depth), LIMEtree achieves lower loss $\mathcal L$ (higher fidelity) than linear LIME across both modalities.
• In deterministic IR settings (image superpixels), an unbounded-depth tree (TREE$^\dagger$) can achieve zero loss by covering all $2^d$ IR instances; for tabular data with non-deterministic IR, zero loss is unattainable but tree fidelity still steadily improves with depth, unlike LIME’s stagnation.
• Post-processing for model-driven faithfulness (TREE$^\ddagger$) keeps additional complexity low while driving loss near zero in images.
• In a user study, LIMEtree exhibited a $\sim$25% improvement in users' accuracy at answering counterfactual queries compared to LIME, attributed to consistency and direct counterfactual paths despite increased visual complexity (Sokol et al., 2020).

5. Practical Considerations

LIMEtree provides a universal, post-hoc methodology: It is model-agnostic (works for any $f$) and data-universal (provided an appropriate IR $\phi$ can be constructed). Efficiency is high for moderate IR dimensionality ($d<20$), with runtimes typically $\ll 1$ second due to binary splits and small datasets local to each instance. However, interpretability may suffer for high-$d$ IRs due to exponential tree size; in such cases, feature importance and counterfactual queries remain concise even if the tree diagram is unwieldy.

LIMEtree is particularly recommended for scenarios demanding coherent, multi-class local explanations and quantified fidelity guarantees, provided IR discretization is of moderate size and (for global fidelity) invertible.

Known limitations include the potential non-invertibility of tabular IR encoding (complicating certain explanation types' fidelity) and declining readability for deep trees (Sokol et al., 2020).

6. Relationship to Other Tree-Based Surrogate Approaches

Tree-based LIME variants have been proposed in other contexts. Tree-LIME (Shi et al., 2019) replaces the linear model in classical LIME with a regression tree, capturing nonlinear feature interactions and yielding shallow, human-comprehensible surrogate models for a single class. It is formalized with a weighted squared error loss plus tree depth regularization and operationalized via weighted MSE splits (CART). Unlike LIMEtree, Tree-LIME does not produce a multi-output surrogate and thus does not guarantee mutual consistency among class explanations. Similarly, a decision-tree variant of autoencoder-weighted LIME (“tree-ALIME” or "LIMEtree" [Editor’s term]) shows competitive local fidelity and interpretability benefits on mixed tabular and text domains, but is still limited to single-class logic per local model (Ranjbar et al., 2022).

A summary table:

Method	Surrogate Model	Multi-class Consistency	Data Types
LIME (classic)	Separate linear per class	None	Image, tabular, text
Tree-LIME	Separate CART per class	None	Image
LIMEtree	Single multi-output CART	Yes	Image, tabular, text
tree-ALIME	Single-output CART, AE kernel	No	Tabular, text

All methods are model-agnostic and post-hoc; only LIMEtree achieves guaranteed cross-class consistency and direct support for multi-class counterfactuals.

7. Limitations and Future Directions

The scalability of LIMEtree is fundamentally bounded by IR dimensionality. When $d$ is large, full enumeration becomes computationally infeasible, necessitating sampling strategies and complexity regularization. Interpretability of the tree structure also deteriorates with depth, motivating reliance on feature importance, what-if, and counterfactual tools for explanation. For tabular data, the non-invertibility of the IR mapping precludes full fidelity for some explanation types except via model-driven counterfactual leaves. Stability metrics for trees may require refinement, as the underlying selection of IR features can introduce sensitivity to sampling choices (Ranjbar et al., 2022).

Potential extensions include adaptive depth penalties, alternative surrogate classes (rule lists or decision sets), manifold-aware perturbation for improved locality, and enhanced interactive interfaces for end users (Sokol et al., 2020).

---

LIMEtree, by providing a unified and consistent surrogate framework for multi-class local explanations, expands the explainability toolkit available for complex black-box models in a manner appropriate for rigorous, decision-critical application scenarios. Its foundational innovations in multi-output surrogate modeling, instance-level counterfactual reasoning, and breadth of explanation forms reflect a significant advance in the domain of post-hoc interpretability.