capbtabboxtable[][]

# Variational Information Pursuit with Large Language and Multimodal Models
for Interpretable Predictions

Kwan Ho Ryan Chan
Johns Hopkins University
<EMAIL_ADDRESS>&Aditya Chattopadhyay
Johns Hopkins University
<EMAIL_ADDRESS>&&Benjamin D. Haeffele
Johns Hopkins University
<EMAIL_ADDRESS>&René Vidal
University of Pennsylvania
<EMAIL_ADDRESS>
###### Abstract

Variational Information Pursuit (V-IP) is a framework for making interpretable
predictions by design by sequentially selecting a short chain of task-
relevant, user-defined and interpretable queries about the data that are most
informative for the task. While using queries related with semantic concepts
allows for built-in interpretability in predictive models, applying V-IP to
any task requires data samples with concept-labeling by domain experts,
limiting the application of V-IP to small-scale tasks where manual data
annotation is feasible. In this work, we extend the V-IP framework with
Foundational Models (FMs) to address this limitation. More specifically, we
use a two-step process, by first leveraging Large Language Models (LLMs) to
generate a sufficiently large candidate set of task-relevant interpretable
concepts, then using multimodal models to annotate each data sample by
semantic similarity with each concept in the generated concept set. While
other interpretable-by-design frameworks such as Concept Bottleneck Models
(CBMs) require an additional step of removing repetitive and non-
discriminative concepts to have good interpretability and test performance, we
mathematically and empirically justify that, with a sufficiently informative
and task-relevant query (concept) set, the proposed FM+V-IP method does not
require any type of concept filtering. In addition, we show that FM+V-IP with
LLM generated concepts can achieve better test performance than V-IP with
human annotated concepts, demonstrating the effectiveness of LLMs at
generating efficient query sets. Finally, when compared to other
interpretable-by-design frameworks such as CBMs, FM+V-IP can achieve
competitive test performance using fewer number of concepts/queries in both
cases with filtered or unfiltered concept sets.

##  1 Introduction

Interpretable-by-design methods incorporate interpretability by requiring
model predictions to be solely dependent on (intermediate) representations
that correspond to semantic concepts. The set of concepts and their
annotations in data is often created and labeled by domain experts for the
task. As a result, the prediction is made based on the composition of
interpretable concepts that explains the model’s underlying decision making.
One line of research on interpretable-by-design frameworks is Variational
Information Pursuit (V-IP): The user first defines a set of queries, which are
concept-related functions of the data such as “Is the car red?”. The model
then makes a prediction by selecting a small number of informative queries
that maximize the mutual information between the task and query-answers.
Another line of work is Concept Bottleneck Models (CBMs) [16], for which
inputs are first nonlinearly mapped to an interpretable concept space, then
linearly mapped to the target’s label space via sparse-promoting regularizers
such as the $\ell_{1}$-norm so that each prediction becomes interpretable by
only using a small number of concepts. An example of both frameworks is shown
Figure 2. Although interpretable-by-design seems ideal, built-in
interpretability is not cost-free: CBMs and V-IP have been traditionally
limited to small- to medium- scale datasets. Applying interpretable-by-design
frameworks to large-scale datasets such as ImageNet entails overcoming three
main challenges:

Table 1: Comparisons between this work and other interpretable-by-design
frameworks.

Methods |  | Annotates samples
---
automatically
| Do not require
---
concept filtering
| Operates on large
---
query sets
| Predict with variable
---
no. of queries/concepts
CBM | No | No | No | No
Lf-CBM | Yes | Yes | Yes | No
LaBo | Yes | No | Yes | No
V-IP | No | No | No | Yes
FM+V-IP (this work) | Yes | Yes | Yes | Yes

Challenge 1: Generating a set of interpretable queries. Interpretable-by-
design frameworks require the user to first define a set of interpretable
concepts that are sufficiently informative for the task. While good
interpretable concepts are often created by domain experts for optimal
interpretability, when the number of classes increases or when the task is too
complex, manually generating interpretable and task-specific concept sets
becomes challenging. To address this issue, we propose to use Large Language
Models (LLMs) such as GPT-3 [2] as the machine expert in place of human domain
experts for extending to tasks of any scale. Since LLMs are trained on a large
amount of text, we operate on the premise that LLMs are machine experts that
have learned discriminative information about the data and labels for any
given task, thus they can produce large query sets from fairly simple prompts.

Challenge 2: Annotating every sample per concept. Once a sufficiently
informative, task-relevant, interpretable concept set is generated (either by
LLMs or by humans), the concepts needs to be related to the data for
interpretable predictions. For instance, in CUB-200 [33], each of the expert-
defined 312 concepts is individually labelled for every one of the 11,788
images. However, in the case of a large-scale dataset, annotating every sample
by hand for datasets with up to millions of samples is infeasible without any
machine assistance. In this work, we propose to use CLIP, a Vision-Language
Pre-trained model (VLPs) trained on a large number of image-text pairs, to
annotate every sample in an efficient manner. CLIP computes a similarity score
for each pair of image-text input, where a high score indicates the presence
of a certain concept and vice versa. By taking advantage of VLPs, we allow
faster data annotations that enables interpretable-by-design frameworks for
large-scale data.

Challenge 3: The need for concept filtering. With a suitable query set
generated by LLMs and per-sample annotated data from VLPs, theoretically one
should be able to scale interpretable-by-design frameworks to data and tasks
of any scale. Nonetheless, recent works such as Label-free CBMs (Lf-CBM) [24]
show that filtering out concepts from the initial concept set (also known as
candidate set) is needed in order to achieve good predictive performance and
interpretability. Concepts that are too similar to other concepts
semantically, for example, should be removed since one of them represents
redundant information. Nonetheless, there is no principled way to judge what
ad-hoc concept filtering methods should or should not be used in the final
concept set. In this work, we argue that the formulation of V-IP can perform
interpretable predictions without the need to perform any concept filtering:
Computing the mutual information for the task and next most informative query
naturally disregards uninformative queries that would have been filtered out.

Paper contributions. The main contributions of this work are the following:

  1. 1.

We extend V-IP to large query sets (300 to 45K concepts) and large visual
datasets (50K to 1M images) by using Foundational Models to generate and
answer queries. We also empirically show that LLMs and VLPs are capable of
generating informative query sets for interpretable predictions.

  2. 2.

We demonstrate that V-IP can perform interpretable predictions without the
need of ad-hoc concept filtering methods when compared to other interpretable-
by-design frameworks such as Lf-CBM.

  3. 3.

We further demonstrate that V-IP with query set of size up to 45K
queries/concepts can achieve competitive test performance with a smaller
number of queries/concepts than other methods such as Lf-CBM and LaBo [35].
The major differences between the different frameworks are summarized in Table
1.

##  2 Related Work

Explanations without language. Post-hoc explanation methods including feature
attribution methods, such as LIME [29] and SHAP [18], as well as gradient-
based methods, GradCAM [30, 4] and Integrated Gradients [32] generate
explanations directly on feature maps/pixels that do not involve natural
language. Similarly for interpretable-by-design methods, image classification
experiments in sequential selection methods such as V-IP [6, 7] use all
possible $8\times 8$ image patches as their query set. Overall, using input
data features as “concepts” versus natural language concepts poses the debate
of what semantics the selected features represent. Conversely, in this work,
we focus solely on natural language concepts, providing a more direct and
colloquial description of the underlying models’ decisions.

Foundational Models. OpenAI’s GPT-3 [2] is a Large Language Model (LLM)
trained on large amounts of unlabeled text in a self-supervised manner. Recent
benchmarks have demonstrated that LLMs can perform complex human tasks, such
as passing the Bar Exam [1], showing signs that LLMs are capable of learning
complex concepts and general understanding [3]. Adding other data modalities,
CLIP [27] is a Vision-Language Pre-trained models (VLPs) trained on a large
dataset of image-text pairs. CLIP consists of an image encoder and a text
encoder that output corresponding image and text embeddings whose dot-products
encode cross-modal similarities between images and texts. Furthermore,
improvements on CLIP achieve state-of-the-art performance in tasks such as
zero-shot image classification [20], and related works have found use-cases of
CLIP as an architecture backbone for human-level tasks such as Visual Question
Answering [11, 25] and Video Question Answering [36]. Also known as
Foundational Models (FMs), LLMs and VLPs have demonstrate strong capabilities
to learn complex concepts, which further motivates the use of LLMs to generate
interpretable concepts and the use VLPs to relate similarity between
representations of data across different modalities.

Concept Bottleneck Models. The interpretable-by-design framework (and its
extensions) that we mainly compare with in this work is Concept Bottleneck
Models (CBMs) [16]. A CBM mainly consist of two parts: 1) A nonlinear function
$f:x\mapsto c$ that maps data to a concept feature space, where each feature
corresponds to the relevance of the input sample and a concept from a pre-
defined set of interpretable concepts; and 2) a linear function $g:c\mapsto y$
that maps from concept scores to task labels. $f$ is often a deep network such
as ResNet-18 [13], while the predictor $g$ is chosen to be a simple model such
as a linear network or a decision tree. Similar to V-IP, while every
prediction is made interpretable, applications of CBMs are also limited to
small- to medium-scale tasks where data with dense concept annotations are
available. To address this, extensions of CBMs such as Post-hoc CBM [37], Lf-
CBM [24] and Language in a Bottle (LaBo) [35] use LLMs such as GPT-3 or
WordNet [21] to generate concept sets, and leverage neuron-labeling methods,
such as MILAN [14] and CLIP-Dissect [23], or VLPs such as CLIP [27] to
annotate visual data with texts.

##  3 Methods

Our method can mainly be divided into three main parts: 1) query set
generation with GPT-3; 2) answering queries using CLIP; and 3) performing
interpretable predictions with Variational Information Pursuit (V-IP) [6]. We
begin by first introducing the background on the V-IP framework, including its
original the generative approach to doing IP [5], the sufficiency criteria,
and IP algorithm.

###  3.1 Background: Information Pursuit and Variational Information Pursuit

IP. The Information Pursuit framework was first introduced in Chattopadhyay et
al. [5] as an interpretable-by-design framework to perform interpretable
predictions for any given task. Let $X:\Omega\rightarrow\mathcal{X}$ and
$Y:\Omega\rightarrow\mathcal{Y}$ denote the random variables for input data
and corresponding labels/outputs, and $\Omega$ be the underlying sample space
were all random variables are defined. The user first define a set $Q$ of
task-specific and interpretable queries $q:\mathcal{X}\rightarrow\mathcal{A}$,
where $q(x)\in\mathcal{A}$ is the answer to the query $q\in Q$ evaluated at
$x\in\mathcal{X}$. For all data-label pairs
$(x,y)\in\mathcal{X}\times\mathcal{Y}$, We say that the query set $Q$ is
sufficient for $Y$ when

$P(y\mid x)=P(y\mid\\{x^{\prime}\in\mathcal{X}:q(x^{\prime})=q(x)\\}).$ (1)

An implication of this is that a query set $Q$ is insufficient if we cannot
estimate the posterior $P(y\mid x)$ properly given all query answers of $x$.
With a sufficient query set $Q$, the IP algorithm is described as follows:
Given a data point $x^{\text{obs}}$, the algorithm selects a sequence of most
informative queries, until all remaining queries are nearly uninformative:

$\begin{split}q_{1}&=\text{IP}(\emptyset)=\mathrm{argmax}_{q\in
Q}{I(q(X);Y)};\\\
q_{k+1}&=\text{IP}(\\{q_{i},q_{i}(x^{\text{obs}})\\}_{1:k})=\mathrm{argmax}_{q\in
Q}I(q(X);Y\mid q_{1:k}(x^{\textrm{obs}})).\end{split}$ (2)

Here $q_{k+1}$ denotes the query selected at step $k+1$, given history
$q_{1:k}(x^{\text{obs}})$. $I$ denotes mutual information. The IP algorithm
terminates at the the stopping criteria, defined as the posterior exceeding a
threshold $P(Y\mid q_{1:k}(x^{\text{obs}})>1-\epsilon$ with a certain pre-
determined $\epsilon$. The first formulation proposed in Chattopadhyay et al.
[5] requires learning a generative model for $P(Q(X),Y)$ to estimate the
mutual information terms. However, the method is not scalable to large-scale
tasks due to the large computational cost during inference. To alleviate this
issue, the authors later proposed V-IP, where the posterior distribution is
learned directly using discriminative models, as described next.

Figure 1: Overview of V-IP.

V-IP. Variational Information Pursuit (V-IP) was later introduced as a
variational approach to IP [6]. V-IP defines a predictor $f:S\rightarrow Y$
and a querier $g:S\rightarrow Q$ that map a query-answer chain $S$ of any
length to the posterior distribution of $Y$ and the most informative next
query given $S$, respectively. Parameterized by deep networks $\theta$ and
$\eta$, $f_{\theta}$ and $g_{\eta}$ are trained by sampling random query-
answer chains and optimizing the following V-IP objective:

$\displaystyle\min_{\theta,\eta}\quad$
$\displaystyle\mathbb{E}_{X,S}[D_{KL}(P(Y|X)\|P_{\theta}(Y|q_{\eta}(X),S)]$
where $\displaystyle q_{\eta}:=g_{\eta}(S)$ $\displaystyle P(Y\mid
q_{\eta}(X),S):=f_{\theta}(\\{q_{\eta},q_{\eta}(X)\cup S\\})$

Importantly, Chattopadhyay et al. [6] shows that selecting the query $q_{k+1}$
with the optimal querier $g_{\eta}^{*}$ given any history $S$ is exactly
equivalent to selecting the query with the maximum mutual information in
Equation (2). Hence, performing inference using V-IP can be done with the
trained querier $g_{\eta}^{*}$ in-place of computing the mutual information at
each query:

$\begin{split}q_{1}&=g_{\eta}^{*}(\emptyset)=\mathrm{argmax}_{q\in
Q}{I(q(X);Y)};\\\
q_{k+1}&=g_{\eta}^{*}(\\{q_{i},q_{i}(x^{\text{obs}})\\}_{1:k})=\mathrm{argmax}_{q\in
Q}I(q(X);Y\mid q_{1:k}(x^{\textrm{obs}})).\end{split}$ (3)

Figure 1 shows a flowchart of performing inference with V-IP. Empirical
results show that V-IP is up to 100x faster in computational speed than the
previous generative approach, while being able to scale up to larger scale
datasets such as CIFAR-10/100.

Figure 2: An example of one test sample evaluated using (left) FM+V-IP and
(right) Lf-CBM.

Comparison between CBMs and V-IP. Fundamentally, CBMs and V-IP are two
different explanation methods (Figure 2). V-IP decomposes a model’s prediction
by sequentially selecting simpler semantic queries and updating the posterior
given the query-answers obtained so far, thereby elucidating the model’s
reasoning process. In sharp contrast, CBMs find a simple linear mapping which
draws correlations between concepts and task variables (classes) while
balancing the trade-off between sparsity and accuracy. Ultimately, CBMs and
V-IP both offer valid explanations, and the user may interpret predictions
based on their preference of frameworks. Further method details can be found
in Appendix D.

###  3.2 Designing the Query Set

We describe the method of generating a query set $Q$ by prompting GPT-3. Then,
we compare with three concept filtering methods from Lf-CBM, and argue that
queries filtered by these methods are never selected when using V-IP, hence
removing the need to do concept filtering for the purpose of V-IP.

Query Generation from LLMs. Given that the query set is user-defined, ideally
the user is a domain-knowledge expert who is knowledgeable about the
discriminative information for a given task. Nonetheless, both manually
creating the query set and labeling each sample is a cumbersome and time-
consuming task that is infeasbile for large-scale datasets. In this work, we
formally extend the V-IP framework by leveraging LLMs to generate
interpretable query sets.

We first assume that for popular image classification tasks in the computer
vision community such as ImageNet and fine-grained image classification tasks
such as flower classification with Flower-102 [22], LLMs contain expert
knowledge about both common and fine-grained objects types/classes.
Consequently, LLMs would ideally have learned sufficient information about our
image classification task to generate a task-dependent, informative and
interpretable query set. Moreover, LLMs often come in the format of user-
friendly APIs that take in the form of natural human language for both inputs
and outputs. The familiarity of objects-in-the-wild, colloquiality and ease-
of-access in LLMs make them an attractive choice to extend our query set
designs beyond human experts.

To generate interpretable concepts, we prompt GPT-3 to describe class of
objects in adjectives, which then can be further processed into phrases or
words as concepts. This poses the question of how to create an efficient
prompt that can provide us with a set of interpretable and task-relevant
queries. In this work, we choose a single all-purpose prompt (with appropriate
parameters) as our input to GPT-3:

> List the useful visual attributes (and their values) of the {object} image
> category ‘{class_name}’.

Here the {object} parameter is an argument to the prompt depending on the type
of object we are classifying in the dataset. For instance, we replacing
{object} with “bird” for bird classification, with “scene” for scene
classification, and leave it blank for common object classification such as
ImageNet and CIFAR-10/100. Then, for a given dataset, we iterate each class by
replace the ‘class_name’ parameter with the name of each class. Take CIFAR-10
as an example, we separately input 10 prompts with ‘{object}’ as blank and
‘{class_name}’ as “cars”, “birds”, “cats”, “deer”, “dogs”, “frogs”, “horses”,
“ships”, “trucks”. An example of one run by feeding this prompt to GPT-3 can
be found in the Appendix.

Figure 3: An overview of the method of generating query sets $Q$ and query
answers $Q(X)$.

The output of this prompt is a list, where each item is in the format of
<attribute>:<value> (with the possibility of having multiple values). From
here, one attribute-value pair can then be transformed as a single query or
concept in the format of <value> <attribute>. An example of the entire process
is shown in Figure 3, where we prompt for visual attributes and values of a
“Blue Jay”. Specifically, the attribute-value pair “Size: Medium” is converted
into a query as “medium size”. Therefore, for a $K$-class classification
problem, a GPT-3 generated query set consist of a union of queries transformed
from attribute-value pairs output by different $K$ class dependent prompts. In
Section 4.1, we empirically verify that GPT-3 is capable of generating an
interpretable and task-dependent query set that is suitable for our tasks.

Concept Filtering. Recent methods such as Lf-CBM[24] show that concept
filtering, removing certain concepts from the initial generated set from
GPT-3, is necessary to achieve good test performance and interpretability. For
comparison, we look at some steps of concept filtering in Lf-CBM. We argue
that, in the context of the IP algorithm in 2, filtered queries/concepts are
uninformative, hence will naturally not be selected by our formulation. For
context, we consider $N$-class bird classification as our task and context,
and again denote $x$ and $y$ as the realizations of the data and label random
variable $X$ and $Y$, and $S$ as history.

  1. 1.

Concept Filter 1: Delete concepts too similar to task’s class names. Consider
the binary query: $q=$ “Is the bird in the image a Blue Jay?”. From the
definition of mutual information between $q(X)$ and $Y$,
$I(q(X),Y)=H(Y)-H(Y\mid q(X))=H(Y\mid q(X)=1)P(q(X)=1)+H(Y\mid
q(X)=0)P(q(X)=0).$ Since the answer to the query is Yes, i.e. $q(X)=1$, there
is no ambiguity left in $Y$ and $H(Y\mid q(X)=1)P(q(X)=1)=0$. Hence,
$I(q(X),Y)=H(Y\mid q(X)=0)P(q(X)=0).$ Now, if $Y$ follows a uniform
distribution, then $H(Y)=\log N$ and $H(Y\mid
q(x)=0)P(q(X)=0)=(1-1/N)\log(N-1)$. For a large $N$, $H(Y)\approx H(Y\mid
q(X)=0)P(q(X)=0)$, implying $I(q(X),Y)=H(Y)-H(Y\mid q)\approx 0$. Therefore,
$q$ is an uninformative query and will not be selected.

  2. 2.

Concept Filter 2: Delete concepts too similar to other concepts. Consider
$q_{1}=$ “Is this bird tiny?” and $q_{2}=$ “Is this bird small?”. Reasonably,
$q_{1}$ and $q_{2}$ provide similar information. Since the IP algorithm
selects queries in a sequential manner, once $q_{1}$ has been chosen, $q_{2}$
is unlikely to be the next most informative query. Take the extreme case where
$q_{1}(x)=q_{2}(x)$ for all $x\in\mathcal{X}$, the mutual information between
labels $Y$ and $q_{2}(X)$ is exactly 0 when $\\{q_{1},q_{1}(X)\\}\in S$, i.e.
$I(Y;q_{2}(X)\mid S,q_{1}(X))=0$.

  3. 3.

Concept Filter 3: Delete concepts not present in training data. Consider a
query $q=$ “Is the car red?”. In a bird classification task, a car is
irrelevant for the task, hence $q(x)=0$ is constant for all $x$. This also
implies $I(Y;q(X)\mid S)=0.$

While concept filtering is not needed for V-IP to select the most informative
query, since V-IP requires differentiation through a high-dimensional vector
of query logits, filtering can reduce the size of $Q$, making V-IP more
computational efficient. Although in our experiments we see little-to-no
difference in time to train, finding ways to reduce the size of $Q$ can be
useful for applications such as extreme classification problems [8].

###  3.3 Answering Queries

Once a query set $Q$ is defined, we require a method of computing the query
answers $q(x)$ for every $x\in\mathcal{X}$. Previously, query answers are
either annotations of the dataset or feature values such as pixel values in a
given image. In this work, our generated query sets are concepts expressed in
natural human language and we will leverage CLIP to generate query answers
$q(x)$.

CLIP is a vision-language model trained on image-texts pairs in a contrastive
manner, in which the inner product (with range $[0,1]$) of the output image
and text embedding represents the similarity of a given input image and text.
CLIP consists of two encoders: an image encoder $\mathcal{I}(\cdot)$ and a
text encoder $\mathcal{T}(\cdot)$, where $\mathcal{I}$ takes images $x$ as
input and outputs image vector embeddings $\mathcal{I}(x)$, whereas
$\mathcal{T}$ takes text $q$ (variable size sentences) as input and output a
text embedding $\mathcal{T}(q)$ as output. Note that the dimensions of both
$\mathcal{T}(x)$ and $\mathcal{I}(q)$ are the same, and we assume all
embeddings are $\ell_{2}$-normalized.

Since the dot-product $\mathcal{I}(x)\cdot\mathcal{T}(q)$ encodes the
similarity between the given image $x$ and query $q$, we compute the query
answer $q(x)$ for all $q\in Q$ and $x\in\mathcal{X}$ as the raw dot-product
(score) between the image embedding $\mathcal{T}(x)$ and text embedding
$\mathcal{I}(q)$, i.e. $q(x)=\mathcal{I}(x)\cdot\mathcal{T}(q).$ When $q(x)$
is large (close to 1), the query $q$ and the image $x$ are similar, whereas
when $q(x)$ is small (close to 0) they are dissimilar. Following Lf-CBM, we
also Z-score standardize each query answer by subtracting the mean and
dividing the standard deviation of all query answers from the training set.

In Chattopadhyay et al. [5, 6], queries are binary questions about the data
such as "Are there square windows in the building?". In contrast, in our
framework query answers measure the similarity between the concept and the
data, e.g., the similarity between the concept "Square windows" and an image
of a building. Answering queries in the form of questions is related to the
field of Visual Question Answering (VQA). We reserve the research of more
sophisticated and fine-grained queries for future work.

##  4 Experiments

In this section, we empirically demonstrate that by leveraging LLMs and VLPs,
FM+V-IP addresses the key challenges for doing interpretable-by-design
predictions in three parts: First, we show that LLMs are capable of generating
interpretable and informative query sets (Section 4.1). Then, we show that
V-IP can achieve competitive test performance with both filtered and
unfiltered query sets when compared to Lf-CBM (Section 4.2). Finally, we show
that FM+V-IP with large query sets can achieve comparable test performance
with much fewer number of queries when compared to LaBo (Section 4.3). In the
Appendix, we also showcase an example where a sample is originally
misclassified, then later intervening and corrected by modifying an erroneous
query answer. Last but not least, we document the details of our experiments,
such as training procedure, architecture design, hyperparameters for FM+V-IP,
Lf-CBM and LaBo, as well as examples of queries from each query set and test
samples in the Appendix. Code is available at
https://github.com/ryanchankh/FM-V-IP/.

Figure 4: Comparisons of query-answer chains using V-IP models trained with
(left) GPT-3 query set and (right) original query set. Each $k$-th row
corresponds to the posterior after selecting $k$ queries. In the $x$-axis,
only the four classes with the highest posterior probabilities at the stopping
criteria are shown, with the predicted class in bold. Green and red $y$ axis
labels corresponds to whether $q_{k}(x)$ is above or below 0, with their query
answer $q_{k}(x)$ shown next to $q_{k}$.

###  4.1 Evaluating Query Sets from LLMs with Annotated Data

We first demonstrate that GPT-3 is capable of generating an interpretable and
informative query set. We construct two different query sets for bird
classification task using CUB-200 [33]. The first query set, named original,
has a size of 312 and is constructed from the original 312 attributes of the
CUB-200 dataset, equivalent to the query set used for V-IP in previous works
[5]. The second query set, named GPT-3, has a size of 518 and is constructed
from concepts obtained using the single-design prompt described in Section
3.2. The query answers $q(x)$ are generated using CLIP dot-product as
mentioned in Section 3.3.We train one V-IP model for each of the query set and
compare their test performance.

Figure 5: Test performance of CUB-200 using the original query set original
versus GPT-3 generated query set GPT-3.

By varying $\epsilon$ and evaluating at different stopping criteria $P(Y\mid
q_{1:k}(X))>1-\epsilon$, we compute the average number of queries needed for
each test sample, and compute the trade-off between test accuracy and average
number of queries used in Figure 5. We observe that the test accuracy gained
by increasing the number of queries is similar before the 16${}^{\text{th}}$
query, but as the number of queries increases, V-IP performs approximately 7%
better with the GPT-3 query set than with the original query set after using
96 queries. This implies that the GPT-3 query set contains additional queries
that are more informative for predicting the bird class than the original
queries. We demonstrate this in a direct comparison of query-answer chains
shown in Figure 4: Note that queries related to colors are mainly selected
from the original query set, whereas queries related to different bill shapes
and patterns such as “white pattern: pied” and “mottled pattern” are selected
from the GPT-3 query set. These queries help further distinguish birds with
similar visual features. We show more examples of query-answer chains using
the two query sets in the Appendix.

###  4.2 Evaluating Filtered and Unfiltered Query Sets with Lf-CBM

We use Lf-CBM as our baseline and evaluate the test performance of V-IP using
the filtered and unfiltered query/concept set as Lf-CBM on five datasets:
CIFAR-10 and CIFAR-100 [17], ImageNet [10], CUB-200 [33], and Places365 [39].
Label-free CBM (Lf-CBM) [24] is an extension of CBM, where concepts/queries
$Q$ are first generated by prompting GPT-3, then refined by passing through a
series of concept filters, such as those mentioned in (Section 3.2). Given the
query answers generated from image embeddings of pre-trained neural networks,
a linear predictor is trained using an elastic-net objective with sparsity
parameter $\lambda$ to map from concept scores to class logits. Note Lf-CBM
differs from V-IP in our experiments in two ways: 1) The predictor for Lf-CBM
is linear, whereas the predictor for V-IP is a nonlinear neural network; and
2) The number of concepts used from Lf-CBM is decided by the sparsity
parameter $\lambda$, whereas queries used per sample in V-IP is variable-
length and driven by mutual information. An example of the two methods is
shown in Figure 2. We give the full explanation and details of the Lf-CBM in
the Appendix. For comparison, we denote our method as FM+V-IP.

Figure 6: Test performance of FM+V-IP versus Lf-CBM on CIFAR-10, CIFAR-100,
CUB-200, ImageNet, and Places365. Using a filtered query set
$Q_{\text{filtered}}$, blue solid lines are results from FM+V-IP and blue
dashed lines are baseline results from a neural network classifier without
V-IP. Using an unfiltered query set $Q_{\text{GPT}}$, green solid lines are
results from FM+V-IP and green dashed lines are baseline results from a neural
network classifier without V-IP. Red solid lines are results by training
multiple Lf-CBMs with $Q_{\text{GPT}}$ and varying the sparsity parameter,
while red crosses are results from Lf-CBMs with $Q_{\text{filtered}}$,
directly referenced from Oikarinen et al. [24]. Figure 7: Comparison of test
performance between FM+V-IP and LaBo. Red curve represents the test accuracy
of LaBo after a certain number of queries. The blue curve represents the test
accuracy of FM+V-IP at varying number of queries.

We compare the test performance of FM+V-IP using unfiltered query set
$Q_{\text{GPT}}$ from our single all-purpose prompt to GPT-3 versus Lf-CBM
using a filtered query set $Q_{\text{filtered}}$ from Lf-CBM. In Figure 6, we
demonstrate that FM+V-IP does not require any concept filtering to achieve
comparable test performance. Take CIFAR-10 as an example: using with 30
queries, V-IP achieves 94.11% test accuracy, whereas Lf-CBM achieves 86.40%
test accuracy. From an alternative viewpoint, FM+V-IP achieves the same test
accuracy as Lf-CBM using fewer number of queries. For instance, FM+V-IP only
requires 5 queries to achieve the 86.84% test accuracy whereas Lf-CBM requires
30 concepts to achieve similar test accuracy. On the other hand, for ImageNet,
FM+V-IP obtains a lower test accuracy than Lf-CBM using 45 queries, where the
former achieves a test accuracy at 67.11% and latter at 71.95%. This can be
attributed to the fact that query answers generated by CLIP are too noisy for
the given query sets. Similarly for CUB-200, FM+V-IP achieves a 63.55% test
accuracy whereas Lf-CBM achieves a test accuracy of 74.31%. The drop in
performance is due to the fact that CLIP dot-products are not ideal for
representing fine-grained details of the image (as mentioned in Section 3.3).

Moreover, in Figure 6, we compare the performance of FM+V-IP and Lf-CBM on the
same query set $Q_{\text{GPT}}$ without any filtering. Similar to findings in
Lf-CBM, we run into memory issues when trying to experiment with larger
datasets. Therefore, we only report findings on datasets where the size of the
unfiltered query set is feasible for performing this experiment. For CIFAR-10
and CUB-200, we train multiple-Lf-CBMs by varying the sparsity parameter
$\lambda$ and compute the test accuracy for different number of queries. On
the other hand, we train a single V-IP model for each dataset. For CIFAR-10,
test accuracy for FM+V-IP saturates around 95% using 25 queries, whereas test
accuracy for Lf-CBM never achieves 95%, and requires 80 queries to achieve 92%
test accuracy. For CUB-200, FM+V-IP achieves 65% with 50 queries, whereas Lf-
CBM fails to generalize well. This shows that FM+V-IP is feasible to train and
can perform well with any query set. On the other hand, Lf-CBM requires
concept filtering to become feasible or perform well.

Last but not least, while $Q_{\text{GPT}}$ contains more uninformative queries
than $Q_{\text{filtered}}$, Figure 6 also shows that FM+V-IP still selects
informative queries and attains similar test performance at different number
of queries.

###  4.3 Comparing V-IP and LaBo with the same query set

While V-IP optimizes to find short variable-length query-chains, LaBo first
optimizes a submodular function to select a pre-determined number of suitable
concepts for each class, then predicts using a linear classifier. In this
section, we compare the test performance of V-IP versus LaBo using the same
query set on three datasets: Flower-102 [22], UCF-101 [31] and FGVC-Aircraft
(Aircraft) [19]. For a given dataset, the query set is generated by feeding
multiple prompts to GPT-3 to obtain sentence descriptions for each class, then
processed into individual concepts using the LLM T-5 [28]. In Yang et al. [35]
and in this experiment, the query answers are dot-products of CLIP embeddings
between concepts as text and images. We train one V-IP model for each dataset
with their respective query sets generated from LaBo.

In Figure 7, we show that, while both methods do not require any concept
filtering, V-IP requires 0.02-0.05 times the number of queries of LaBo to
achieve comparable performance. The size of the query set $Q$ are orders of
magnitude larger than filtered concept sets in Lf-CBM: 24960 for Flower-102,
46845 for UCF-101 and 36324 for Aircraft. This further argues that V-IP can
perform and scale competitively with large query sets without requiring
downsizing of the query set.

##  5 Conclusion

In this work, we address the need for data with concept annotations by
proposing a method of leveraging LLMs and VLPs to create query/concept sets
and annotations. We mathematically argue that the sequential selection process
of V-IP avoids the need for any concept filtering, and empirically show that
V-IP is capable of achieving competitive test accuracy on different scales of
datasets when compared with other methods such as Lf-CBM and LaBo.
Nonetheless, we also observe that using CLIP dot-products as query answers can
be noisy for fine-grain concepts, negatively impacting test performance. As
future work we seek to extend the framework for more sophisticated queries and
answering them with more scalable and precise VQA systems, so that task
predictions can obtain better accuracy and be more interpretable.

## References

  * Bommarito II and Katz [2022] Michael Bommarito II and Daniel Martin Katz.  Gpt takes the bar exam.  _arXiv preprint arXiv:2212.14402_ , 2022.
  * Brown et al. [2020] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al.  Language models are few-shot learners.  _Advances in neural information processing systems_ , 33:1877–1901, 2020.
  * Bubeck et al. [2023] Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, et al.  Sparks of artificial general intelligence: Early experiments with gpt-4.  _arXiv preprint arXiv:2303.12712_ , 2023.
  * Chattopadhay et al. [2018] Aditya Chattopadhay, Anirban Sarkar, Prantik Howlader, and Vineeth N Balasubramanian.  Grad-cam++: Generalized gradient-based visual explanations for deep convolutional networks.  In _2018 IEEE winter conference on applications of computer vision (WACV)_ , pages 839–847. IEEE, 2018.
  * Chattopadhyay et al. [2022] Aditya Chattopadhyay, Stewart Slocum, Benjamin D Haeffele, Rene Vidal, and Donald Geman.  Interpretable by design: Learning predictors by composing interpretable queries.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 2022.
  * Chattopadhyay et al. [2023] Aditya Chattopadhyay, Kwan Ho Ryan Chan, Benjamin D Haeffele, Donald Geman, and René Vidal.  Variational information pursuit for interpretable predictions.  _arXiv preprint arXiv:2302.02876_ , 2023.
  * Covert et al. [2023] Ian Covert, Wei Qiu, Mingyu Lu, Nayoon Kim, Nathan White, and Su-In Lee.  Learning to maximize mutual information for dynamic feature selection.  _arXiv preprint arXiv:2301.00557_ , 2023.
  * Daghaghi et al. [2021] Shabnam Daghaghi, Tharun Medini, Nicholas Meisburger, Beidi Chen, Mengnan Zhao, and Anshumali Shrivastava.  A tale of two efficient and informative negative sampling distributions.  In _International Conference on Machine Learning_ , pages 2319–2329. PMLR, 2021.
  * Defazio et al. [2014] Aaron Defazio, Francis Bach, and Simon Lacoste-Julien.  Saga: A fast incremental gradient method with support for non-strongly convex composite objectives.  _Advances in neural information processing systems_ , 27, 2014.
  * Deng et al. [2009] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei.  Imagenet: A large-scale hierarchical image database.  In _2009 IEEE conference on computer vision and pattern recognition_ , pages 248–255. Ieee, 2009.
  * Eslami et al. [2021] Sedigheh Eslami, Gerard de Melo, and Christoph Meinel.  Does clip benefit visual question answering in the medical domain as much as it does in the general domain?  _arXiv preprint arXiv:2112.13906_ , 2021.
  * Haupt and Marks [2023] Claudia E Haupt and Mason Marks.  Ai-generated medical advice—gpt and beyond.  _Jama_ , 329(16):1349–1350, 2023.
  * He et al. [2016] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun.  Deep residual learning for image recognition.  In _Proceedings of the IEEE conference on computer vision and pattern recognition_ , pages 770–778, 2016.
  * Hernandez et al. [2022] Evan Hernandez, Sarah Schwettmann, David Bau, Teona Bagashvili, Antonio Torralba, and Jacob Andreas.  Natural language descriptions of deep visual features.  In _International Conference on Learning Representations_ , 2022.
  * Kingma and Ba [2014] Diederik P Kingma and Jimmy Ba.  Adam: A method for stochastic optimization.  _arXiv preprint arXiv:1412.6980_ , 2014.
  * Koh et al. [2020] Pang Wei Koh, Thao Nguyen, Yew Siang Tang, Stephen Mussmann, Emma Pierson, Been Kim, and Percy Liang.  Concept bottleneck models.  In _International Conference on Machine Learning_ , pages 5338–5348. PMLR, 2020.
  * Krizhevsky et al. [2009] Alex Krizhevsky, Geoffrey Hinton, et al.  Learning multiple layers of features from tiny images.  2009\.
  * Lundberg and Lee [2017] Scott M Lundberg and Su-In Lee.  A unified approach to interpreting model predictions.  _Advances in neural information processing systems_ , 30, 2017.
  * Maji et al. [2013] S. Maji, J. Kannala, E. Rahtu, M. Blaschko, and A. Vedaldi.  Fine-grained visual classification of aircraft.  Technical report, 2013.
  * Menon and Vondrick [2022] Sachit Menon and Carl Vondrick.  Visual classification via description from large language models.  _arXiv preprint arXiv:2210.07183_ , 2022.
  * Miller [1998] George A Miller.  _WordNet: An electronic lexical database_.  MIT press, 1998.
  * Nilsback and Zisserman [2008] Maria-Elena Nilsback and Andrew Zisserman.  Automated flower classification over a large number of classes.  In _2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing_, pages 722–729. IEEE, 2008.
  * Oikarinen and Weng [2022] Tuomas Oikarinen and Tsui-Wei Weng.  Clip-dissect: Automatic description of neuron representations in deep vision networks.  _arXiv preprint arXiv:2204.10965_ , 2022.
  * Oikarinen et al. [2023] Tuomas Oikarinen, Subhro Das, Lam M Nguyen, and Tsui-Wei Weng.  Label-free concept bottleneck models.  _arXiv preprint arXiv:2304.06129_ , 2023.
  * Parelli et al. [2023] Maria Parelli, Alexandros Delitzas, Nikolas Hars, Georgios Vlassis, Sotirios Anagnostidis, Gregor Bachmann, and Thomas Hofmann.  Clip-guided vision-language pre-training for question answering in 3d scenes.  _arXiv preprint arXiv:2304.06061_ , 2023.
  * Paszke et al. [2017] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer.  Automatic differentiation in pytorch.  2017\.
  * Radford et al. [2021] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al.  Learning transferable visual models from natural language supervision.  In _International conference on machine learning_ , pages 8748–8763. PMLR, 2021.
  * Raffel et al. [2020] Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu.  Exploring the limits of transfer learning with a unified text-to-text transformer.  _The Journal of Machine Learning Research_ , 21(1):5485–5551, 2020.
  * Ribeiro et al. [2016] Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin.  " why should i trust you?" explaining the predictions of any classifier.  In _Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining_ , pages 1135–1144, 2016.
  * Selvaraju et al. [2017] Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra.  Grad-cam: Visual explanations from deep networks via gradient-based localization.  In _Proceedings of the IEEE international conference on computer vision_ , pages 618–626, 2017.
  * Soomro et al. [2012] Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah.  Ucf101: A dataset of 101 human actions classes from videos in the wild.  _arXiv preprint arXiv:1212.0402_ , 2012.
  * Sundararajan et al. [2017] Mukund Sundararajan, Ankur Taly, and Qiqi Yan.  Axiomatic attribution for deep networks.  In _International conference on machine learning_ , pages 3319–3328. PMLR, 2017.
  * Wah et al. [2011] Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie.  The caltech-ucsd birds-200-2011 dataset.  2011\.
  * Wu and Barsalou [2009] Ling-ling Wu and Lawrence W Barsalou.  Perceptual simulation in conceptual combination: Evidence from property generation.  _Acta psychologica_ , 132(2):173–189, 2009.
  * Yang et al. [2022] Yue Yang, Artemis Panagopoulou, Shenghao Zhou, Daniel Jin, Chris Callison-Burch, and Mark Yatskar.  Language in a bottle: Language model guided concept bottlenecks for interpretable image classification.  _arXiv preprint arXiv:2211.11158_ , 2022.
  * Ye et al. [2023] Shuhong Ye, Weikai Kong, Chenglin Yao, Jianfeng Ren, and Xudong Jiang.  Video question answering using clip-guided visual-text attention.  _arXiv preprint arXiv:2303.03131_ , 2023.
  * Yuksekgonul et al. [2022] Mert Yuksekgonul, Maggie Wang, and James Zou.  Post-hoc concept bottleneck models.  _arXiv preprint arXiv:2205.15480_ , 2022.
  * Zang et al. [2022] Yuhang Zang, Wei Li, Kaiyang Zhou, Chen Huang, and Chen Change Loy.  Unified vision and language prompt learning.  _arXiv preprint arXiv:2210.07225_ , 2022.
  * Zhou et al. [2017] Bolei Zhou, Agata Lapedriza, Aditya Khosla, Aude Oliva, and Antonio Torralba.  Places: A 10 million image database for scene recognition.  _IEEE Transactions on Pattern Analysis and Machine Intelligence_ , 2017.

## Appendix

##  Appendix A Extended Results

###  A.1 Intervention on Misclassified Examples

One key contribution from CBMs from Koh et al. [16] is the ability to
intervene a model’s decisions. This ability is especially useful in the case
where the classifier make a erroneous prediction due to a mis-labled concept.
In this section, we demonstrate one example of intervention on models trained
with FM+V-IP.

While in this work we mainly focus on using dot-products of CLIP image and
text embeddings as query answers, since CLIP is not trained for the purpose of
VQA, query-answers can be noisy and incorrect. Hence, the ability to interpret
and intervene a model’s decisions has great significance, especially erroneous
prediction due to an incorrectly annotated concept/query-answer.

Figure 8: Intervention on an misclassified sample in CIFAR10.

Here we illustrate one example that FM+V-IP has the ability to intervene the
sequential selection process of queries during inference and correct a
misclassification result. A misclassified image of an airplane from CIFAR-10
is shown in Figure 8. The top figure shows the posterior using original query-
answer chain (history) $P(Y\mid S=q_{1:6}(x))$, making an incorrect prediction
of the class “ship”. Note that since the object in the image does not resemble
a (bird) nest, they should be dissimilar and have a negative score. Hence,
following the sequence of queries selected by the trained model, we edit the
query answer $q_{3}(x)\rightarrow\hat{q}_{3}(x)$ for “a nest” from a positive
score 0.1873 to a negative score $-1$, With the updated query answer
$\hat{q}_{3}(x)$, the model now outputs the correct posterior $P(Y\mid
S\setminus q_{3}(x),\hat{q}_{3}(x))$ and predicts the correct class label
“airplanes” with high confidence.

###  A.2 Test Performance of FM+V-IP with More Queries

We show extended results of test performance of FM+V-IP versus Lf-CBM on
different datasets and query sets in Figure 9. For any dataset, the baseline
result is computed by training only the classifier of the FM+V-IP model on all
query answers; This is equivalent to training a vanilla fully-connected neural
network with all query answers as input features. Ideally, the test
performance of the baseline classifier should approximately upper bound the
test performance of models trained with FM+V-IP with any number of queries.

From Figure 9, we see that as the number of queries increase, the test
performance of FM+V-IP approaches the baseline test performance. Specifically,
we see that CIFAR-10, ImageNet and Places365 can achieve the same test
performance as baseline at 100, 200, and 200 queries respectively.
Nonetheless, we also observe that CUB-200 and CIFAR-100 never arrives at the
desired test performance, even with extra number of queries. This could be
attributed to the expressivity of the architecture. In FM+V-IP, the choice of
the predictor $f_{\theta}$ is arbitrary and flexible. Hence, the gap in
performance could potentially be addressed via better neural network
architecture search.

Figure 9: Test performance of FM+V-IP and Lf-CBM. This figure is the same
figure as Figure 6, except each model is evaluated with longer number of
queries.

###  A.3 Accuracy of Attributes Evaluated on Annotated Dataset

Here we evaluate the accuracy of CLIP-generated answers (i.e.
$q(x)=\mathcal{I}(x)\cdot\mathcal{T}(q)\in[0,1]$). Specifically, using the
CUB-200 dataset, we compare the answers obtained from CLIP and the expert-
labeled annotated attributes from CUB-200. Since given attributes are
binarized, we use the validation set to compute the best threshold for
binarization, where $q(x)$ rounds up to 1 if it is above the threshold, and
rounds down 0 if $q(x)$ is below the threshold. For each train/test/validation
split, we first compute the accuracy for each attribute over all samples, then
compute the average attribute accuracy by taking the average of accuracies
over all attributes. For the training set, we obtain an average accuracy of
88.3%. For the validation and test set, both obtain an average accuracy of
88.2%. We highlight that although the query answers are not fully correct,
noisy query answers do not have a large impact on the interpretability of
FM+V-IP.

###  A.4 Explanations from FM+V-IP

For each input, our method FM+V-IP generates a query-answer chain as a means
of explaining the model’s decision making, breaking it down into simpler
questions and provide a sequential reasoning to the prediction problem. We
explicitly showcase this reasoning in words in Figure 10. This coarse-to-fine
reasoning is vastly different than explanations that CBMs offer, which is to
find a sparse set of concepts that most correlate to the input, for
prediction. We hope to highlight the benefits of the use of foundational
models, including concept filtering via mutual information, with V-IP through
this work.

Figure 10: An example of query-answer chain from CIFAR-100. FM+V-IP first
selects queries such as “partial cloud cover” and “thick fur texture” to
differentiate between the “animals” super-classes and “buildings” super-
classes. It further ask queries such as “light traffic” to differentiate
between indoor and outdoor buildings. Finally, it ask queries such as
“rectangular windows” to differentiate the finer classes, namely as
skyscraper, castle and bridges.

##  Appendix B Limitations

In this work, we only focus on the task of interpretable image classification
using FM+V-IP with GPT-3 for generating queries and CLIP dot-products for
answering. One limitation of FM+V-IP is that CLIP dot-products can be noisy
and inaccurate, which can severely impact predictive accuracy. Reasonably,
CLIP is pretrained on large number of text and image pairs, which the text may
or may not describe the image in a fine-grain enough detail to accurate
represent any data. A future work may involve using Visual Question Answering
(VQA) systems to answer queries, which allows the design of queries to be more
flexible and the answer of the query to be precise. Ideally, this would not
only improve the test performance due to cleaner query answers, but also
improve the interpretability of the model.

Another limitation is that concepts generated by GPT-3 could potentially be
non-visual. While we construct our prompt by explicitly mentioning “visual
attributes," there is no explicit filter that controls the interpretability of
the output itself. We reserve incorporating such control in our
concept/language generation process [34] or using prompt learning for finding
more interpretable concepts [38] for future work.

In addition, in this work we focus on solving visual tasks, but our framework
can be further extended to other modalities including medical data, where
generative models such as GPT finetuned on medical data [12] can be leveraged
for generating and answering queries. We also reserve this for further work.

##  Appendix C Broader Impacts

Intepretable predictions plays a key role in gaining the trust of the user
when machine learning models are deployed in real-world uses. In this work, we
advocate that interpretability should be a built-in functionality of the
models. While this work focuses on common object image classification tasks,
our framework can be expanded to other risk-sensitive applications domains
such as medical imagining. Meanwhile, explanations has a potential to de-bias
algorithms by realizing why the predictor makes a correct or incorrect
prediction, and we aim to make machine learning algorithms more accessible and
fair for people regardless of their ethnic or social status.

##  Appendix D Method Details

###  D.1 Label-free CBM (Lf-CBM)

Label-free Concept Bottleneck Model (Lf-CBM) was introduced in [24] as a
method to address the lack of concept-annotated data for making interpretable
predictions. For a given image classification task, similar to FM+V-IP, the
method first create an initial concept set by prompting GPT-3 to describe
different classes from the task. Then, using a series of concept filtering
steps, such as removing concepts too similar to class names, or concepts too
similar to each other, a concept set is generated.

The method then learns a weight matrix that projects image embeddings from
deep networks into a concept space. Given a pre-trained deep network $f$, such
as ResNet-18 [13], we first compute an image embedding $f(x)$ for an input
image $x$. Then we train a linear network with weight $W_{c}$ that maps from
image embedding to a feature space known as “concept bottleneck layer”, i.e.
$f_{c}(x)=W_{c}f(x)$. This layer is trained with a “cosine cubed” similarity
loss [24], where $f_{c}(x)$ are encouraged to align with a matrix $P$,
constructed from taking the dot-product between image embeddings of all
training images and text embeddings of all concepts. Finally, it learns a
linear predictor $g(x)=W_{F}f_{c}(x)+b_{F}$ that predicts the label $y$ of the
given image $x$. $g$ is trained with an elastic-net objective:

$\min_{W_{F},b_{F}}\sum^{N}_{i=1}\mathcal{L}_{\text{CE}}(W_{F}f_{c}(x_{i})+b_{F},y_{i})+\lambda
R_{\alpha}(W_{F}),$

where
$R_{\alpha}(W_{F})=(1-\alpha)\frac{1}{2}\|W_{F}\|_{F}+\alpha\|W_{F}\|_{1,1}$.
$N$ is the number of training samples, $\|\cdot\|_{F}$ here denotes the
Frobenius norm and $\|\cdot\|_{1,1}$ denotes the element-wise 1-norm.
$\lambda$ is a parameter to tune for sparsity, the number of concepts used for
prediction. In our experiments in Section 4.2, we tune $\lambda$ to achieve
different levels of sparsity.

###  D.2 Language in a Bottle (LaBo)

Introduced in Yang et al. [35], LaBo also proposes to perform interprertable
predictions with CBMs by using LLMs to generate concepts and computing concept
scores with dot products of image and text embeddings from CLIP for each image
and concept. The method of generating a concept set is as follows: we first
prompt GPT-3 to describe attributes of different image classes using various
general template. Then, we use a T5 concept extractor [28], another LLM
finetuned on extracting key phrases from sentences, to extract short concepts.
Finally, concepts with class names are processed, by either replacing the
class name with its superclass name or completely removing the concept from
the concept set.

Given $N$ samples of data and labels $\\{x_{i},y_{i}\\}_{i=1}^{N}$ for a
$K$-class classification problem, and a candidate set of concepts
$S=S_{1}\cup\ldots\cup S_{K}$ obtained from the above method, LaBo optimizes
the following composite objective:

$\min_{f,C}\sum^{N}_{i=1}\mathcal{L}_{\text{CE}}(f(g(\mathcal{I}(x_{i}),E_{C}),y_{i}))-\mathcal{F}(C,\\{\mathcal{I}(x_{i}),y_{i}\\}_{i=1}^{N}).$

The above adjective is solved sequentially: first we solve for the
maximization problem of seeking the optimal set of concepts $C$ from a large
candidate set $S$, then solve the minimization of cross entropy loss for the
linear predictor $f$. Again, $\mathcal{I}$ denotes the CLIP image encoder and
$\mathcal{T}$ denotes the CLIP text encoder.

Noteably, $\mathcal{F}$ is a submodular function that defines a
discriminability score and a coverage score for any subset $C$. Maximizing
$\mathcal{F}$ leads to an optimal subset of concepts $C_{y}$ from a large
candidate set $S_{k}$ for each class that optimizes for finding discriminative
concepts (similar to not having two concepts that similar to each other) and
concepts that emcompass most of the semantics of the overall candidate concept
set.

Having solved the maximization problem, $C$ determines the choice of $E_{C}$,
which is a matrix whose row vectors are text embeddings of all concepts $c\in
C$, i.e. $E_{C}=[\mathcal{T}(c_{1})|\ldots|\mathcal{T}(c_{|C|})]^{\top}$. And
$g(x,E_{C})=E_{C}x$ is a matrix multiplication of the image embedding $x$ with
text embeddings of selected concepts, hence the output of $g$ is a vector of
concept scores for $x$. Finally, similar to CBMs, $f$ consisnt of a weight
matrix $W$ that maps concept scores to label logits.

###  D.3 Difference between Lf-CBM, LaBo and FM+V-IP

We emphasize that all three methods, Lf-CBM, LaBo, and FM+V-IP, use GPT-3 as a
starter to generate concepts. Nonetheless, our work advocates that FM+V-IP do
not require any type of concept filtering, whereas Lf-CBM requires multiple
step of ad-hoc concept filtering and LaBo requires first finetuning a T5 LLM
and similar concept filtering steps. Not having the need for concept
filtering, either for the sake of improving test accuracy or interpretability,
is the main advantage of FM+V-IP, as removing concepts involves the risk of
discarding potentially meaningful concepts.

In addition, both LaBo and FM+V-IP use dot-products of image and text
embeddings from CLIP directly as concept scores/query answers, whereas Lf-CBM
trains a concept bottleneck layer that maximizes alignment between transformed
image embedding ($f_{c}(x)$ from Appendix Section D.1) and CLIP dot products.
From our experiments, we see that CLIP dot-products are generally suitable for
our image classification tasks, but image embeddings may be fetter fine-grain
classification, since pre-trained models are finetuned on images from the
given dataset of the task for extracting fine-grain features.

Finally, the number of queries/concepts for each prediction is chosen
differently: In Lf-CBM, the sparsity parameter $\lambda$ decides the number of
concepts used, where a larger $\lambda$ leads to smaller number of concepts.
In Oikarinen et al. [24], $\lambda$ is chosen such that the model only uses
25-35 concepts. In LaBo, each classes selects a pre-defined number of
concepts. The user has control over this parameter and can chooses exactly
however many concepts LaBo uses for prediction. In our work FM+V-IP, the
number of queries is decided by the stopping criteria, where we stop querying
only when the posterior saturates at a desired level. This also reflects the
model’s confidence in the prediction after certain number of queries. It’s
worth noting that the number of queries used for each sample can vary for
FM+V-IP, whereas the number of concepts used is fixed for once the
hyperparameters is selected.

##  Appendix E Implementation Details

All of our experiments are implemented using Python 3.9 with PyTorch version
1.12 [26]. All experiments are done on one computing node with 64-core 2.10GHz
Intel(R) Xeon(R) Gold 6130 CPU, eight NVIDIA GeForce RTX 2080 GPU (each with
10GB memory) and 377GB of RAM.

Datasets. In this paper, we used 9 datasets in total: CUB-200 [16], CIFAR-10
and CIFAR-100 [27], ImageNet [10], Places365 [39], Flower-102 [22], FGVC-
Aircraft (Aircraft) [19], and UCF-101 [31]. For CUB-200, CIFAR-10 and
CIFAR-100, ImageNet, Places365, we use the same training and testing split as
Lf-CBM [24]. For Flower-102, FGVC-Aircraft (Aircraft), and UCF-101, we use the
same training, validation, and testing split as LaBo [35]. For summary, the
size of each split and the number of classes for each dataset is listed in
Table 2.

Dataset | CUB-200 | CIFAR-10 | CIFAR-100 | ImageNet | Places365 | Flower-102 | Aircraft | UCF-101
---|---|---|---|---|---|---|---|---
# Train | 4,796 | 50,000 | 50,000 | 1.3 mil. | 1.8 mil. | 4,093 | 3,334 | 7.639
# Validation | 1,198 | - | - | 50,000 | 36,000 | 1,633 | 3,333 | 1,898
# Test | 5,794 | 10,000 | 10,000 | - | - | 2,463 | 3,333 | 3,783
# Classes | 200 | 10 | 100 | 1,000 | 365 | 102 | 102 | 101

Table 2: Number of samples in training, validation, and testing splits, as
well as the number of classes for each dataset.

Note that there are multiple versions of Places365 dataset. In this work, we
use the standard dataset with small images.

Query Sets $Q$. In Section 4.1 and Section 4.2, we generate a query set by
prompting GPT-3 with the following hyperparameters: text-davinci-003 engine, 0
temperature, 500 maximum tokens, top_p=1, 0 frequency penalty and 0.5 presence
penalty. Query set $Q_{\text{filtered}}$ in Section 4.2 and query set in
Section 4.3 (here we denote as $Q_{\text{LaBo}}$) are directly obtained from
GitHub repositories of Lf-CBM111https://github.com/Trustworthy-ML-Lab/Label-
free-CBM and LaBo222https://github.com/YueYANG1996/LaBo. The size of each
query set is listed in Table 3:

Size | CUB-200 | CIFAR-10 | CIFAR-100 | ImageNet | Places365 | Flower-102 | Aircraft | UCF-101
---|---|---|---|---|---|---|---|---
$Q_{\text{filtered}}$ | 208 | 128 | 824 | 4523 | 2207 | - | - | -
$Q_{\text{GPT}}$ | 518 | 204 | 1152 | 4495 | 2491 | - | - | -
$Q_{\text{LaBo}}$ | - | - | - | - | - | 24960 | 36324 | 46845

Table 3: Query set sizes for different datasets. $Q_{\text{filtered}}$ was
used in Section 4.2, and is referenced directly from Lf-CBM [24].
$Q_{\text{GPT}}$ was used in Section 4.1 and Section 4.3. $Q_{\text{LaBo}}$ is
used in Section 4.3, and is referenced directly from LaBo [35].

Query Answers $Q(X)$. Query answers are computed using CLIP dot-products.
Again, we denote $\mathcal{I}(\cdot)$ and $\mathcal{T}(\cdot)$ as the image
and text encoder from CLIP. For any task and dataset, we obtain the image
embeddings of all images $\mathcal{I}(x)\ \forall x\in\mathcal{X}$ and
$\mathcal{T}(q)\ \forall q\in Q$. Each embedding is assumed to be
$\ell_{2}$-normalized, then the query answer
$q(x)=\mathcal{I}(x)\cdot\mathcal{T}(q)$. Following Lf-CBM, we further Z-score
standardize each query answer by subtracting the mean and dividing the
standard deviation of query answers from the training set:

$q(x)\leftarrow\frac{q(x)-\hat{\mu}}{\hat{\sigma}},\quad\hat{\mu}=\frac{1}{|\mathcal{X}||Q|}\sum_{x\in\mathcal{X}}\sum_{q_{\in}Q}q(x),\quad\hat{\sigma}=\sqrt{\sum_{x\in\mathcal{X}}\sum_{q\in
Q}\frac{(q(x)-\hat{\mu})^{2}}{|\mathcal{X}||Q|}},$ (4)

which can be computed easily with np.mean and np.std.

For experiments in Section 4.1 and Section 4.2, we use CLIP with ViT-B/16
backbone. For experiments in Section 4.3, we use the same backbone as Labo and
use CLIP with ViT-L/14 backbone [35]. Each image is preprocessed with CLIP’s
default preprocess function [27].

Representing and Updating the History $S$. In V-IP framework, the input to
predictor $f_{\theta}$ and querier $g_{\eta}$ are both histories $S$. Similar
to Chattopadhyay et al. [6], the history for a sample $x$, $S(x)$, is
represented as the product of $|Q|$-dimensional feature vector for all query
answers $Q(x)$ and a binary mask $M$, i.e. $Q(x)\odot M$, where $\odot$ here
represents point-wise multiplication, also known as the Hadamard product. The
$i$-th dimension corresponds to the query answer $q_{i}(x)$. We set $M_{i}$ to
$0$ if the $q_{i}(x)\not\in S$ and $1$ if $q_{i}(x)\in S$. Hence, a history
with all query answers has $M$ equal to a vector of all ones, and an empty
history is represented by a mask of all zeros.

Suppose we have a history for sample $x$ of size $k$, $S_{k}(x)=Q(x)\cdot
M_{k}$. To update the history $S_{k}$ with an additional query from the output
of the querier $g_{\eta}(S_{k})$, we simply update the mask and the history
by:

$M_{k+1}\leftarrow M_{k}+g_{\eta}(S_{k})\quad\text{and}\quad S_{k+1}\leftarrow
S_{k}+Q(x)\odot g_{\eta}(S_{k})$

In other words, the new query is mathematically represented as a one-hot
vector with dimension $|Q|$, hence updating the representation of history is
equivalent to updating the binary mask $M$ by setting $i$-th position to 1,
indicating that the $q_{i}(x)$ is in the updated history $S_{k+1}(x)$.

Architectures. In this work, we only have two design choices for the predictor
$f_{\theta}$ and querier $g_{\eta}$, which we will denote them as shallow and
deep. shallow is a two-layer fully connected neural network, and deep is a
four-layer fully connected neural network. Diagrams of their architecture is
shown in Figure 11. The shallow architecture is used for medium-scale datasets
CIFAR-10, CIFAR-100, CUB-200, Flower-102, FVGC-Aircraft, and UCF-101. The deep
architecture is used for large-scale datasets ImageNet and Places365. The
number of parameters for each experiment is listed in Table 4. The
architecture design is chosen empirically based on the performance of the
model. The size of the query set only affects the final output dimension of
the querier $g_{\eta}$, and the number of classes affects the final output
dimension of the classifier $f_{\theta}$. In all of our experiments, we do not
share the weights between $f_{\theta}$ and $g_{\eta}$. We apply Softmax
operator to class logits and query scores to obtain probability for each class
and probability for each query.During training, a Straight-through softmax
with temperature parameter $\tau$ is used for computing query probabilities.
For every experiment, we linear decay $\tau$ from $1.0$ to $0.2$ for 20 epochs
333$\tau=1.0$ is equivalent to regular Softmax operator, whereas
$\tau\rightarrow 0$ corresponds to $\mathrm{argmax}(\cdot)$ operator.. We find
V-IP training is rather insensitive to how we anneal $\tau$.

# of Parameters | CUB-200 | CIFAR-10 | CIFAR-100 | ImageNet | Places365 | Flower-102 | Aircraft | UCF-101
---|---|---|---|---|---|---|---|---
$Q_{\text{filtered}}$ | 3,051,408 | 2,596,138 | 5,773,924 | 41,659,523 | 29,441,572 | - | - | -
$Q_{\text{GPT}}$ | 4,446,718 | 2,938,214 | 7,250,252 | 41,519,495 | 3,0861,856 | - | - | -
$Q_{\text{LaBo}}$ | - | - | - | - | - | 126,942,062 | 183,773,426 | 236,387,946

Table 4: The total number of parameters for each dataset.

Training FM+V-IP. Every FM+V-IP experiment for medium-scale datasets CIFAR-10,
CIFAR-100, CUB-200, Flower-102, Aircraft, and UCF-101 follow the two-stage
training procedure mentioned in the Chattopadhyay et al. [6], where we
optimize the V-IP objective for $f_{\theta}$ and $g_{\eta}$ with random
histories, by first using the Randomly Sampling strategy for $4000$ epochs
with learning rate $0.0001$, followed by the Subsequent Biased Sampling
strategy for $1500$ epochs with learning rate $0.00005$. In both stages, we
train using Adam Optimizer [15] with no weight decay, along with Cosine
Annealing learning rate scheduler and hyperparameter T_max=100.

Similarly, for large-scale datasets ImageNet and Places365, we also follow the
two-stage training procedure. We use the same optimizer and learning rate
scheduler with the same optimizer hyperparameter as mentioned above, but we
train the Random Sampling stage for $400$ epochs, and train the Subsequent
Biased Sampling stage for $40$ epochs. In both stages, we also train using
Adam Optimizer [15] with no weight decay, but with Cosine Annealing learning
rate scheduler and hyperparameter T_max=100.

Training Baselines. In Figure 6, we compare the test performance of FM+V-IP
with Lf-CBM for different query sets, along with with baselines, where we
train the predictor for V-IP without the querier on all query answers. For
fair comparison, classifier for each dataset is the same as the predictor from
training FM+V-IP. For medium-scale datasets, we train for $1000$ epochs using
Adam Optimizer with learning rate $0.0001$ and no weight decay, and Cosine
Annealing learning rate scheduler with hyperparameter T_max=100.

(a) shallow architecture for (left) predictor $f_{\theta}$ and (right) querier
$g_{\eta}$.

(b) deep architecture for (left) predictor $f_{\theta}$ and (right) querier
$g_{\eta}$.

Figure 11: Architecture designs for shallow and deep. “shared” implies the
weights are shared between the two linear layers. “Concatenated” implies the
output from previous layers are concatenated ($a\in\mathbb{R}^{1\times
n},b\in\mathbb{R}^{1\times},\mathrm{concat(a,b)=[a|b]\in\mathbb{R}^{1\times(n+m)}}$).
Every arrow $\rightarrow$ before the concatenation and after the input layer
is LayerNorm of appropriate dimension, followed by ReLU.

Training Lf-CBMs. In Section 4.2, we trained multiple Lf-CBMs with varying
sparsity level $\lambda$ using the unfiltered query set $Q_{\text{GPT}}$. To
train these models, we optimize using GLM-SAGA optimizer [9] with the same
hyperparameters as mentioned in Lf-CBM [24]. We obtain results with different
sparsity levels with
$\lambda\in\\{0.05,0.045,0.0401,0.03516,0.03022,0.02527,0.02033,0.01538,0.01044,0.0055\\}$
for CUB-200 and with $\lambda\in\\{0.101,0.0101,0.005051,0.002121,0.001414\\}$
for CIFAR-10.

Inference Time. Inference on one sample involves performing multiple forward
pass on the querier $g$ to obtain the next optimal query and the classifier
$f$ to obtain the posterior distribution $P(Y|S)$. Using our hardware, one
forward pass takes no more than 0.1 seconds. Inference speed can be further
improved by batch processing on multiple samples, depending on hardware memory
limitations. For each sample, we begin with an empty set, and append new
queries selected by the querier. In contrast, inference on Lf-CBM, LaBo or
vanilla NNs are faster, since they only involve a single forward pass, either
on a single linear map or on a nonlinear neural network. Nevertheless,
relatively speaking, we believe believe a 0.1 second overhead in inference
time to be minuscule.

##  Appendix F Ablation Study

###  F.1 CLIP Text Embeddings: Prompt-tuning for Queries

Figure 12: Test performance of FM+V-IP using different prompts for compute
text embeddings for queries. “FM+VIP” are results trained with V-IP, where as
“NN without V-IP” are results from training the classifier only with all query
answers.

Radford et al. [27] has demonstrated in their work that CLIP can achieve
state-of-the-art test performance in zero-shot image classification tasks. To
do so, they first compute the image embeddings for every test image. Then for
each class name {class_name}, they use multiple possible prompts such as “a
bright photo of a {class_name},” “a photo of a dirty {class_name},” “a photo
of a small {class_name}.” Intuitively, the optimal prompt should predict the
correct class with a higher score (dot-product between image and text
embeddings). Here, we perform a similar study, where we compare the difference
in test performance when using four different prompts given a query/concept
{concept}:

  1. 1.

No Prompt: {concept}

  2. 2.

Prompt 1: An image of an object with {concept}.

  3. 3.

Prompt 2: An image of an small object with {concept}.

  4. 4.

Prompt 3: A small image of an object with {concept}.

Our results for CIFAR-10 are shown in Figure 12. We find that using the
different prompts result in little difference in test performance for FM+V-IP.
From our baselines, which are models from training the classifier only with
all query answers, we also see there is little-to-no difference in test
performance.

###  F.2 CLIP Image Embeddings: Using Different Backbones

Figure 13: Test performance of FM+V-IP with different backbones.

As mentioned above, CLIP provides the choice of choosing a backbone as the
image encoder. Reasonably, the more parameters the backbone has, the better
the quality of the text embeddings should be. Here, we experiment with the
following three different backbones and observe the impact the choice of
backbone has on test performance for FM+V-IP:

  1. 1.

RN50: ResNet-50. This architecture has the least parameters.

  2. 2.

ViT-B\16: Vision Transformer with Base architecture with $16\times 16$ image
patches

  3. 3.

ViT-L\14: Vision Transformer with Large architecture with $14\times 14$ image
patches. This architecture has the most parameters.

Our results for CIFAR-10 are shown in Figure 13. As expected, the encoder with
more parameters have higher quality image embeddings, the query answers are
less noisy and help FM+V-IP achieves better performance. Notably, at 15
queries, FM+V-IP using ViT-L\14 achieves a 96% test accuracy, whereas RN50
achieves a 79% test accuracy, a difference of about 17%. From this, we can
conclude that the number of parameters in the image encoder backbone has a big
impact on the test performance of FM+V-IP.

##  Appendix G Further Examples of Query-Answer Chains

We illustrate more test examples of query-answer chains using FM+V-IP with the
$Q_{\text{GPT}}$ query set from Section 4.2 on CIFAR-10 14, CIFAR-100 15,
CUB-200 16, ImageNet 17, Places365 18. We also show test examples using
FM+V-IP with LaBo’s query set from Section 4.3 on Flower-102 19, FGVC-Aircraft
20, and UCF-101 21. Different stopping criteria is used for each dataset:
$\epsilon=0.95$ for CIFAR-10, $\epsilon=0.85$ for CIFAR-100, $\epsilon=0.8$
for CUB-200, $\epsilon=0.8$ for ImageNet, $\epsilon=0.8$ for Places365,
$\epsilon=0.9$ for Flower-102, $\epsilon=0.9$ for FGVC-Aircraft, and
$\epsilon=0.9$ for UCF-101. For datasets with more than 10 classes, we show
only the classes with the top 10 probability class where IP terminates.
Similar to other examples of query-answer chains, green/red query (y-axis of
the plots) represents whether query answer is above/below 0.

The query set used for Flower-102, FGVC-Aircraft and UCF-101 are from LaBo,
which is also available on their github. Since their prompts are not visual-
attribute specific, some concepts may appear non-visual related.

Figure 14: Five examples of query-answer chains from CIFAR-10.

Figure 15: Five examples of query-answer chains from CIFAR-100.

Figure 16: Five examples of query-answer chains from CUB-200.

Figure 17: Five examples of query-answer chains from ImageNet.

Figure 18: Five examples of query-answer chains from Places365.

Figure 19: Five examples of query-answer chains from Flower-102.

Figure 20: Five examples of query-answer chains from FGVC-Aircraft.

Figure 21: Five examples of query-answer chains from UCF-101.


# Signals of the QCD Critical Point in Hydrodynamic Evolutions

Chiho Nonakaa, M. Asakawab, S. A. Bassc, B. Müllerc aDepartment of Physics,
Nagoya University, Nagoya 464-8602, Japan
bDepartment of Physics, Osaka University, Toyonaka 560-0043, Japan
cDepartment of Physics, Duke University, Durham, North Carolina 27708, USA

###### Abstract

The presence of a critical point in the QCD phase diagram can deform the
trajectories describing the evolution of the expanding fireball in the
$\mu_{B}$-$T$ phase diagram. The deformation of the hydrodynamic trajectories
will change the transverse velocity ($\beta_{T}$) dependence of the proton-
antiproton ratio when the fireball passes in the vicinity of the critical
point. An unusual $\beta_{T}$ dependence of the $\bar{p}/{p}$ ratio in a
narrow beam energy window would thus signal the presence of the critical
point.

††journal: Nuclear Physics A

##  1 Towards quantitative analyses of QCP

The existence and location of the QCD critical point (QCP) in the QCD phase
diagram have been attracting many physists’ interests in heavy ion collision
physics. However recent studies based on effective theories show many possible
location of the QCP in the QCD phase diagram. In addition, the latest finite
temperature and imaginary chemical potential lattice QCD calculation shows
that even the existence of the QCD critical point is uncertain [1]. At present
experiments and quantitative phenomenological analyses for the QCP are needed,
because it seems to be very difficult to reach a solid conclusion about the
QCP just from lattice QCD and effective theories. Here we discuss the
consequences of the QCP from point of view of the quantitative
phenomenological analyses in heavy ion collisions. Towards quantitative
analyses of the QCP we need the following three steps: a realistic dynamical
model which describes expansion of hot and dense matter after collisions, an
equation of state (EoS) with QCP and appropriate physical observables which
show signals of QCP clearly.

For a realistic dynamical model, we use a combined fully three-dimensional
macroscopic / microscopic transport approach employing relativistic
3d-hydrodynamics for the early, dense, deconfined stage of the reaction and a
microscopic non-equilibrium model for the later hadronic stage where the
equilibrium assumptions are not valid anymore [2]. Within this approach we
study the dynamics of hot, bulk QCD matter, which is being created in ultra-
relativistic heavy ion collisions at RHIC. Our approach is capable of self-
consistently calculating the freezeout of the hadronic system, while
accounting for the collective flow on the hadronization hypersurface generated
by the QGP expansion. We succeed in explaining a lot of experimental data
consistently at RHIC: $P_{T}$ spectra of various particles including
multistrangeness particles, rapidity distributions, mean $P_{T}$ as a function
of particle mass, freezeout time distribution of particles, and elliptic flow.
In this calculation, we adopt the EoS with the 1st order phase transition
without QCP which is used in most hydrodynamic models. Now we replace the EoS
in 3d hydro + UrQMD model by an EoS with QCP.

The EoS of QCP which we construct here is composed of two parts: one is a
singular part around QCP and another part is non-singular part which is
described by usual QGP phase and hadron phase [3]. For the singular part of
the EoS, we assume that QCD has the same universality class as 3d Ising model.
First we construct the EoS of 3d Ising model as a function of reduced
temperature ($r$) and external magnetic field ($h$) [4] and map it on the QCD
phase diagram, $\mu_{B}$-$T$ plane. The magnetization as a functions of $r$
and $h$ in 3d Ising model shows different behavior of phase transition between
negative $r$ (1st order) and positive $r$ (crossover). In mapping the EoS with
3d Ising model as a function of $r$ and $h$ on the $\mu_{B}$-$T$ plane,
however, there is no universality between QCD and 3d Ising model. We can not
determine the direction of $h$ axis to $r$ axis, though we can fix $r$ axis as
it is parallel to tangential line at QCP to the phase boundary. Here we choose
the direction of $h$ to be perpendicular to $r$ axis. Besides not only the
size of critical region around the QCD and location of it on the QCD phase
diagram are input parameters in our model. The EoS with the QCP has a very
interesting feature in isentropic trajectories on $\mu_{B}$-$T$ plane: the QCP
works as an attractor of isentropic trajectories on the QCD phase diagram [5,
3], which gives us a clue of finding the QCP.

##  2 Signals of QCP

Next we discuss how to find clear consequences of QCP in heavy ion collisions.
The promising signals of QCP should survive not only in expanding fireball but
also even after the freezeout process. Here we investigate two candidates of
them: fluctuations and hadron ratios. For fluctuation, naively, we have to
pick up fluctuations of conserved values such as charge, baryon number and
strangeness during whole process of collisions. Hadron ratios are fixed at
chemical freezeout temperature and hold the same value during freezeout
process and final state interactions.

Figure 2 shows behavior of static and dynamical fluctuations in 1d
hydrodynamic expansion along isentropic trajectories on the $\mu_{B}$-$T$
plane [3]. In both cases of static and dynamic fluctuations, we can see the
effect of QCP, i.e enhancement of fluctuation around QCP. For static case
fluctuation becomes maximum just at QCP. However for dynamic case maximum
value of fluctuation appears after passing in the vicinity of QCP because of
the critical slowing down and the maximum value itself is not so large as the
static case. There is possibility that fluctuations which are induced by QCP
do not become so large as a signal of QCP, if the expansion of fireball is
fast.

For hadron ratios key issue from the point of view of QCP is that a chemical
freezeout temperature depends on transverse velocity of hadrons. Figure 2
shows that $\bar{p}/p$ ratio has transverse velocity dependence in a
microscopic transport model, UrQMD in which the QCP does not exist. We find
that on isentropic trajectories the freezeout process occurs gradually [6]:
particles with higher transverse velocity are emitted at earlier time of
expansion and those with lower transverse velocity are produced at later time.
This suggests that hadron ratios may change on isentropic trajectory between a
hadronization point on the QCD phase boundary on the $\mu_{B}$-$T$ plane and
chemical freezeout point. The hadron ratio, especially $\bar{p}/p$ ratio as a
function of transverse velocity (momentum) is sensitive to behavior of
isentropic trajectories on $\mu_{B}$-$T$ plane and may show a consequence of
QCP clearly.

Figure 1: Fluctuations as a function of temperature along isentropic
trajectories.

Figure 2: $\bar{p}/p$ ratio as a function of transverse velocity which is
obtained with UrQMD.

Next we do a demonstrative calculation to show how the signal of QCP appears
through $\bar{p}/p$ ratio in heavy ion collisions. Here we focus on SPS energy
region and put the QCP which is parameter in our model and the chemical
freezeout point which is obtained in a statistical model [7] to $(\mu_{B},T)$
= (550, 159) MeV and (406, 105) MeV on the $\mu_{B}$-$T$ plane, respectively.
Figure 4 shows that hydrodynamical trajectories in the QCD phase diagram with
and without the presence of a critical point. Possible trajectories in the
plane in the absence of a critical point are shown as solid line (for a
crossover transition (CO)) or dash-dotted line (for a first-order transition
(FO)); the trajectory in the presence of a critical point is shown as dashed
line (QCP). All trajectories meet at the bulk chemical freezeout point. This
dotted line in which clear focusing effect appears stands for isentropic
trajectory of the QCP. Hadronization occurs between the phase boundary and
chemical freezeout point. And between them we can see clear differences in
three cases. In the case of QCD critical point the ratio of $\bar{p}{p}$
decreases along the line or almost the same. On the other hand, in the case of
1st order phase transition and crossover this value increases along isentropic
trajectory.

Antiproton-to-proton ratio along the trajectories is shown in Fig. 4 as a
function of the entropy density which is proportion to transverse momentum.
The curves start at the phase boundary 160 MeV and continue down to chemical
freezeout temperature (145 MeV). The location of the chemical freezeout point
deduced from experimental data is indicated by the open and solid squares.
Note that the ratio only rises for the trajectory deformed by the critical
point. In actual experimental data this evidence should appear as steeper
$\bar{p}$ spectra at high $P_{T}$.

Figure 3:  Isentropic trajectories with and without QCP on the QCD phase
diagram. Arrows indicate the direction of time evolution.

Figure 4: Antiproton-to-proton ratio along the trajectories as a function of
the entropy density. Arrows indicate the direction of time evolution.

We find interesting experimental data which may suggest a signal of QCP:
$\bar{p}$ spectra obtained by NA49 [8]. They show $\bar{p}$ and $p$ spectra on
collision energies from 20 GeV to 158 GeV. Only at 40 GeV collision energy
slope of $P_{T}$ spectra of $\bar{p}$ seems to be steeper compared to other
collision energies, which would require a trajectory of the type expected in
the vicinity of the QCP (Fig. 4). The size of the statistical errors of the
measurement does not permit a firm conclusion about this anomaly, but it is
certainly compatible with the arguments presented here.

Finally we show an example of realistic calculation by 3d hydro + UrQMD model
with EoS including QCP. For initial conditions of our hybrid model we set
maximum value of energy density and baryon number density to be 2.0 GeV/fm3
and 0.15 fm-3 , respectively, which corresponds to SPS energy region. In the
following calculations we use the same initial conditions for the both cases
of EoS with and without QCP and set a switching temperature from hydrodynamic
model to UrQMD to be 150 MeV. Because of different behavior in isentropic
trajectories between EoS with and without QCP, chemical potential at the
switching temperature is 430 MeV in presence of QCP which is larger than one
in absence of QCP (250 MeV). This difference appears in hadron ratio. Figure 5
shows $P_{T}$ spectra of $\pi$, $K$, $p$ with QCP (left) and without QCP
(right). We can see the effect of different isentrpic trajectoris in hadron
ratios.

In summary, we have shown that the evolution of the $\bar{p}/p$ ratio along
isentropic curves between the phase boundary in the QCD phase diagram and the
chemical freeze-out point is strongly dependent on the presence or absence of
a critical point. When a critical point exists, the isentropic trajectory
approximately corresponding to hydrodynamical expansion is deformed, and the
$\bar{p}/p$ ratio grows during the approach to chemical freeze-out. Depending
on the actual size of the attractive region around the critical point, the
search for an anomaly in the $P_{T}$ dependence of the $\bar{p}/p$ ratio may
require small beam energy steps.

Figure 5: $P_{T}$ spectra for $\pi$ (solid circles), $K$ (solid square) and
$p$ (solid triangle) with QCP (left) and without QCP (right).

## References

  * [1] P. Petreczky, these proceedings, C. Sasaki, these proceedings.
  * [2] C.Nonaka, S.A.Bass, Phys. Rev. C 75 (2007) 014902.
  * [3] C. Nonaka, M. Asakawa, Phys. Rev. C71(2005) 044904.
  * [4] R.Guida and J.Zinn-Justin Nucl. Phys. B486(1997)626.
  * [5] M. A. Stephanov, K. Rajagopal, E. V. Shuryak, Phys. Rev. Lett. 81(1998) 4816.
  * [6] M. Asakawa, S. A. Bass, B. Mul̈ler and C. Nonaka, Phys. Rev. Lett.  101(2008)122302.
  * [7] P. Braun-Munzinger, K. Redlich, and J. Stachel, arXiv: nucl-th/0304013.
  * [8] C. Alt et al. (NA49 Collaboration), Phys. Rev. C73(2006) 044910\.