ConLUX: Concept-Based Local Unified Explanations

## Abstract

Abstract With the rapid advancements of various machine learning models, there is a significant demand for model-agnostic explanation techniques, which can explain these models across different architectures.
Mainstream model-agnostic explanation techniques generate local explanations based on basic features (e.g., words for text models and (super-)pixels for image models). However, these explanations often do not align with the decision-making processes of the target models and end-users, resulting in explanations that are unfaithful and difficult for users to understand.
On the other hand, concept-based techniques provide explanations based on high-level features (e.g., topics for text models and objects for image models), but most are model-specific or require additional pre-defined external concept knowledge.
To address this limitation, we propose ConLUX , a general framework to provide concept-based local explanations for any machine learning models.
Our key insight is that we can automatically extract high-level concepts from large pre-trained models, and uniformly extend existing local model-agnostic techniques to provide unified concept-based explanations.
We have instantiated ConLUX on four different types of explanation techniques: LIME, Kernel SHAP, Anchor, and LORE, and applied these techniques to text and image models.
Our evaluation results demonstrate that 1) compared to the vanilla versions, ConLUX offers more faithful explanations and makes them more understandable to users, and 2) by offering multiple forms of explanations, ConLUX outperforms state-of-the-art concept-based explanation techniques specifically designed for text and image models, respectively.

## 1 Introduction

As machine learning models become more complex and popular, it has become an emerging topic to explain the rationale behind their decisions.
In particular,
as the structure of machine learning models diversifies and evolves rapidly, and effective closed-source models (e.g., GPT-4 (Achiam et al., ) and Gemini (et al., )) become more prevalent,
model-agnostic explanation techniques show their appeal due to their adaptability to various models and tasks (Wang, ).
These techniques consider target models as black boxes, so they can explain any machine learning model without requiring any knowledge of the model’s internal structure.
This paper addresses the challenge of incorporating high-level concepts into local model-agnostic techniques to explain the decision-making processes of various machine learning models, including large language models (LLMs).

To faithfully explain the behavior of machine learning models, it is essential to provide explanations built from language components aligned with the decision process of the target models; to make explanations easy to understand, it is also crucial to provide explanations built from user-friendly language components.
Unfortunately, mainstream model-agnostic explanation techniques often fail to meet both requirements, as they provide explanations built from basic features (e.g., words for text models and (super-)pixels for image models) (Ribeiro et al., ; Lundberg & Lee, ; Ribeiro et al., ; Guidotti et al., ).
In contrast, many concept-based techniques provide explanations based on high-level features (e.g., topics in texts and objects in images) (Poeta et al., ).
These techniques either utilize the internal information of the target models like gradients, activations, and attention weights (Zhang et al., ; Yeh et al., ; ; Cunningham et al., ; Ghorbani et al., ; Crabbé & van der Schaar, ), or pre-defined external knowledge (El Shawi, ; Fel et al., ) to build high-level concepts.
This limits these techniques to specific types of models or tasks.
Furthermore, while there are different forms of explanations (e.g. feature attributions, rules) for various purposes (Zhang et al., ), existing concept-based explanations mainly focus only on attributions, which limits their fidelity and applicability.

To bridge this gap, we aim to elevate the explanations of various forms provided by existing model-agnostic techniques from feature-level to concept-level.
As we focus on explaining the decision-making process of machine learning models to end-users, we put our emphasis on local explanations, which are more tractable for end-users.
Moreover, we observe that various large pre-trained models provide a unified way to extract high-level concepts across different tasks.
To this end, we propose ConLUX, a general framework that automatically incorporates high-level concepts into various existing local model-agnostic techniques for any machine learning models, and provides local explanations in various forms for diverse user needs.

Figure: Figure 1: Example explanation (a) is generated by LIME, demonstrating how each word in the input sentence contributes to the target model’s prediction. The color intensity reflects the magnitude of the weight, with deeper hues indicating larger absolute values. Example explanation (b) is generated by ConLUX-augmented LIME, providing an explanation based on high-level concepts.
Refer to caption: x1.png

We take three mainstream local model-agnostic techniques, LIME (Ribeiro et al., ), Anchor (Ribeiro et al., ), and LORE (Guidotti et al., ) as examples to illustrate how ConLUX improves local model-agnostic explanations.

Figure 1 shows a LIME explanation for a BERT-based sentiment analysis model on a movie review. The target model classifies the sentence as negative.
LIME provides feature-level attributions, indicating how each word contributes to the model’s prediction.
In this case, LIME assigns high negative scores to the words “however” and “falls”, which indicates that these words contribute much to the negative prediction.
However, this explanation is unfaithful and hard to understand by end-users.
For example, the word “however” is assigned a high negative score, but it functions as a conjunction and does not directly convey sentiment (Liu & Zhang, ).
Moreover, such confusing attributions, combined with an overwhelming amount of attribution information, complicate the explanation for end-users.
ConLUX addresses these issues by elevating the explanation from feature-level to concept-level.
ConLUX-agumented LIME extracts the main topics of the input sentence using GPT-4o, and then provides attribution-based explanations with these topics.
From this explanation, users can easily understand that the negative prediction is mainly because the sentence mentions the movie’s poor performance in “emotion impact” and “direction and script”, while the part about “stunning visuals” and “passable plot” also expresses some positive sentiment.
This explanation faithfully reflects the decision process of the target model and is more understandable to end-users.

Figure: Figure 2: Example explanations generated by LIME (upper) and ConLUX-augmented LIME (lower) for an image classification task.
Refer to caption: x2.png

Figure: Figure 3: Example Anchors, LORE explanations and their ConLUX-augmented versions.
Refer to caption: x3.png

Similar issues exist in the explanation of image models. We use YOLOv8 (Jocher et al., ) to perform an image classification task on ImageNet (Deng et al., ) dataset. Figure 2 shows a LIME explanation for an image classified as a punching bag. LIME attributes high importance to some fragmented superpixels. End-users can hardly understand why these parts are important for the model’s prediction.
ConLUX-agumented LIME provides explanations based on objects detected by Segment Anything Model (SAM) (Kirillov et al., ), and attributes high importance to the punching bag itself and the kid in the image.
This explanation is more faithful and understandable.
End-users can easily realize that the model does not perform perfectly when classifying this image to a punching bag.

Figure 3 shows the explanations generated by Anchor, LORE, and their ConLUX-augmented versions for an image classified as a pickup.
Anchors provides rule-based sufficient conditions (referred to as anchors) for the target model’s prediction. The vanilla anchor indicates that parts of the car and the background house guarantee the prediction as a pickup.
With ConLUX, end-users can easily understand that the model classifies the image as a pickup exactly because it indeed detects the pickup truck in the image.
LORE provides rule-based sufficient conditions and counterfactual explanations. Figure 3 shows the counterfactual explanations, which show users how to change the model’s prediction by modifying the input image.
The vanilla LORE explanation indicates that if we mask a part of the grass, the background house and the whole side window of the truck will change the model’s prediction to a Half track.
In contrast, ConLUX-augmented LORE indicates that users can simply mask the pickup truck to change the model’s prediction to a Bison, which is more user-friendly.

The preceding examples indicate that feature-level explanations are hard to understand by end-users.
On the other hand, as high-level concepts align with the decision process of target models and users better (Zhang et al., ; Ghorbani et al., ; Kim et al., ; Sun et al., ),
ConLUX addresses this by providing concept-level explanations, and the examples demonstrate that ConLUX makes explanations more understandable to end-users.
Moreover, our empirical evaluation shows these concept-level explanations are also more faithful to the models.
Finally, benefiting from the various types of explanations provided by existing local model-agnostic techniques, ConLUX can provide rich explanations including attributions, sufficient conditions, and counterfactuals, satisfying diverse user needs and offering a more comprehensive understanding of the target models.
This fills the current gap in concept-based explanations, which lack forms beyond attributions.

To elevate the explanations provided by existing local model-agnostic techniques from feature-level to concept-level, we modify these techniques in a uniform and lightweight way based on their two commonalities:
1) these techniques use basic features as language components to build explanations;
2) these techniques use a perturbation model, which generates samples similar to the given input by changing some of its feature values, to capture the local behavior of the target model at the feature level.
To this end, by only elevating the language components to high-level concepts and extending the perturbation model to generate samples by changing high-level concepts, ConLUX extends these techniques to provide concept-level explanations.

We evaluated ConLUX on explaining two sentiment analysis models (BERT, Llama 3.1(et al., )) and three image classification models(YOLOv8, Vision Transformer (Oquab et al., ; Darcet et al., ), and ResNet-50 (He et al., )). Our evaluation results demonstrate that ConLUX improves the fidelity of Anchors, LIME, LORE, and Kernel SHAP explanations by 82.21%, 48.59%, 149.93%, and 48.27% respectively, and by considering various forms of explanations together, ConLUX outperforms state-of-the-art concept-based explanation techniques specifically designed for text models (TBM (Ludan et al., )) and image models (EAC (Sun et al., )), respectively.

## 2 Preliminaries

In this section, we introduce the background knowledge and notations used in this paper.

##### Machine Learning Models.

We consider a machine learning model as a black-box function $f$ that maps an input vector ${\bm{x}}$ to an output scalar $f({\bm{x}})$.
Formally, we let $f:{\mathbb{X}}\rightarrow\mathbb{R}$, where ${\mathbb{X}}$ is the input domain.
For models that take fixed-dimension inputs, let ${\mathbb{X}}=\mathbb{R}^{n}$.
For models capable of handling inputs of arbitrary dimensions, let ${\mathbb{X}}=\cup_{i=1}^{\infty}\mathbb{R}^{i}$.
Let ${\bm{x}}_{i}$ denote the $i$-th feature value of ${\bm{x}}$.

##### Local Model-Agnostic Explanation Techniques.

A local model-agnostic explanation technique $t$ takes a model $f$ and an input ${\bm{x}}$, and generates a local explanation $g_{f,{\bm{x}}}$ to describe the behavior of $f$ around ${\bm{x}}$, i.e., $g_{f,{\bm{x}}}:=t(f,{\bm{x}})$.
$g_{f,{\bm{x}}}$ ($g$ for short) is an expression formed with predicates. Each predicate $p$ maps an input ${\bm{x}}$ to a binary value, i.e., $p:{\mathbb{X}}\rightarrow\{0,1\}$, indicating whether ${\bm{x}}$ satisfies a specific condition.

As shown in Figure 4
Existing local model-agnostic explanation techniques generate explanations following a similar workflow:

- 1.
Producing Predicates: These techniques first generate a set of predicates ${\mathbb{P}}$ based on the input ${\bm{x}}$.
- 2.
Generating Samples: The underlying perturbation model $t_{per}$ generates a set of samples ${\mathbb{X}}^{b}_{s}$ in predicate representations, where each sample ${\bm{z}}^{b}\in{\mathbb{X}}^{b}_{s}$ is a binary vector in $\{0,1\}^{d}$ and ${\bm{z}}_{i}^{b}$ indicates whether the sample satisfies the $i$-th predicate in ${\mathbb{P}}$. The perturbation model then transforms the samples ${\mathbb{X}}^{b}_{s}$ back to the original input space to get ${\mathbb{X}}_{s}$ and $f({\mathbb{X}}_{s})$.
- 3.
Learning Explanation: The underlying learning algorithm generates the local explanation $g_{f,{\bm{x}}}$ consisting of predicates in $P$ using ${\mathbb{X}}_{s}$ and $f({\mathbb{X}}_{s})$.

Figure: Figure 4: The workflow of generating explanations by a local model-agnostic explanation technique.
Refer to caption: x4.png

Mainstream local model-agnostic explanation techniques like Anchors, LIME, LORE, and Kernel SHAP, all follow this workflow. They use the same kinds of predicate sets and perturbation models, and use different learning algorithms to generate explanations with different properties.
In the following, we introduce the main components of the explanation techniques.

Predicate Sets. Given an input ${\bm{x}}$, the corresponding predicate set ${\mathbb{P}}$ is defined as follows:

$$ ${\mathbb{P}}=\{p_{i}|i\in[1,d]\},$ $$

where $d$ is the number of predicates in ${\mathbb{P}}$, a hyperparameter set by users or according to the input data ${\bm{x}}$.
Each $p_{i}$ is a feature predicate that constrains the value of a set of feature values in ${\bm{x}}$, i.e. $p_{i}({\bm{z}}):\bigwedge_{j\in{\mathbb{A}}_{i}}1_{\mathrm{ran}({\bm{x}},j)}(z
_{j})$, where ${\mathbb{A}}_{i}$ is the set of indices of features that $p_{i}$ constrains. Specifically, $\{{\mathbb{A}}_{1},{\mathbb{A}}_{2},...,{\mathbb{A}}_{d}\}$ forms a partition of $\{1,2,\ldots,|x|\}$.
Each $\mathrm{ran}({\bm{x}},j)$ is a set containing $x_{j}$, which is set according to the type of input data. For example, we can use $\mathrm{ran}({\bm{x}},j)=(x_{j}-\epsilon,x_{j}+\epsilon)$ for continuous values, and $\mathrm{ran}({\bm{x}},j)=\{x_{j}\}$ for categorical values.
The predicate $p_{i}$ is a conjunction of indicator functions, each of which
checks if a sample $z$ has a similar value to $x_{j}$ (i.e., $z_{j}\in\mathrm{ran}({\bm{x}},j)$).

Predicate Representations. The predicate representation ${\bm{z}}^{b}\in\{0,1\}^{d}$ of a sample ${\bm{z}}$ is a binary vector where ${\bm{z}}_{i}^{b}=p_{i}({\bm{z}})$.

Perturbation Models. The perturbation model $t_{per}$ first randomly selects ${\mathbb{X}}_{s}^{b}\subseteq\{0,1\}^{d}$ as the predicate representations of the samples.
Then, it transforms ${\mathbb{X}}_{s}^{b}$ back to the original input space to get ${\mathbb{X}}_{s}$.
For each ${\bm{z}}^{b}\in{\mathbb{X}}_{s}^{b}$, a predicate-to-feature mapping function $t_{\text{p2f}}:\{0,1\}^{d}\rightarrow{\mathbb{X}}$
transforms ${\bm{z}}^{b}$ to ${\bm{z}}$ as follows: if $z_{i}^{b}=1$, then for each $j\in{\mathbb{A}}_{i}$, set $z_{j}=x_{j}$; otherwise, set each $z_{j}$ to a masked value, or a random value sampled from $\text{per}({\bm{x}},j)\backslash\text{ran}({\bm{x}},j)$, where $\text{per}({\bm{x}},j)$ is a perturbation range with $\text{per}({\bm{x}},j)\supset\mathrm{ran}({\bm{x}},j)$.

Learning Algorithms and Explanations. The learning algorithm learns an understandable expression $g$ as an explanation.
In Anchors, $g$ is a conjunction of predicates that provides a sufficient condition for producing $f({\bm{x}})$ as output, i.e., $f({\bm{z}})=f({\bm{x}})$ if $g(z)=1$, and $g(z)=\bigwedge_{p\in{\mathbb{Q}}}p(z)$, where ${\mathbb{Q}}$ is selected by KL-LUCB algorithm (Kaufmann & Kalyanakrishnan, ).
In LIME and Kernel SHAP, $g(z)=\sum_{i=1}^{d}w_{i}p_{i}(z)+w_{0}$, where $w_{i}$ is the weight of $p_{i}$, which is learned by their underlying regression algorithms.
LORE first learns a decision tree with building systems like Yadt (Ruggieri, ), then extracts a sufficient condition to obtain $f({\bm{x}})$ and some counterfactual rules from the tree as explanations. The sufficient condition is similar to Anchors, while each of the counterfactual rules is in the form of $f({\bm{z}})=y$ if $g(z)=1$, where $y\neq f({\bm{x}})$ and $g(z)=\bigwedge_{p\in{\mathbb{Q}}}p(z)\wedge\bigwedge_{p\in{\mathbb{C}}}\neg p(z)$, and ${\mathbb{Q}}$ and ${\mathbb{C}}$ are extracted from the decision tree.

An Example.
For a text input I love this movie so much, these techniques can let each $p_{i}$ constrains only one feature, and produce six predicates in the form of $p_{i}(z):=\bm{1}_{z_{i}=x_{i}}$. For another text input $z=$ I love this [MASK] so [MASK], the predicate representation of $z$ is $p_{1}(z)\ p_{2}(z)\ p_{3}(z)\ p_{4}(z)\ p_{5}(z)\ p_{6}(z)=1\ 1\ 1\ 0\ 1\ 0$. The perturbation model will generate samples in predicate representation, then $t_{p2f}$ will transform samples back to the origin input space.
For example, a sample $0\ 1\ 0\ 1\ 1\ 1$ is generated and $t_{p2f}$ maps it to [MASK] love [MASK] movie so much.
Consequently, these techniques will use the output of these samples and the samples’ predicate presentation to learn an expression, and build the explanation with the predicates.

Limited by the predicate sets and perturbation models, existing local model-agnostic explanation techniques can only generate explanations based on the constraints of feature values, which limits their effectiveness in explaining the behavior of the model.

## 3 The ConLUX Framework

In this section, we propose ConLUX, a general framework to provide concept-based local explanations based on existing local model-agnostic explanation techniques without significantly changing their core components.

We introduce ConLUX in three steps: 1) defining concept-based local explanations and concept predicates, 2) showing the modifications to the explanation techniques, and 3) demonstrating the augmented workflow.

### 3.1 Concept-Based Local Explanations

As we discussed in Section 2, though the form of the explanations varies, they are all built from predicates in ${\mathbb{P}}$. Elevating the predicates to concept level is the key to providing concept-based explanations.

Definition of high-level concepts varies, as Molnar () mentions, “A concept can be any abstraction, such as a color, an object, or even an idea.”
Here, to provide explanations that are easier to understand by end-users, we define a concept predicate as follows:

###### Definition 1 (Concept Predicate) .

Given an input ${\bm{x}}$, a concept predicate $p^{c}$ is a function that maps ${\bm{x}}$ to a binary value, i.e., $p^{c}:{\mathbb{X}}\rightarrow\{0,1\}$, and satisfies the following properties:

- 1.
Descriptive: The concept predicate $p^{c}$ can be concisely and intuitively described in natural language.
- 2.
Human Evaluable: The truth of $p^{c}({\bm{x}})$ can be readily assessed by a human user.

The preceding two properties ensure that the concepts are easy to understand. Here, we provide two examples of concept predicates for text and image models in the following:

###### Definition 1 (Concept Predicate) .

##### Examples.

For text models, we can define a concept predicate as follows:

- •
Concept Name: Poor Visual Effects and Cinematography
- •
Description: The input text mentioned that the visual effects and cinematography are lacking, failing to create an appealing aesthetic.

For image models, we use objects in an image to define a concept predicate. As shown in Figure 2, we can easily describe the concept predicate as “there is a punching bag in the image”, “there is a kid in the image”, etc.

We then define a concept-based local explanation as follows:

###### Definition 2 (Concept-Based Local Explanation) .

A concept-based local explanation $g^{c}_{f,{\bm{x}}}$ is an expression formed with concept predicates to describe the behavior of $f$ around ${\bm{x}}$.

As existing local explanation model-agnostic techniques provide various kinds of explanations like attributions, sufficient conditions, and counterfactuals, ConLUX can elevate all these explanations to concept level and provide users a unified interface to obtain various kinds of explanations with a single click.
Additionally, We denote such a set of various kinds of explanations as a ConLUX unified explanation, which provides higher fidelity and offers a more comprehensive view than a single form of explanation.

###### Definition 2 (Concept-Based Local Explanation) .

### 3.2 Augmenting explanation techniques

As shown in Figure 4, to produce concept predicates, we should first extract high-level concepts based on the input ${\bm{x}}$; to provide explanations at concept level, we should replace the feature predicates in ${\mathbb{P}}$ with concept predicates; to capture the local behavior of the target model at concept level, we should extend the perturbation model to generate samples by changing high-level concepts.

##### Producing Concept Predicates.

We use large pre-trained models to provide high-level concepts based on the input ${\bm{x}}$ and the target task.
For text models, we refer to the concept extracting prompt used in Ludan et al. (), providing the information about the task, the given input, the corresponding output, and some in-context learning examples.
For image models, we use SAM to detect objects in the image.

Consequently, ConLUX defines concept predicates (denoted as $p^{c}$) using the extracted concepts, and replaces the feature predicates set ${\mathbb{P}}$ with the concept predicates set ${\mathbb{P}}^{c}$.

##### Generating Samples.

The extended perturbation model $t_{per}^{c}$ generates samples in predicate representation and $t_{\text{p2f}}^{c}:\{0,1\}^{|{\mathbb{P}}^{c}|}\rightarrow{\mathbb{X}}$ transforms the samples back to the original input space.
Different from the $t_{per}$ simply decides whether to mask a feature value, $t_{per}^{c}$ changes high-level concepts at feature level, which is more complex.
Therefore, $t_{per}^{c}$ is usually a more sophisticated model.
Here, for text models, we use Llama3.1 to perform the predicate-feature mapping; for image models, since each object is still a set of pixels, we can use the same transformation as $t_{per}$.

### 3.3 ConLUX -Augmented Workflow

The ConLUX augments the workflow in Figure 4 as follows: it first extracts high-level concepts based on the input ${\bm{x}}$ and the target task, then follows a similar workflow as their vanilla versions, but replaces the predicate set ${\mathbb{P}}$ with ${\mathbb{P}}^{c}$ and the perturbation model $t_{per}$ with $t_{per}^{c}$. Therefore, the ConLUX-augmented techniques can capture the local behavior of the target model at the concept level, and provide concept-based local explanations.

More details about the implementation of ConLUX can be found in Appendix A.

## 4 Empirical Evaluation

In this section, we demonstrated the generality of ConLUX, its improvement of explanation fidelity, and the fidelity of ConLUX unified explanations by empirical evaluation.
We showed the generality of ConLUX by applying it to four mainstream local model-agnostic explanation techniques: Anchors, LIME, LORE, and Kernel SHAP (KSHAP for short), which provide three types of explanations:
sufficient conditions, counterfactuals, and attributions.
We applied them to explain various text and image models.
We showed the improvement of explanation fidelity by comparing the vanilla feature-level explanations with ConLUX-augmented the concept-based explanations.
Moreover, we compared the fidelity of ConLUX unified explanations with two state-of-the-art concept-based explanation techniques: Textual Bottleneck Model (TBM) (Ludan et al., ) for text models and Explain Any Concept (EAC) (Sun et al., ) for image models.

### 4.1 Experimental Setup

We chose sentiment analysis as the target task for text models, and image classification as the target task for image models.

##### Sentiment Analysis.

Sentiment analysis models take a text sequence as input and predict if the text is positive or negative, i.e. $f:{\mathbb{X}}\rightarrow\{0,1\}$, where ${\mathbb{X}}:=\bigcup_{i=1}^{\infty}{\mathbb{W}}^{i}$ is the input domain, and ${\mathbb{W}}$ is the vocabulary set.
We used a pre-trained BERT (Morris et al., ) and Llama3.1 to predict the sentiment of 200 movie reviews from the Large Movie Review Dataset (Maas et al., ), and explained the local behavior of the models around each input text.
For vanilla techniques, we followed the settings described in Section 2.
For ConLUX-augmented techniques, we set the number of concept predicates to 10, used GPT-3.5 (Brown et al., ) to extract high-level concepts, and Llama3.1 to perform the predicate-to-feature mapping.
For TBM, we applied it to explain the same 200 movie reviews with its default settings.

##### Image Classification.

Image classification models take an image as input and predict the category of the image, i.e. $f:{\mathbb{X}}\rightarrow\{0,1,...,m\}$, where $m$ is the number of categories, ${\mathbb{X}}:=\mathbb{R}^{3\times h\times w}$ is the input domain, with $h$ and $w$ being the height and width of the image.
We used a pre-trained YOLOv8, Vision Transformer (ViT) (Oquab et al., ; Darcet et al., ), and ResNet-50 (He et al., ) to predict the category of 1000 images from the ImageNet dataset (Deng et al., ), and explained the local behavior of the models around each input image.
For vanilla techniques, we followed LIME to use Quickshift algorithm (Jiang et al., ) to obtain the superpixels, and used these super-pixels as predicates.
For ConLUX-augmented techniques, we used SAM (Kirillov et al., ) to detect objects in the images, and used these objects as predicates.
For EAC, we applied it to explain the same 1000 images with its default settings.

To evaluate the fidelity of ConLUX unified explanations, as the combination of multiple forms of explanation provides more fidelity than a single form, we used the combination ConLUX-augmented KSHAP and LORE explanations as local surrogate models.
Specifically, if an input is covered by LORE’s rule, we use the LORE output; otherwise, we use the KSHAP explanation.

More details can be referred to Appendix B.

### 4.2 Fidelity Evaluation

#### 4.2.1 Evaluation Metrics

Fidelity reflects how faithfully the explanations describe the target model. As these techniques provide explanations in different forms, we used different metrics to evaluate their fidelity.

Following the setup in the original papers of Anchors and LORE,
we used coverage and precision as fidelity metrics (which are named differently in the LORE paper). Given a target model $f$, an input ${\bm{x}}$, and a distribution $D_{\bm{x}}$ derived from the perturbation model, and the corresponding explanation $g$, we defined the coverage as $\mathrm{cov}({\bm{x}};f,g)=\mathbb{E}_{{\bm{z}}\sim D_{\bm{x}}}[g({\bm{z}})]$, which indicates the proportion of inputs in the distribution that match the rule;
we defined the precision as $\mathrm{prec}({\bm{x}};f,g)=\mathbb{E}_{{\bm{z}}\sim D_{\bm{x}}}[\bm{1}_{f({
\bm{z}})=y}|g({\bm{z}})]$, where y is the consequence of the rules in $g$ with $y=f({\bm{x}})$ for factual rules and $y\neq f({\bm{x}})$ for counterfactual rules.
Precision indicates the proportion of covered inputs that $g$ correctly predicts the model outputs.

As LIME and KSHAP are attribution-based local surrogate, we used Area Over most relevant first perturbation curve (AOPC) (Samek et al., ; Modarressi et al., ), and $\mathrm{accuracy_{a}}$ as fidelity metrics (Balagopalan et al., ; Yeh et al., ; Ismail et al., ).
Given a target model $f$, an input ${\bm{x}}$, its corresponding model output $y=f({\bm{x}})$, their corresponding explanation $g$, and $x^{(k)}$ that is generated by masking the $k\%$ most important predicates in ${\bm{x}}$,
AOPC and $\mathrm{accuracy_{a}}$ are defined as follows:

- •
AOPC: Let $\mathrm{AOPC}_{k}=\frac{1}{|{\mathbb{T}}|}\sum_{\bm{x}}^{\mathbb{T}}p_{f}(y|{
\bm{x}})-p_{f}(y|{\bm{x}}^{(k)}),$
where $p_{f}(y|{\bm{x}})$ is the probability of $f$ to output $y$ given the input ${\bm{x}}$, and ${\mathbb{T}}$ is the set of all test inputs.
$AOPC_{k}$ indicates the average change of the model output when masking the $k\%$ most important predicates. A higher $AOPC_{k}$ indicates a better explanation. We calculate the AOPC curve by varying $k$ from 0 to 100.
- •
$\mathrm{\mathbf{Accuracy_{a}}}$: $\mathrm{Accuracy_{a}}$ indicates the proportion of inputs among all ${\bm{x}}^{(k)}$ that the target model gives the same output as the original input ${\bm{x}}$, i.e. $\mathbb{E}(f({\bm{x}}^{(k)})=f({\bm{x}}))$. Specifically, $\mathrm{accuracy_{a}}$ is different from the standard accuracy, and a lower $\mathrm{accuracy_{a}}$ indicates a better explanation.

Specifically, we only considered the predicates that positively contribute to $f({\bm{x}})$, and we did not use AOPC when explaining Llama 3.1, as it does not directly provide the probability for each output token.

For TBM, EAC, and ConLUX unified explanations,
considering that they can all serve as local surrogate models, i.e. $g:{\mathbb{X}}\rightarrow\mathbb{R}$, we defined the metrics as follows: Given a target model $f$, an input ${\bm{x}}$, a perturbation distribution ${\mathbb{D}}_{{\bm{x}}}$, and their corresponding explanation $g$, a performance metric $L$ (e.g. accuracy, F1 score, MSE, etc.), we define the (in-)fidelity as $E_{z\sim{\mathbb{D}}_{\bm{x}}}L(f({\bm{z}}),g({\bm{z}}))$, which indicates the performance of using $g$ to approximate $f$. Here, we used the accuracy as the performance metric.
Specifically,
considering the complexity of the original task,
we reduced the image classification task for local surrogates to predicting whether the target model $f$ assigns the same classification to ${\bm{x}}^{\prime}$ as it does to ${\bm{x}}$.

Figure: Figure 5: AOPC upon masking the K% most important tokens. We use LIME, Kernel SHAP, and their ConLUX-augmented version to explain YOLO, ViT, and Rednet 50 on the image classification task and BERT on the sentiment analysis task.
Refer to caption: x5.png

**Table 1: Average coverage and precision (higher are better) of Anchors, LORE, and their ConLUX-augmented versions (denoted as Anchors* and LORE*) on two sentiment analysis models and three image classification models.**
| Models | Coverage (%) $\uparrow$ | Precision (%) $\uparrow$ |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Anchors | Anchors* | LORE | LORE* | Anchors | Anchors* | LORE | LORE* |  |
| Llama 3.1 | 4.9 | 22.5 | 2.3 | 21.3 | 81.2 | 94.2 | 64.3 | 76.9 |
| BERT | 5.3 | 24.4 | 3.2 | 20.3 | 78.2 | 91.0 | 65.3 | 79.4 |
| YOLOv8 | 28.6 | 30.9 | 20.8 | 24.8 | 84.3 | 98.2 | 87.8 | 92.2 |
| ViT | 24.6 | 28.2 | 21.3 | 23.8 | 88.7 | 98.2 | 89.6 | 95.6 |
| ResNet-50 | 28.0 | 30.5 | 20.1 | 29.7 | 89.3 | 99.4 | 85.8 | 92.6 |

**Table 2: Average AOPC and $\mathrm{accuracy_{a}}$ (higher AOPC and lower $\mathrm{accuracy_{a}}$ are better) of LIME, KSHAP, and their ConLUX-augmented versions (denoted as LIME* and KSHAP*) on two sentiment analysis models and three image classification models.**
| Models | AOPC $\uparrow$ | $\mathrm{Accuracy_{a}}$ (%) $\downarrow$ |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LIME | LIME* | KSAHP | KSAHP* | LIME | LIME* | KSAHP | KSAHP* |  |
| Llama 3.1 | – | – | – | – | 82.3 | 49.8 | 72.1 | 45.4 |
| BERT | 0.243 | 0.456 | 0.379 | 0.553 | 75.7 | 47.7 | 60.3 | 40.2 |
| YOLOv8 | 0.401 | 0.474 | 0.433 | 0.590 | 14.8 | 5.0 | 33.1 | 6.9 |
| ViT | 0.469 | 0.598 | 0.454 | 0.611 | 21.1 | 4.9 | 25.7 | 9.0 |
| ResNet-50 | 0.232 | 0.306 | 0.233 | 0.323 | 36.3 | 14.6 | 33.1 | 8.6 |

#### 4.2.2 Evaluation Results

Table 1 shows the fidelity of Anchors, LORE, and their ConLUX-augmented versions.
ConLUX improves the average coverage of Anchors and LORE by 9.0% and 10.4%, and the average precision by 11.9% and 8.7%, respectively.
Figure 5 and Table 2 show the fidelity of LIME, KSHAP, and their ConLUX-augmented versions.
Figure 5 shows the AOPC curve of LIME and KSHAP.
Each AOPC curve of ConLUX-augmented versions is higher than the vanilla counterpart.
Table 2 shows the average AOPC and $\mathrm{accuracy_{a}}$. ConLUX improves the average AOPC by 0.122 and 0.145, and decreases the
average $\mathrm{accuracy_{a}}$ by 21.6% and 22.8%, for LIME and KSHAP, respectively.
We do paired t-tests for each setup that only differs on whether to apply ConLUX,
to show the statistical significance of the improvement. The p-value is all less than 0.01, which indicates with over 99% confidence the improvement is significant.

We also compared ConLUX unified explanations with two state-of-the-art concept-based task-specific explanation techniques: TBM for text tasks and EAC for image tasks.
Table 3 shows the fidelity of TBM, EAC, and ConLUX unified explanations. ConLUX helps two classic local model-agnostic techniques to achieve 5.75% and 4.9% more accuracy than TBM and EAC.

**Table 3: Average accuracy (higher accuracy is better) of LIME, KSHAP, and their ConLUX-augmented versions (denoted as LIME* and KSHAP*) on two sentiment analysis models and three image classification models.**
| Methods | Accuracy (%) $\uparrow$ |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Llama 3.1 | BERT | YOLOv8 | ViT | ResNet-50 |  |
| ConLUX | 94.7 | 87.8 | 61.3 | 59.6 | 61.5 |
| EAC | – | – | 56.6 | 53.4 | 57.7 |
| TBM | 89.6 | 81.4 | – | – | – |

## 5 Related Work

Our work is related to model-agnostic explanation techniques and concept-based explanation techniques.

Model-agnostic explanation techniques consider target models as black boxes and provide explanations without requiring any knowledge of the model’s internal structure.
Existing Model-agnostic explanation techniques provide different types of explanations, such as feature importance (Lundberg & Lee, ; Ribeiro et al., ; Tan et al., ; Shankaranarayana & Runje, ), decision rules (Ribeiro et al., ; Guidotti et al., ; Dhurandhar et al., ), counterfactuals (Wachter et al., ; Guidotti et al., ), and
visualizations (Goldstein et al., ; Friedman, ; Apley & Zhu, ).
However, to our knowledge, all existing model-agnostic explanation techniques provide explanations at feature levels (Zhang et al., ). Basic feature-based explanations are usually worse in aligning with either the decision-making process of the model or end-users (Ghorbani et al., ; Sun et al., ; Kim et al., ), which makes these explanations unfaithful and hard to understand.

Concept-based explanation techniques provide explanations in terms of high-level concepts, which align with the decision-making process of the model better and are more interpretable to end-users.
To our knowledge, existing concept-based explanation techniques are all model-specific or task-specific (Poeta et al., ). We categorize them into three groups:
(1) techniques that extract concepts from the model’s internal structure (Zhang et al., ; Yeh et al., ; ; Cunningham et al., ; Ghorbani et al., ; Crabbé & van der Schaar, ), which are limited to specific types of models,
(2) techniques that use external knowledge to define concepts (El Shawi, ; Fel et al., ), which are limited to specific types of tasks since their methods based on the knowledge for a specific task, and
(3) techniques that use pre-trained models to extract concepts (Ludan et al., ; Sun et al., ). Ludan et al. () propose TBM, which is a surrogate model specifically designed for text data, while Sun et al. () propose EAC, which also utilizes internal information of the target model.
Therefore, these techniques are only for specific types of tasks.
In addition, these techniques mainly focus only on attributions which limits their use cases (Poeta et al., ).

## 6 Conclusion

We have proposed ConLUX, a general framework that automatically extracts high-level concepts and incorporates them into existing local model-agnostic explanation techniques to provide concept-based explanations, which are more faithful and easier to understand by end-users.
ConLUX offers unified explanations that combine attributions, sufficient conditions, and counterfactuals. This satisfies diverse user needs and fills the current gap in concept-based explanations, which lack forms beyond attributions.
ConLUX achieves this by utilizing large pre-trained models to extract high-level concepts, elevating language components from feature level to concept level, and extending perturbation models to sample in the concept space.
We have instantiated ConLUX on Anchors, LIME, LORE, and Kernel SHAP, and provide unified explanations. We have constructed empirical evaluations to demonstrate the effectiveness of ConLUX.

## Appendix A The ConLUX Framework (Continued)

In this section, we introduce the details of incorporating ConLUX into existing local explanation methods.

We first follow Section 3 to introduce how we extend each part for text models in detail.

### A.1 Producing Concept

ConLUX provides predicates that describe high-level concepts by utilizing a large pre-trained model.
Here, we describe the step to extract concept from text and image data in detail.

Text Data.
We use GPT-3.5 to produce concept-level predicates in two step.
First, we let $GPT-3.5$ generate the concepts that are important to the current task with a prompt as follows:

> Now you are an expert at writing movie reviews, please tell me from which perspectives can you evaluate a movie.

Then we let the $GPT-3.5$ to refine the predicates based on the current input and its similar sentences, and format the concepts. Here, we referred to the format defined in TBM (Ludan et al., ).
The prompt is as follows:

> Here we are presented with a text dataset accompanied by labels, and our objective is to identify a concept in the text that correlates with these labels. The task is to ….., we have known the following concepts are important in this task. [concepts] In additionally, you should refine the concept to make sure that concepts can be used to correctly classify the following examples: [texts labels] Then you are given examples of concepts across various datasets. please give me the concepts following their format: Example 1: ”Concept Name”: ”explicit language”, ”Concept Description”: ”’Explicit language’ refers to the use of words, phrases, or expressions that are offensive, vulgar, or inappropriate for general audiences. This may include profanity, obscenities, slurs, sexually explicit or lewd language, and derogatory or discriminatory terms targeted at specific groups or individuals.”, ”Concept Question”: ”What is the nature of the language used in the text?”, ”Possible Responses”: [”explicit”, ”strong”, ”non-explicit”, ”uncertain”], ”Response Guide”: ”explicit”: ”The text contains explicit language, such as profanity, obscenities, slurs, sexually explicit or lewd language, or derogatory terms targeted at specific groups or individuals.”, ”Strong”: ”The text contains strong language but not explicit language, it may contain terms that some viewers might find mature.”, ”non-explicit”: ”The text is free from explicit language and is appropriate for general audiences.”, ”uncertain”: ”It is difficult to determine the nature of the language used in the text or if any explicit terms are used.” , ”Response Mapping”: ”explicit”: 2, ”strong”:1, ”non-explicit”: -1, ”uncertain”: 0 Example 2: …… Now, please give me your formatted concepts:

Then we use the Response Guides to produce local concepts.

### A.2 Predicate-Feature Mapping

We the the following prompt for predicate-feature mapping:

> Generate a sentence similar to a given sentence from the domain of dataset. The dataset’s description is that . The generated sentence satisfies given concepts. Before generating the sentence, carefully read the description of each concept to understand the properties that the generated sentence must satisfy, think about how the sentence satisfies the concepts first, and then create the sentence that satisfies the concepts. Format your response as a JSON with string keys and string values. Below is an example of a valid JSON response. The JSON contains keys thoughts, and the answer. End your response with ### — Concepts: 1. Concept 1 2. Concept 2 … Response JSON: ”thoughts”: ”In this section, you explain which snippets in your text support the concepts. Be as objective as possible and ignore irrelevant information. Focus only on the snippets and avoid making guesses.”, ”answer”: ”A sentence that satisfies the concepts.” ### Two examples of this task being performed can be seen below. Note that the answer should be in 5 to 20 words and should be a single sentence. Example 1: Concepts: 1. The plot of the text is exciting, captivating, or engrossing. It may have unexpected twists, compelling conflicts, or keep the reader eagerly turning pages. 2. The characters in the movie are portrayed in a realistic and convincing manner. Their actions, dialogue, emotions, motivations, and development feel authentic and relatable, making them believable to the audience. 3. The narrative structure of the text is confusing or unclear, making it difficult to follow or comprehend the events happening within the story. 4. The text introduces some original elements or takes minor risks in the plot development, but overall, it lacks a truly unique or innovative narrative. Response JSON: ”thoughts”: ”The snippet ’the silly and crude storyline’ mentions a storyline that is described as silly and crude mentions a ’silly and crude storyline’ which indicates a lack of creativity and reliance on clichéd plot devices, satisfying the concept of some originality and inventive plot development. The snippet ’the real issues tucked between the silly and crude storyline’, mentions a contrast between real issues and a silly and crude storyline, indicating a potentially confusing narrative structure, satisfying the concept of a confusing narrative structure. This also mentions that it has real conflict inside, which satisfies the concept of an exciting plot. This snippet also mentions mentions ’real issues’ which indicates that the characters are portrayed in a realistic and convincing manner, satisfying the concept of realistic and convincing characters.” ”answer”: ”it’s about issues most adults have to face in marriage and i think that’s what i liked about it – the real issues tucked between the silly and crude storyline.” ### Example 2: …. ### Perform the task below, keeping in mind to limit the response to 5 to 20 words and a single sentence. Return a valid JSON response ending with ### Concepts: Response JSON:

## Appendix B Experiment Settings (cont.)

We experimented on two machines, one with an Intel i9-13900K CPU, 128 GiB RAM, and RTX 4090 GPU, and another with Intel(R) Xeon(R) Silver 4314 CPU, 256GiB RAM, and 4 RTX 4090 GPUs.

To measure the fidelity improvement brought by ConLUX, we keep all hyperparameters the same for both vanilla and augmented methods.

For LIME and KSHAP, we set the number of sampled inputs to 1000 except for explaining Llama 3.1.

For Anchors, we follow the default settings.

For LORE, we set $ngen=5$.

For the LLama3.1 model, when applying it to the sentiment analysis task, we simply use the following prompt:

> From now on, you should act as a sentiment analysis neural network. You should classify the sentiment of a sentence into positive or negative. If the sentence is positive, you should reply 1. Otherwise, if it’s negative, you should reply 0. There may be some words that are masked in the sentence, which are represented by <UNK>. The input sentence may be empty, which is represented by <EMPTY>. You will be given the sentences to be classified, and you should reply with the sentiment of the sentence by 1 or 0. There are two examples: Sentence: I am good Sentiment: 1 Sentence: The movie is bad. Sentiment: 0 You must follow this format. Then I’ll give you the sentence. Remember Your reply should be only 1 or 0. Do not contain any other content in your response. The input sentence may be empty. Sentence: {The given sentence} Sentiment:

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 2
questions: For each data point, the concept used can be different. Given that it comes from an LLM, there can even be stochasticity over it (it may also be worth mentioning the LLM temperature setting for this, if not already mentioned). Even otherwise, two very similar reviews can have different concepts chosen for explanation, with no theoretical guarantee on the LLM choosing similar predicates. This lack of control makes the explanation less robust. In theory, changing a token (may be an adversarially crafted one in practice) can change the entire explanation, as the choice of predicates is left to the LLM. One cat may be identified by its ears and a similar one by its eyes. Can you propose an experiment to study this robustness?
soundness: 2
strengths: The proposed framework is interesting and can be useful if validated rigorously. The paper explores two different modalities. The framework is applied across multiple established methods (LIME, Kernel SHAP, Anchor, and LORE).
summary: The paper proposes to use foundation models to discover concepts to augment on methods like LIME to provide concept-based local explanations. The method is evaluated on sentiment analysis and image classification tasks.
weaknesses: Concept discovery using LLM is the key aspect of the proposed framework. This calls for a human evaluation to answer the question: are the concepts discovered by the foundation models indeed aligned with a human-understandable representation? Currently, it sounds like it is assumed that the prompt will take care of this. 


How faithful is the backtracking from the perturbed concept space to the original space? This also done by the LLM?

Methods like LIME create a local approximation of the original function to a human-understandable form and explain the decision. This is the reliable yet explainable part of the method. By using LLM for discovering concepts, (given each task and the sample), it becomes difficult even locally to explain the predicates. The decision-making is not fully explained, i.e., the choice of predicates cannot be explained. For instance, in case a poor predicate is chosen by an LLM, the user may be confused by the explanation. I think the proposed method, by using foundation models for concept discovery, makes the framework less reliably explainable.

To prove the robustness of the method, it would be useful to try intervention-based causal metrics, especially since the concept discovery is done by foundation models. C-insertion and deletion are often used to evaluate concept importance and fidelity in concept-based explanations.

Robustness to the prompt: how robust is the framework to the construction of the prompt? Also, given the literature around prompt engineering, the framework could explore what might be the optimal prompting strategy for discovering human-interpretable concepts. 


The paper proposes a new framework for explanation where concept discovery is done by foundation models. For the text modality, the experiments are restricted to sentiment analysis, and 1000 images from the ImageNet dataset are used for classification for images. The method calls for more experiments for validation. However, this is not the sole reason for the decision.


There is no baseline comparison. Though the method is a new paradigm, it could be compared with concept bottleneck methods or predicates selected by other methods. There could also be an ablation study on different LLM model combinations. Additionally, the authors could discuss concept bottleneck-based methods. What do you think about a method where task-specific concept bottlenecks are chosen by the LLM? This is not a weakness or a mandatory experiment for the text.


Minor comments:

L44: Please provide a citation, as not all visual explanation methods using attribution mapping follow this principle.
L80: "Moreover, we observe that ... across different tasks." given the restricted number of tasks evaluated it might be a good idea to tone down this claim.
Teaser figure: I think, this can be made more comparable if the attribution method is shown with certain thresholding. When shown post-thresholding, the viz can clearly demonstrate the benefit of the proposed method, even allowing for certain comparative evaluations later.
L93: This is a tradeoff between reliability of explanation to prediction and understandability. If the model is indeed making a decision based on the token, pivoting the explanation on different concepts can change it. 
Figure 2: Comparison of LIME and ConLUX-augmented LIME; the ConLUX highlights the kid! Is this a good explanation? Of course, SAM performs a good segmentation of the image, providing an object-level explanation, but the attribution seems incorrect to me. Or did I miss something?

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: - Don’t have much in terms of questions on the methodology itself, but a few conceptual issues stood out, as mentioned in the weaknesses.
- It’d be interesting to see if the authors could run additional experiments with different scales of perturbation to make sure these fidelity gains are actually about better explanations, rather than just larger shifts.
soundness: 3
strengths: - ConLUX shows promise in being adaptable to multiple existing explanation methods (LIME, SHAP, Anchors, LORE), broadening its application across varied model types.
- ConLUX aims to make model behaviors more intuitive and accessible for end-users, addressing a limitation in feature-based explanations.
summary: - The paper introduces ConLUX a framework designed to enhance model-agnostic explanation methods by transforming traditional feature-level explanations into concept-level ones. 
- The authors argue that mainstream model-agnostic explanation techniques often provide explanations based on low-level features that don't align well with model decision processes or user understanding so ConLUX elevates explanations to the concept level.
- The framework applies ConLUX to different explanation methods (LIME, Anchors, LORE, and Kernel SHAP) across text and image models.
weaknesses: **Major**
- One key weakness of ConLUX I felt was that since it shifts to a concept-level perturbations, which are broader and may disrupt the local fidelity of explanations. Unlike small feature-level adjustments (e.g., word or pixel changes in LIME), concept-level changes can alter the input more drastically, potentially leading to explanations that do not accurately reflect the model’s behavior around the specific input instance. To investigate whether these concept-level perturbations maintain local fidelity, I suggest running controlled experiments comparing concept-level and feature-level perturbations. For example, the authors could measure fidelity loss or gain across a gradient of perturbation scales, allowing for a comparison between the fidelity of feature-level and concept-level explanations.
- The paper relies on pre-trained models to extract high-level concepts but does not fully explore whether these concepts are consistently relevant across diverse domains. Variability in concept quality could impact the explanation's reliability. I recommend testing concept quality across datasets from different domains and introducing a metric or using existing ones like TCAV[1] to measure concept relevance and coherence within each domain. 
- Since ConLUX relies on pre-trained models to extract high-level concepts, it inherits any biases present in these models. This reliance could skew the explanations based on the biases embedded in the pre-trained models, which might limit the fairness and reliability of the generated explanations.
- Observed improvement in fidelity metrics, such as AOPC, coverage, and precision, may partly result from the broader concept-level perturbations rather than genuinely enhanced explanation quality. Since larger perturbations at the concept level likely introduce more drastic changes to the model output, they could artificially inflate these scores, making the explanations appear more effective than they might be with finer, feature-level adjustments. To address this, the paper could benefit from controlled experiments using varying perturbation scales, comparing small and large concept-level shifts, to ensure that the fidelity improvements genuinely reflect enhanced interpretability rather than the impact of larger perturbations. I suggest implementing a normalized fidelity metric that adjusts for the magnitude of perturbations.

**Minor**
- A few typos in page 2 "ConLUX-agumented LIME" should be "ConLUX-augmented LIME"

**References**
1. Kim, Been, et al. "Interpretability beyond feature attribution: Quantitative testing with concept activation vectors (tcav)." International conference on machine learning. PMLR, 2018.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: 1. I am not completely convinced by the strategy of using language models for text concept predicates. While I assume it probably provides the best performance and our generally more than good enough for text-only tasks, they could still be prone to hallucinations in terms of incorrect concept extraction or during generations for perturbation. Did you consider some other method (maybe traditional topic modelling approaches) to validate its concept detection or perturbation outputs. In this sense I like the visual predicates lot more than textual ones.

2. I wonder if you considered an ACE (Ghorbani et al.) + LIME method to compare ConLUX against a concept based reference where you use activation space of an external encoder to cluster superpixels instead of the original model. The concepts can be defined as clusters of superpixels, as in original method. 

Overall, comparing the strengths and weaknesses, I find the method to be just sound and strong enough that I would tilt slightly towards acceptance.
soundness: 3
strengths: 1. The problem setup, what the authors want to solve, and why, is quite clear.
2. The core idea of using a concept-friendly representation for input and combining it with black-box explanation methods is simple and its positive implications are easy to see. 
3. The experiments are reasonably strong. They cover both text, images, and on multiple black-box models, with positive results in all cases. Also, via the existing black-box explainers, the method can generate different types of explanations (attribution, counterfactual etc.)
4. While it has its own weaknesses, the proposal to build visual concept predicates is a principled way that could be readily validated by a user if the concept extraction is incorrect. This aspect of simplicity should positively reflect in its application
summary: The paper proposes a concept based local explanation method ConLUX that is model agnostic. The authors essentially propose a modality specific concept representations of inputs (concept predicates). These representations also readily provide a procedure to perform perturbation on the predicates and subsequently the input. Combining these two, the method is able to augment the traditional model-agnostic approaches to provide concept based explanations. The authors provide experiments on text (sentiment prediction) and images (classification) with multiple black-box models and explanation techniques and essentially show a clear improvement in terms of various forms of fidelity.
weaknesses: 1. Twice the authors describe (Fel et al. 2023) as using external knowledge to learn concepts. To my understanding, this is a wrong description. They propose a unified class of methods based on dictionary learning that is completely unsupervised. 
2. Typos/Errors: 
    * Rednet (line 448)
    * line 351 should not be in past tense
    * Table 3 caption does not correspond to the table content
3. The method seems only capable to extract coarse visual concepts. Also it can only admit concepts that can be represented as a segmentation mask. In case of text concept predicates, potential risk of some issues arising from using language models for concept detection and predicate-feature mapping. 
4. I felt a lack of examples/illustrations of visual explanations and any deeper qualitative insights the authors might have.

Meta-review: The paper introduces an intriguing method using large pre-trained models for concept discovery and perturbation, but several issues limit its reliability and generalizability. Concept-level perturbations can distort inputs, failing to capture local decision boundaries effectively, especially when modeled as entire objects. The extracted concepts lack evidence of generalization across domains, raising concerns about interpretability. Reliance on pre-trained models introduces biases, with no mitigation strategies proposed. Additionally, LLM-based perturbations in language tasks face fidelity issues, and the framework's sensitivity to prompt selection impacts reproducibility. Significant revisions, including finer-grained experiments, robust validation, and bias mitigation, are needed to improve its rigor and reliability.

Decision: Reject