Large Language Models are Interpretable Learners

## Abstract

Abstract The trade-off between expressiveness and interpretability remains a core challenge when building human-centric predictive models for classification and decision-making. While symbolic rules offer interpretability, they often lack expressiveness, whereas neural networks excel in performance but are known for being black boxes. In this paper, we show a combination of Large Language Models (LLMs) and symbolic programs can bridge this gap. In the proposed LLM-based Symbolic Programs (LSPs), the pretrained LLM with natural language prompts provides a massive set of interpretable modules that can transform raw input into natural language concepts. Symbolic programs then integrate these modules into an interpretable decision rule. To train LSPs, we develop a divide-and-conquer approach to incrementally build the program from scratch, where the learning process of each step is guided by LLMs. To evaluate the effectiveness of LSPs in extracting interpretable and accurate knowledge from data, we introduce IL-Bench, a collection of diverse tasks, including both synthetic and real-world scenarios across different modalities. Empirical results demonstrate LSP’s superior performance compared to traditional neurosymbolic programs and vanilla automatic prompt tuning methods. Moreover, as the knowledge learned by LSP is a combination of natural language descriptions and symbolic rules, it is easily transferable to humans (interpretable), and other LLMs, and generalizes well to out-of-distribution samples.

## 1 Introduction

Learning interpretable predictive models from annotated data remains a key challenge in human-centric AI.
Given input-output pairs $\{(x_{i},y_{i})\}$, the objective is to learn a function $f:x\rightarrow y$ that not only fits the data accurately but is also interpretable.
tIn this context, a strong form of "interpretable" means that individuals with no prior domain knowledge can understand and apply the decision rules demonstrated by $f$, facilitating the transfer of knowledge from AI to humans.
This is crucial not only for enhancing the transparency of AI systems but also for enabling humans to learn from these models, empowering various human-in-the-loop applications such as scientific discovery, material synthesis, and automatic data annotation (Chaudhuri et al., ).

Consider an exemplar task of classifying species in Palworld (Pair, ) - a newly released Pokemon-style game - based on a few image-label pairs, as illustrated in Figure 1.
The ultimate goal is that even humans unfamiliar with Palworld can replicate AI’s decisions by following the same predictive rules after examining the model trained on the data.
This task effectively represents the challenge of extracting interpretable knowledge, such as species characteristics, from data.
The algorithm we propose in this paper learns a model following the decision rule illustrated in Figure 1, which is designed to be easily understood and reproduced by humans. In essence, this problem can be viewed as discovering interpretable knowledge (e.g., the properties of a species in Palworld) from the data.

Despite extensive research, the problem of developing a fully interpretable predictive model has not been fully addressed.
Traditional methods often face a trade-off between expressiveness and interpretability:
Deep neural networks, for instance, are powerful yet operate as "black boxes".
Although post-hoc explanation methods attempt to make these models more transparent by identifying influential features (Ribeiro et al., ), they do not clarify the underlying decision-making processes and have no control over the learning process.
Directly learning interpretable models like (locally) linear, tree-based often falls short in expressiveness, especially with complex inputs like images.

To address this challenge, Neurosymbolic Programs (NSPs) (Chaudhuri et al., ; Shah et al., ; Cui and Zhu, ; Nauta et al., ) offer a promising solution by modeling the decision rule as a program incorporating both symbolic operations and neural network modules.
Despite this, the inherent trade-off between expressiveness and interpretability persists.
While the integration of neural modules enhances expressiveness, it also compromises the program’s overall interpretability.
Additionally, designing effective symbolic operators requires significant expertise and is critical for the performance of the resulting program, necessitating careful customization for each specific dataset (Chaudhuri et al., ; Shah et al., ; Cui and Zhu, ).

Is it possible to harness the power of neural networks within Neurosymbolic Programs without compromising interpretability?
This paper presents an affirmative answer.
Our key insight is that (Multimodal) LLMs encompass a variety of powerful, conditional probabilistic sub-models.
These models share a unified parametric architecture with the unconditional parent LLM (Super Model), yet distinctive defined by their respective prompts.
Therefore, crafting prompts (by either Human or meta-LLMs) for LLM is equivalent to searching over the hypothesis space spanned by these submodels.
This yields an infinite set of neural network-based operations that are inherently interpretable and can serve as fundamental “learnable” building blocks within Neurosymbolic Programs.

Building on this insight, we introduce a novel framework termed LLM-Symbolic Programs (LSPs), defined and learned through LLMs.
Our approach leverages a minimal Domain-Specific Language (DSL) set with only two operators: prompted-LLM and conditional branching, yielding a classic decision-making process structured as trees. We then propose a learning algorithm to incrementally learn the tree using LLMs with prompt optimization.
To thoroughly evaluate the efficacy of LSPs, we construct the Interpretable-Learning-Benchmark of diverse predictive tasks, containing both synthetic and real-world data across vision and text modalities.
Our empirical findings show that LSPs surpass the accuracy of both traditional XAI methods and LLMs prompted with automatically learned instructions, all while maintaining human interpretability.
These results highlight the potential of LSPs to significantly enhance the performance and utility of Multimodal LLMs in various applications.

## 2 LLM-Symbolic Programs

Figure: Figure 1: Illustration of LLM-Symbolic vs. Neuro-Symbolic Program on interpretable learning task. The goal is to develop a model that allows humans with no prior knowledge to replicate AI’s decisions by following the same rules as the model. While NSP (Top right) offers a certain level of interpretability, it heavily relies on manually designing operators, and the inclusion of neural operators often reduces interpretability. In contrast, LSP (Bottom right) generates fully interpretable programs with the help of versatile LLM modules.
Refer to caption: extracted/5689113/Figures/pipeline/apex_inference.png

This section explains our proposed framework: LLM-Symbolic Programs.
Section 2.1 reviews Neurosymbolic Learning method.
Section 2.2 discusses utilizing LLM to implement interpretable programs, including a connection between prompted-LLM and interpretable unit (Section 2.2.1), the Domain Specific Language (Section 2.2.2) and learning algorithm (Section 2.2.3).

### 2.1 Preliminaries on Neurosymbolic Learning

NeuroSymbolic Programmings (NSPs) (Chaudhuri et al., ; Shah et al., ; Cui and Zhu, ; Frosst and Hinton, ) seek to couple classical symbolic methods with contemporary neural networks to build expressive and interpretable models.
The learning method for NSPs is often characterized by (1) a Domain Specific Language (DSL) that specifies available operations of the program and (2) a learning algorithm for finding the best instance.
The resulting programs are structured, neuro-symbolic terms that follow the syntax specified by the DSL.

##### Domain-Specific Language (DSL)

DSL in NSPs comprises manually defined operators, including interpretable symbolic (e.g. if-then-else) and expressive neural components (e.g. cnn(x, $\theta$)).
These operators can be chained to construct various tree-structured programs, a.k.a. computation graphs.
Eq (1) presents an example DSL used to construct the program for predicting the creature species in Figure 1.
Here, $x$ and $c$ represents inputs and constants, and $\alpha$ denotes a sub-program:

$$ $\displaystyle\alpha::=x\mid c\mid\texttt{Add}(\alpha_{1},\alpha_{2})\mid \texttt{Mul}(\alpha_{1},\alpha_{2})\mid\text{If }\alpha_{1}\text{ Then }\alpha _{2}\text{ Else }\alpha_{3}\mid\texttt{cnn}(x,\theta)\mid\texttt{Dist}(\alpha_ {1},\alpha_{2}).$ (1) $$

##### Co-optimization of program structure and learnable parameters

In NSPs, the construction of a program involves solving a combinatorial optimization problem for both the program structure and the parameters of its learnable operators (e.g. neural components). As the number of DSL operators increases, the complexity of this task grows exponentially. To make the search process more tractable, existing research employs various approximation techniques to efficiently identify viable candidates, including greedy tree search (Shah et al., ), continuous relaxation (Cui and Zhu, ), distillation (Frosst and Hinton, ) and meta-learning (Chaudhuri et al., ).

##### Limitations

While the integration of symbolic and neural components in NSPs represents a promising innovation, the incorporating of neural modules inevitably introduces black-box components and makes the program non-interpretable. Researchers have attempted to address this issue through two primary approaches: restricting the DSL to only interpretable operators (Shah et al., ; Cui and Zhu, ), or employing prototype learning to derive relatively interpretable neural modules (Nauta et al., ; Ming et al., ; Nauta et al., ). However, the DSL approach is not automatic, heavily relies on domain expertise, and potentially overlooking crucial information not identified by experts; Conversely, prototype learning aims to represent the concept of each neural module by a set of representative samples, which is not guaranteed to success.

### 2.2 LLM-Symbolic Programs

This section explores how LLMs can effectively be utilized to implement NSPs’ modules that are expressive, interpretable, and straightforward to learn with LLMs.

#### 2.2.1 Prompted-LLM as an interpretable unit

The trade-off between interpretability and expressiveness presents a fundamental limitation in machine learning. Machines perceive images and text as raw binary signals, and transforming these into interpretable concepts inevitably requires complex and non-interpretable components, such as neural networks. Even human perception remains non-interpretable, as we lack a complete understanding of how the brain processes signals.
However, The following analysis suggests that pretrained LLM offer a potential avenue to bridge this gap.

##### Connection between interpretable learning and prompting

LLMs pretrained on the next-token prediction task model the following joint distribution of a sequence of tokens $\{w_{t}\}_{t=1}^{T}$

$$ $\displaystyle P(w_{1},w_{2},\ldots,w_{T})=\prod\nolimits_{t=1}^{T}P(w_{t}\mid w _{t-1},w_{t-2},\dots,1)=f_{\theta}(w_{t}\mid w_{1},w_{2},\ldots,w_{t-1}),$ $$

where the conditional probabilities are parameterized by an auto-regressive model $f(\cdot;\theta)$ (e.g. Transformer) and each word $w_{t}$ is predicted given all the preceding tokens.
The pretraining objective minimizes the following negative log-likelihood:

$$ $\displaystyle\min_{\theta}\mathcal{L}(\theta)=-\sum\nolimits_{t=1}^{T}\log f_{ \theta}(w_{t}\mid w_{t-1},\dots,w_{1}).$ (2) $$

A key observation from Eq. (2) is that the training process optimizes a “SuperNet" of conditional probabilistic models (CPM), each defined by an instruction $s$: $f_{s,\theta}(y|x)=f_{\theta}(y\mid x,s)$, where $x$ is the input and $s$ is the instruction for a particular task. Therefore, with a fixed LLM, the set of natural language prompts, denoted as $\cal{S}$, provides a massive set of interpretable neural network modules for the task.
For a given dataset $\{(x_{i},y_{i})\}_{i=1}^{n}$, finding the best prompt to minimize the empirical loss,
$\min_{s\in{\cal S}}\sum_{i=1}^{n}{\cal L}((f_{s,\theta}(y_{i}\mid x_{i})))$,
can be viewed as a form of learning, and the resulting model is inherently interpretable, as the prompt $s$ is expressed in natural language.

This connection reveals that prompt optimization within the natural language space offers a form of interpretable learning that simultaneously achieves both expressiveness and interpretability. The key to bridging this gap lies in leveraging LLMs to handle the non-interpretable processing of raw signals into high-level concepts, much like how neurons in the human brain transform signals into information. This allows learning to occur within an interpretable space.

##### Limitation of (discrete) prompt optimization

However, existing prompt optimization algorithms are insufficient for interpretable learning for several reasons: firstly most methods focus on “rewriting” prompts to enhance performance (Pryzant et al., ; Hsieh et al., ), which might not help in extracting interpretable knowledge from data. Additionally, while recent developments show some capabilities in correcting prompts using error examples (Pryzant et al., ; Wang et al., ), they still struggle with complex decision rules, such as conditional branching for classification tasks. These rules, often applicable to only a subset of samples, are difficult to recover when considering the whole training set. Our experiments indicate that direct application of current methods fails to effectively address complex decision rules. These challenges motivate the proposed LSP framework that combines prompt optimization with symbolic programs.

#### 2.2.2 Domain-Specific Language of LSPs

Compared with traditional NSPs that require manually designing a comprehensive DSL, LLM’s ability to represent a wide range of functions via different prompting, we can significantly streamline the grammar required to build expressive and interpretable models.
Specifically, for predictive models, we can build powerful LSPs from a minimalist DSL with only three components: the input, conditional branching, and LLM module:in

$$ $\displaystyle\alpha$ $\displaystyle::=x\mid\texttt{switch}(\{\alpha==y_{i}:\alpha_{i}\}_{i=1}^{k}) \mid\texttt{LLM}(x,s).$ (3) $$

Here,
input $x$ represents the input data (text, image, etc);
the conditional branching $\texttt{switch}(\{y_{i}:\alpha_{i}\}_{i=1}^{k})$ forms the backbone of the program structure.
Each switch can be viewed as a node in a decision tree tree with $k$ branches.
It will branch to $\alpha_{i}$
if the sub-program $\alpha$ predicts $y_{i}$.
The LLM Module $\texttt{LLM}(x,s)$ serves as the inference engines. It means to prompting LLM to make a prediction on input $x$ under the instruction $s$.

Figure 1 shows an example LSP generated from above DSL.
Given a test query, we traverse the tree-structured program in a top-down manner, assigning data to specific child node based on the parent node’s predictions, until the leaf node is reached and the final response is returned.

#### 2.2.3 Learning algorithm

Figure: Figure 2: Learning Algorithm for LSPs. The learning algorithm for LSPs contains two parts: (1) program structure search (Left): This process is akin to constructing a traditional decision tree. Starting from the root, the algorithm traverses down the tree, iteratively splitting the training dataset based on the current node’s predictions and expanding the leaf node with the highest prediction errors. (2) LLM module optimization (Right): Here, a learner LLM is instructed to summarize rules based on the observed data at its node.
Refer to caption: x1.png

##### Overview

The tree search framework commonly used in NSPs also applies to LSPs (Chaudhuri et al., ; Shah et al., ).
Moreover, the simplicity of our DSL allows the search process to be further arranged in a highly intuitive manner akin to constructing decision trees.
As illustrated in Figure 2, the process begins at the root node with an empty program and the entire training set. A switch operator combined with an LLM(x, s) module is then added.
This combination essentially directs the program’s flow based on the module’s predictions.
Once the LLM module is trained, we expand its child nodes and repeat the whole process.
This divide-and-conquer strategy benefits the search process by simplifying each LLM module’s task to fitting only a subset of the data.

##### Learning LLM-modules by summarizing predictive rules

In LSPs, each LLM module is responsible for decision-making on its designated data subset.
For traditional NSPs, the neural modules are optimized using empirical risk minimization;
For LSPs, training LLM modules essentially transforms into deriving rules from observed data, as established in Section 2.2.1.
While this can be achieved via generic prompt optimization techniques, we adopt a more direct approach utilizing the LLM’s robust summarization capabilities (Adams et al., ; Goyal et al., ; Zhang et al., ; Pu and Demberg, ), asking the model to summarize rules from observed data patterns.
Note that LLM serves as both the inference engine and the learner, as depicted in Figure 2 (Right).

##### Node selection

Top-down tree search algorithms generally use a node scoring function to determine the next node to expand, ideally prioritizing nodes with the greatest potential for program improvement.
Given that nodes with more frequent errors likely have more room for improvement, we use error count as our scoring function.
This metric, accounting for both the error rate and the size of the data subset each node handles, provides a simple yet empirically effective approach.
Section 6 presents empirical evidence supporting the efficacy and robustness of this metric.

##### Complete algorithm

The above outlines the learning process for expanding a single program.
In the full search pipeline, we further incorporate beam search (Pryzant et al., ) and batch sampling to prevent the search from getting stuck in local minima, as summarized in Algorithm 2 (Appendix).

## 3 IL-Bench Interpretable-Learning Benchmark

The goal for interpretable learning is for the model to acquire knowledge transferable to humans for classification tasks that are NOT zero-shot solvable. A task is zero-shot solvable if the LLM can predict accurately based solely on the class name (e.g. basic dog-cat classification). To evaluate interpretable learning methods, we need classification tasks with classes unseen during LLM pretraining, requiring the model to learn additional knowledge for successful classification.
This is challenging given the extensive pretraining on Internet data.
Therefore, we introduce Interpretable-Learning Bench, a novel benchmark comprising multiple challenging tasks, and even advanced LLMs like GPT need to learn substantial additional knowledge to solve these tasks. This benchmark provides a valuable resource for evaluating future interpretable learning and autoprompting methods. We will explain the construction of IL-Bench next, and leave the detailed summaries to Appendix Table 7.

##### Synthetic Tasks

Prior work in symbolic learning often uses synthetic datasets to evaluate methodologies due to known oracle rules, making it easy to observe model performance. Inspired by this, we develop synthetic datasets with known predictive rules in our benchmark. These datasets employ symbols to represent variables and values, making them context-agnostic and requiring the model to rely on abstract reasoning. Our tasks include decisions generated by decision trees of varying complexity, allowing us to assess model behavior as rule complexity increases.

##### Textual Classification Tasks: from image to text dataset

To evaluate the model’s proficiency in complex scenarios, Fine-Grained Visual Classification (FGVC) tasks (Maji et al., ; Wah et al., ; Kramberger and Potočnik, ; Nilsback and Zisserman, ; Van Horn et al., ) serve as an excellent testbed.
FGVC focuses on distinguishing objects within narrowly defined categories, where the differences between examples from each class are often subtle.
We selected specific image subsets from FGVC databases, covering area of various bird species (Wah et al., ).
For evaluating pure-text LLMs, we convert them to text datasets via captioning.
To ensure the captions cover the intricate differences between objects, we introduce the Concatenated Contrastive Captioning (C3) technique, which generates detailed captions by contrasting a target image with reference images from different classes, merging them into a comprehensive description for text-only LLM evaluation.

##### Visual classification Tasks: distinguishing novel visual concepts

We also collect a new suit of datasets from Palworld, a Pokemon-style game containing various species of creatures (Examples in Table 7).
Since the game is released after most existing LLM’s knowledge cut-off date, the model will need to rely solely on the knowledge extracted from the dataset to perform the prediction.

## 4 Related Work

##### Interpretable machine learning

Although neural networks are immensely expressive, they provide no insights into its internal decision making mechanism.
In the quest of making model predictions interpretable, research has broadly categorized methods into two main types: post-hoc and intrinsic.
Post-hoc methods provide insights into how a pretrained model behaves, usually by highlighting important features used for decision making (Zintgraf et al., ; Petsiuk et al., ; Dabkowski and Gal, ; Shrikumar et al., ; Sundararajan et al., ; Ancona et al., ) or provide counterfactual explanations (Dhurandhar et al., ; Hendricks et al., ; van der Waa et al., ; Goyal et al., ; Hsieh et al., ). Beyond attribution in the feature space, some methods can also be generalized to the space of higher level concepts (Kim et al., ; Bai et al., ). However, all these methods aim to highlight important features while not being able to recover the entire decision making process of neural networks.

On the other hand, intrinsic methods integrate interpretability directly into the model’s architecture, making them naturally interpretable by design.
Traditional Methods include Decision Trees (Chen and Guestrin, ) and Generalized Additive Models (GAMs) (Hastie and Tibshirani, ) offer strong interpretability, yet often not expressive enough. Concept bottleneck model adds a hidden layer in neural network, where neurons represent some predefined concepts to gain interpretability (Koh et al., ; Losch et al., ; Yuksekgonul et al., ; Oikarinen et al., ). While this approach facilitates attribution of concepts, it does not provide a comprehensive decision rule.
Neurosymbolic Programming (NSP) (Chaudhuri et al., ; Shah et al., ; Cui and Zhu, ; Nauta et al., ) represents an innovative blend, combining deep learning’s data handling capabilities with symbolic reasoning to foster both performance and transparency.
Despite early promises, NSP suffers from an inherit trade-off between expressiveness (more NN modules) and interpretability (more symbolic modules).
Moreover, they are often expensive to train due to co-optimization of program architecture and parameters of the NN modules (Shah et al., ; Cui and Zhu, ).

##### Prompt Optimization

The essence of utilizing a generative language model lies in crafting effective prompts.
Recent advancements have aimed to automate this process, reducing the need for human effort through prompt optimization (Shin et al., ; Zhou et al., ).
While pioneering efforts were mainly directed towards various discrete optimization algorithms (Shin et al., ; Deng et al., ; Zhang et al., ), it has been noted that advanced LLMs can revise prompts similarly to human engineers (Zhou et al., ; Pryzant et al., ).
Since these initial efforts, a significant body of research has emerged, exploring various search algorithms including Monte Carlo Sampling (Zhou et al., ), beam search (Pryzant et al., ), evolutionary search (Yang et al., ; Fernando et al., ; Xu et al., ; Guo et al., ; Hsieh et al., ), and tree search (Wang et al., ).
However, existing methods often treat the prompt as a single entity without explicit structure.
From this perspective, prompt optimization methods can be seen as simplified instances of LSPs, where the program consists solely of one LLM module. While this simplification has shown promising results, as task complexity increases, the explicit structuring within LSPs allows them to encode knowledge from data. This provides substantial advantages over conventional prompt optimization methods.

## 5 Experimental Results

We adopt a comprehensive approach to extensively evaluate the effectiveness of LSPs against various baselines under different settings.
Our empirical study is designed to validate the benefits of LSPs over alternative methods by addressing the following research questions:

- •
Q1: How does LSP compare against traditional NSPs in expressiveness and interpretability? We assess this through both quantitative and qualitative evaluations (human studies). (Section 5.2)
- •
Q2: Does LSP generalize better than traditional NSPs under domain shifts? This question is explored in detail in Section 5.2.
- •
Q3: Is the incorporation of explicit structures beneficial to LSPs? We compare the structured LSP with vanilla prompt optimization, which exemplifies a special case of LSP with a single LLM module. (Section 5.3)
- •
Q4: How effective are different LLMs in implementing LSP? We conduct cross-model experiments to evaluate the performance of various LLMs as the computational backbone for learning and inference in LSP. (Section 8.1.1)

### 5.1 General settings

##### Evaluation

For language tasks, we test popular LLMs, including GPT-3.5 (turbo-1104) (Ouyang et al., ), GPT-4 (1106-preview) (Achiam et al., ), and Gemini-M (1.0-pro) (Team et al., ).
For vision tasks, GPT-4V (gpt-4-1106-vision-preview) and Gemini-Vision (1.0-pro-vision) are utilized.
All experiments are repeated with 3 seeds.

##### Implementation details of LSP

Our default model of choice is GPT-3.5 for language tasks and Gemini-Vision for vision tasks, but also examine cross-(M)LLM performance in Appendix.
All LLM modules are initialized with an empty instruction “none”.
More detailed hyperparameters can be found in Appendix, which is kept fixed throughout the experiments.

### 5.2 Comparison with traditional interpretable learning methods

**Table 1: Classification accuracy comparison with XAI methods on IL-Bench-Vision. Here, all numbers for LSP are obtained with Gemini-Vision as the learner and inference LLM, except for LSP (GPT-4V) which uses the larger GPT-4V as the learner; Decision Tree, operating directly on pixel data, lacks human interpretability. Key findings include: (1) Our method outperforms XAI baselines with an average accuracy of 95.67%, which is over 10% higher than the nearest competitor. (2) The program generated by LSP also demonstrates superior transferability to human raters, as they are able to reproduce the predictions following rules learned by LSP.**
| IL-Bench-Vision |  | Palworld |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| MLLM | Method | Mean | Fire-1 | Fire-2 | Dragon-1 | Dragon-2 | Electric-1 | Electric-2 | Water-1 |
| Gemini-M | Decision Tree (Chen and Guestrin, ) | 68.20 | 91.11 $\pm$ 12.57 | 32.00 $\pm$ 9.80 | 68.33 $\pm$ 10.27 | 48.33 $\pm$ 20.95 | 82.67 $\pm$ 6.80 | 65.33 $\pm$ 13.60 | 66.67 $\pm$ 8.50 |
| ProtoTree (Nauta et al., ) | 84.33 | 100.00 $\pm$ 0.00 | 62.67 $\pm$ 12.36 | 98.33 $\pm$ 2.36 | 85.00 $\pm$ 4.08 | 100.00 $\pm$ 0.00 | 82.67 $\pm$ 9.98 | 61.67 $\pm$ 25.93 |  |
| LSP | 84.76 | 93.33 $\pm$ 6.67 | 76.00 $\pm$ 4.00 | 85.00 $\pm$ 0.00 | 97.50 $\pm$ 2.50 | 86.00 $\pm$ 10.00 | 68.00 $\pm$ 4.00 | 87.50 $\pm$ 2.50 |  |
| LSP (GPT-4V) | 95.67 | 96.67 $\pm$ 3.33 | 90.00 $\pm$ 6.00 | 90.00 $\pm$ 10.00 | 97.50 $\pm$ 2.50 | 100.00 $\pm$ 0.00 | 98.00 $\pm$ 2.00 | 97.50 $\pm$ 2.50 |  |
| Human Rater | ProtoTree (Nauta et al., ) | 72.74 | 83.33 $\pm$ 16.67 | 50.0 $\pm$ 10.0 | 100.0 $\pm$ 0.0 | 75.0 $\pm$ 0.0 | 83.33 $\pm$ 16.67 | 80.0 $\pm$ 0.0 | 37.5 $\pm$ 12.5 |
| LSP (GPT-4V) | 90.36 | 100.00 $\pm$ 0.00 | 70.00 $\pm$ 10.00 | 100.00 $\pm$ 0.00 | 87.5 $\pm$ 12.5 | 100.00 $\pm$ 0.00 | 100.00 $\pm$ 0.00 | 75.00 $\pm$ 25.00 |  |

Figure: Figure 3: Accuracy retention rate on Out-Of-Distribution variants of IL-Bench-Vision testsets. We compute the ratio of test accuracy evaluated on OOD datasets to the original test accuracy. LSP shows strong transferability to OOD data. Notably, the version using GPT-4V as the learner retains 90-100% of the original test accuracy.
Refer to caption: x2.png

We compare LSP with two established models - ProtoTree (Nauta et al., ) and Decision Tree (Chen and Guestrin, ) - both organize prediction process in tree-structured formats.
Among existing NSP methods, the closest to ours is ProtoTree - a highly interpretable NSP that learns a discrete binary tree end-to-end, where each node stores an image patch ("prototype") and the edges determine whether the prototype exists within the query image.
Note that ProtoTree does not rely on an explicit DSL - we could not compare with methods based on explicit DSL since they require domain experts to design those operation, while our goal is to automate the whole process.
Since ProtoTree only implements image tasks, this comparison also focus on the vision tasks in IL-Bench.

##### Expressiveness

The expressiveness of the learned programs is evaluated in Table 1.
LSP (GPT4V) outperforms ProtoTree with an average accuracy of 95.67%, which is over 10% gain.
Considering that GPT/Gemini has never observed the images in our datasets before (curated after their knowledge cutoff), this result suggests LSP is capable of formulating effective predictive rules from previously unseen examples.

##### Interpretability

We measure the interpretability of LSPs and NSPs by having human raters make predictions based on visualizations of the learned programs (See Appendix for evaluation protocols).
This process essentially "transfers" knowledge from models back to human.
Notably, many XAI methods fall short of achieving this level of interpretability, with ProtoTree being a rare exception.
As summarized in Table 1, the program generated by LSP also demonstrates stronger transferability to human raters, as they are able to largely reproduce the predictions following rules learned by LSP.

##### Generalization under Domain Shift

In contrast to traditional NSP models that rely on parametric memory, LSP utilizes language instructions to encode knowledge.
This strategy significantly enhances robustness against variations in visual attributes (domain shifts).
To verify this advantage, we examine the transferability of the learned programs to Out-of-Distribution (OOD) data, constructed using GPT-4V (See Appendix for details)
As shown in Figure 3, LSP demonstrates exceptional resilience to domain shifts, compared with ProtoTree.

### 5.3 Comparison with prompt optimization

**Table 2: Classification accuracy comparison with Prompt Optimization methods on IL-Bench-Language. Key findings include: (1) LSP achieves $\sim 5\%$ accuracy gain over PromptAgent, the previous state-of-the-art. (2) Across synthetic Decision Tree datasets categorized by increasing complexity of oracle decision rules (Easy, Medium, Hard), LSP consistently outperforms other methods in maintaining high accuracy levels, demonstrating its superior ability to reverse-engineer complex rules from observed data.**
| Text Benchmark |  | Synthetic | Caption |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| LLM | Method | Mean | DT-Easy | DT-Medium | DT-Hard | Waxwing | Waterthrush | Jaeger | Albatross | Blackbird | Swallow |
| GPT-3.5 | APE (Zhou et al., ) | 67.62 | 99.67 $\pm$ 0.47 | 86.67 $\pm$ 12.47 | 87.00 $\pm$ 8.57 | 46.11 $\pm$ 4.37 | 43.89 $\pm$ 3.14 | 65.56 $\pm$ 2.83 | 47.41 $\pm$ 2.28 | 78.06 $\pm$ 1.04 | 54.17 $\pm$ 1.18 |
| OPRO (Yang et al., ) | 55.48 | 50.00 $\pm$ 1.08 | 50.17 $\pm$ 3.06 | 30.33 $\pm$ 2.62 | 57.22 $\pm$ 2.08 | 57.22 $\pm$ 4.16 | 76.67 $\pm$ 4.71 | 40.37 $\pm$ 3.43 | 78.06 $\pm$ 2.83 | 55.28 $\pm$ 1.04 |  |
| APO (Pryzant et al., ) | 70.67 | 100.00 $\pm$ 0.00 | 96.67 $\pm$ 4.71 | 77.83 $\pm$ 11.90 | 56.11 $\pm$ 4.78 | 48.89 $\pm$ 4.16 | 70.00 $\pm$ 5.93 | 54.07 $\pm$ 9.70 | 74.17 $\pm$ 2.97 | 58.33 $\pm$ 1.36 |  |
| PromptAgent (Wang et al., ) | 72.40 | 97.67 $\pm$ 3.30 | 88.50 $\pm$ 8.44 | 64.33 $\pm$ 20.27 | 60.56 $\pm$ 4.78 | 56.67 $\pm$ 6.24 | 75.00 $\pm$ 3.60 | 74.44 $\pm$ 6.54 | 74.17 $\pm$ 1.36 | 57.22 $\pm$ 0.79 |  |
| LSP (Ours) | 77.29 | 99.25 $\pm$ 0.75 | 98.50 $\pm$ 0.00 | 89.75 $\pm$ 1.25 | 65.83 $\pm$ 4.17 | 62.50 $\pm$ 0.83 | 80.00 $\pm$ 1.67 | 61.11 $\pm$ 1.11 | 78.75 $\pm$ 0.42 | 62.92 $\pm$ 0.42 |  |

**Table 3: Classification accuracy comparison with Prompt Optimization methods on IL-Bench-Vision. LSP achieves an average accuracy of 84.47%, which is $\sim 20\%$ higher than the 2nd best method (APE).**
| Vision Benchmark |  | Palworld |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| MLLM | Method | Mean | Fire-1 | Fire-2 | Dragon-1 | Dragon-2 | Electric-1 | Electric-2 | Water-1 |
| Gemini-M | APE (Zhou et al., ) | 64.38 | 76.67 $\pm$ 3.33 | 56.00 $\pm$ 0.00 | 59.17 $\pm$ 5.83 | 35.00 $\pm$ 5.00 | 57.33 $\pm$ 10.67 | 82.00 $\pm$ 2.00 | 82.50 $\pm$ 12.50 |
| OPRO (Yang et al., ) | 49.26 | 86.67 $\pm$ 0.00 | 32.00 $\pm$ 4.00 | 56.67 $\pm$ 3.33 | 50.00 $\pm$ 5.00 | 48.00 $\pm$ 28.00 | 49.00 $\pm$ 19.00 | 27.50 $\pm$ 2.50 |  |
| APO (Pryzant et al., ) | 58.45 | 76.67 $\pm$ 23.33 | 42.00 $\pm$ 14.00 | 59.17 $\pm$ 5.83 | 70.00 $\pm$ 5.00 | 39.33 $\pm$ 7.33 | 67.50 $\pm$ 12.50 | 52.50 $\pm$ 17.50 |  |
| PromptAgent (Wang et al., ) | 54.74 | 66.67 $\pm$ 6.67 | 44.00 $\pm$ 0.00 | 49.17 $\pm$ 15.83 | 52.50 $\pm$ 2.50 | 55.33 $\pm$ 8.67 | 42.50 $\pm$ 2.50 | 70.00 $\pm$ 0.00 |  |
| LSP (Ours) | 84.47 | 93.33 $\pm$ 6.67 | 76.00 $\pm$ 4.00 | 85.00 $\pm$ 0.00 | 97.50 $\pm$ 2.50 | 86.00 $\pm$ 10.00 | 68.00 $\pm$ 4.00 | 87.50 $\pm$ 2.50 |  |

Since there exists a variety of PO method that primarily differ in the search algorithm, we select one most representative method from each major category: Monte Carlo sampling (APE) (Zhou et al., ), evolutionary search (ORPO) (Yang et al., ), beam search (APO) (Pryzant et al., ), and tree search (PromptAgent) (Wang et al., ).
Since the main bottleneck for PO methods is the candidate evaluation, we follow existing works and set the same maximum number of candidate proposals for all methods (100 candidates).

##### Results

The empirical results indicate that incorporating explicit structures significantly enhances performance of the programs on predictive tasks:
LSP consistently outperforms all vanilla prompt optimization methods, with a considerable margin of $20.09\%$ and $4.89\%$ over the 2nd best methods on vision and language tasks respectively.
The advantages of integrating structured learning are twofold:
(1) It simplifies the learning process: LSP benefits from a divide-and-conquer approach where each LLM-module node focuses solely on extracting predictive rules for a specific subset of the data.
(2) It streamlines the inference process: We observe that LLMs tend to exhibit hallucination as the complexity of the instructions increases (e.g., multiple conditional clauses.
In contrast, LSP mitigates this issue by ensuring that each LLM module contains simpler, more manageable instructions.

Figure: (a) Language Tasks
Refer to caption: x3.png

## 6 Ablation Study

##### Convergence of LLM-Symbolic Program LSP

Figure: (a) CUB-Waxwing
Refer to caption: x7.png

**Table 4: Search and inference runtime Ccmparison. Despite the multi-step decision-making process of LSP’s tree structure, our method incurs comparable search and inference costs to various prompt optimization baselines.**
| Method | Search (s) | Inference (s) |
| --- | --- | --- |
| APE | 270.60 | 0.11 |
| OPRO | 257.86 | 0.14 |
| APO | 270.85 | 0.08 |
| PromptAgent | 220.95 | 0.11 |
| LSP | 232.54 | 0.13 |

LSP organizes instructions into a tree-based structure.
Such divide-and-conquer strategy simplifies the learning process.
To verify this, we also plot the training trajectories for LSP across various tasks.
The training trajectory indicates the how fast a model fits the observed examples.
As Figure 5 demonstrates, LSP not only converges faster but also achieves higher final accuracy compared to models that use unstructured prompting techniques.

**Table 5: Comparison of Different Node Scoring Functions on three tasks from IL-Bench-Language. Despite its simplicity, error count achieves more consistent performance compared to alternative metrics.**
| Node Scoring | DT-Hard | Waxwing | Waterthrush |
| --- | --- | --- | --- |
| Random | 70.50 $\pm$ 11.01 | 62.22 $\pm$ 4.78 | 61.67 $\pm$ 1.36 |
| Accuracy | 80.33 $\pm$ 18.27 | 66.11 $\pm$ 7.86 | 54.44 $\pm$ 0.70 |
| Error Count (LSP) | 89.75 $\pm$ 1.25 | 65.83 $\pm$ 4.17 | 62.50 $\pm$ 0.83 |

##### Search cost analysis

We also report the actual runtime of search and inference process for different methods in Table 4.
We found that LSP incurs comparable search and inference costs to various prompt optimization baselines.

##### Different node scoring functions

Table 5 summarizes the performance of LSP using three different node scoring functions:
(1). Error count.
(2). Prediction accuracy.
(3). Random scoring.
The results suggest that Error count achieves substantially better and more consistent outcomes across different tasks.

##### Complexity of Learned LSP

Our analysis of the statistics of learned programs indicates that the complexity of programs developed by LSP is quite manageable:
Most programs can reach a final prediction within just three steps, as illustrated in Figure 4(c), and the tree structures tend to be sparse, as shown in Figure 4(d).
These observations confirm that although theoretical maximum tree expansion could grow exponentially with depth, in practice, LSPs operate effectively without requiring overly complex structures.
This further explain why LSP exhibits the reasonable search and inference costs documented in Table 4.

## 7 Conclusion

This work aims at revitalizing the concept of Neuro-Symbolic Programming in the era of Large Language Models.
We demonstrate that pretrained LLMs can implement powerful symbolic programs that are expressive, interpretable, and easy to train.
Additionally, we introduce the Instruction Learning Benchmark (IL-Benchmark), which consists of a suite of vision and language datasets designed to evaluate instruction learning algorithms.
We hope that our proposed framework will inspire new developments in interpretable learning methods during the LLM era.
We regard our study as an initial step in the research on LLM-Symbolic Programs.
Accordingly, we acknowledge the limitations of the current method in Appendix Section 8.4.

## 8 Supplemental Material

### 8.1 Additional ablation experiments

#### 8.1.1 Using different LLMs to implement LSPs

The role of LLMs in LSPs is twofold: they serve both as the inference and learning engine of the LLM-modules in the grammar.
The learning engine is responsible for summarizing and organizing patterns from observed data samples into clear predictive rules, whereas the inference engine follows the learned program to make predictions on test examples.
Natural questions arise: (1). how effective are different LLMs at optimizing LSPs? (2). Is the learned programs interpretable to different LLMs?

##### LLM as LSP learner

We replace the learning engine used in optimizing LSP with various LLMs - GPT-3.5, Gemini, and GPT-4 - while keeping all other settings consistent with the main experiment.
As shown in Figure 4, GPT-4 consistently outperforms other LLMs on both text and vision tasks, while Gemini and GPT-3.5 show similar performance with each other.
This reflects their respective capabilities.
For specific examples of instructions generated by different LLM optimizers, please see the Appendix.

##### LLM as LSP interpreter

**Table 6: Transferring LSPs learned from one LLM to another. The learned LSPs are generally interpretable across various LLMs. However, larger LLMs (e.g., GPT-4) demonstrate a slightly higher consistency in understanding LSPs learned by other LLMs.**
| Source Model | Task | Evaluator |  |  |  |
| --- | --- | --- | --- | --- | --- |
| GPT3.5 | Gemini-M | GPT4 |  |  |  |
| GPT3.5 | DT-Hard | 89.75 $\pm$ 1.25 | 72.67 $\pm$ 6.91 | 87.50 $\pm$ 1.22 |  |
| Waxwing | 65.83 $\pm$ 4.17 | 52.22 $\pm$ 1.57 | 56.67 $\pm$ 3.60 |  |  |
| Waterthrush | 62.50 $\pm$ 0.83 | 64.44 $\pm$ 0.79 | 59.44 $\pm$ 3.93 |  |  |
| Gemini-M | DT-Hard | 75.50 $\pm$ 2.04 | 80.83 $\pm$ 1.03 | 79.17 $\pm$ 11.45 |  |
| Waxwing | 52.78 $\pm$ 3.42 | 58.33 $\pm$ 4.91 | 61.11 $\pm$ 10.57 |  |  |
| Waterthrush | 50.56 $\pm$ 4.16 | 54.44 $\pm$ 5.50 | 52.22 $\pm$ 0.79 |  |  |
| GPT4 | DT-Hard | 74.50 $\pm$ 9.35 | 57.67 $\pm$ 3.01 | 99.50 $\pm$ 0.00 |  |
| Waxwing | 59.44 $\pm$ 5.15 | 62.22 $\pm$ 7.49 | 63.33 $\pm$ 4.91 |  |  |
| Waterthrush | 66.67 $\pm$ 6.80 | 68.33 $\pm$ 2.72 | 62.78 $\pm$ 9.06 |  |  |

We then test if LSPs created by one LLM could be interpreted by other LLMs.
Table 6 summarizes the performance.
The results suggest that LSPs are interpretable across a diverse range of inference models;
Larger and stronger LLMs (e.g. GPT-4) demonstrates a slight more consistent ability in interpreting LSPs, which aligns their superior instruction-following capacities.

### 8.2 Learning algorithm for LSP

The complete pipeline for constructing LSP is summarized in Algorithm 1 and Algorithm 2.

##### Remarks

- •
Although initially, the complexity of the program expansion might seem exponential to the tree depth, a closer examination reveals otherwise: (1). In practice, the trees are typically sparse, meaning that expanding only a few branches is often sufficient to achieve good performance (Figure 4(d)). (2). The divide-and-conquer approach ensures that each tree level processes the same amount of data making the evaluation complexity linear to tree depth.
- •
The above arrangement of the search process does not compromise generality of LSP: For more sophisticated DSL designs, program structure search can be conducted similarly to traditional NSPs, using top-down tree traversal (cite).

Figure: Algorithm 1 learn_llm_module: Learning LLM Module by summarizing predictive rules

Figure: Algorithm 2 Complete pipeline of optimizing LSPs

**Table 7: Overview of Interpretable-Learning Benchmark. We provide task names, types, summaries, number of labels, and one example data point for each task.**
| Task | Type | Summary | Labels | Example |
| --- | --- | --- | --- | --- |
| DT-Easy | Synthetic | Predict labels based on symbolic inputs. Rules generated by a small decision tree | 2 | "input": "x1=A2; x2=B1", "output": "bar" |
| DT-Medium | Synthetic | Predict labels based on symbolic inputs. Rules generated by a medium decision tree | 2 | "input": "x1=A3; x2=B2", "output": "bar" |
| DT-Hard | Synthetic | Predict labels based on symbolic inputs. Rules generated by a large decision tree | 4 | "input": "x1=A1; x2=B1; x3=C1", "output": "foo" |
| Waxwing | Caption | Classify Waxwing species based on its text description. | 2 | "input": "Tan to light brown head and upper body, black m̈askäcross eyes, lighter cream underparts, bright red tips on secondary wing feathers, small black bill, yellow band on tail.", "output": "Cedar Waxwing" |
| Waterthrush | Caption | Classify Waterthrush species based on its text description. | 2 | "input": "Light gray crown, white supercilium, dark eyestripe extending behind eye, olive-brown wings with faint wingbars, white throat, pale underparts, long, slender bill, relatively short tail, orange legs.", "output": "Louisiana Waterthrush" |
| Jaeger | Caption | Classify Jaeger species based on its text description. | 2 | "input": "Light greyish-brown plumage on the underside, distinct narrow white band across the nape, wings with a M-shaped pattern when spread, tail slightly forked but mostly straight across.", "output": "Long tailed Jaeger" |
| Albatross | Caption | Classify Albatross species based on its text description. | 3 | "input": "Dark brown upperparts and paler brown underparts, elongated and narrow wings with a white trailing edge and distinct finger-like tips, hooked beak with a pale base, light-colored head with a dark eye patch and bill, wings held straight in gliding flight, gliding above water surface. Uniform dark brown plumage, long slender wings, distinct white pattern on underwings, white band near the tips of the underwings, pale or white head, dark eye patch.", "output": "Black footed Albatross" |
| Blackbird | Caption | Classify Blackbird species based on its text description. | 4 | "input": "Bright yellow head, black body, sharp conical beak, perched on reed-like vegetation. Bright yellow head, yellow chest, solid black body excluding head and chest, perched on a thin branch. Black body, bright yellow head, sturdy bill, perched on a reed.", "output": "Yellow headed Blackbird" |
| Swallow | Caption | Classify Swallow species based on its text description. | 4 | "input": "Light brown head, pale throat, light brown upperparts, long pointed wings, short tail, white underparts, sitting on wire. Light brown head and upper body, white underparts, sitting on a wire, sky background, short beak, sleek body shape. Brown and white plumage, perched on a wire, stout body, short and thick neck, medium-length tail with a straight edge, compact size, unmarked lighter underparts, darker wings and upperparts.", "output": "Bank Swallow" |
| Fire-1 | Vision | Distinguish visually-similar fire-type pals from Palworld. | 3 | "input":    ,    "output:" "Arsox" |
| Fire-2 | Vision | Distinguish visually-similar fire-type pals from Palworld. | 5 | "input":    ,    "output:" "Pyrin" |
| Dragon-Blue-1 | Vision | Distinguish visually-similar blue-colored dragon-type pals from Palworld. | 3 | "input":    ,    "output:" "Elphidran Aqua" |
| Dragon-Blue-2 | Vision | Distinguish visually-similar blue-colored dragon-type pals from Palworld. | 4 | "input":    ,    "output:" "Jetragon" |
| Electric-1 | Vision | Distinguish visually-similar electric-type pals from Palworld. | 3 | "input":    ,    "output:" "Grizzbolt" |
| Electric-2 | Vision | Distinguish visually-similar electric-type pals from Palworld. | 4 | "input":    ,    "output:" "Univolt" |
| Water-1 | Vision | Distinguish visually-similar water-type pals from Palworld. | 4 | "input":    ,    "output:" "Celaray" |

### 8.3 More details on empirical evaluation

Here we provide more details on the empirical evaluation.

#### 8.3.1 Implementation details

Throughout our main experiment, we use an expansion ratio of 4, batch size of 64, a maximum number of four iterations, and a maximum of 8 candidate (LLM module) proposals for each iteration.
The settings for beam search follows that of APO, which uses a beam size of 4 and deploys UCBBandits algorithm with a sample size of 32 to speedup the candidate ranking Pryzant et al. [].
The only exception is that for vision tasks, we use a batch size of 4 for cost reduction.
The temperature for all API models are set to their default (0.7).

For all prompt optimization baselines, we set the maximum budget (measured by the number of candidate proposals) to the same number.
For Decision Tree, we use XGBoost library’s standard implementation, which operates on raw pixels.
For ProtoTree, we directly run the original implementation, but reduce the maximum depth from 9 to 5, as it is faster to train yet achieves better performance on our datasets.
We align the evaluation our baselines

#### 8.3.2 Constructing Out-Of-Distribution dataset for IL-Bench-Vision tasks

Figure: (a) Beakon Original
Refer to caption: extracted/5689113/Figures/appendix/palworld/Beakon_frame_1470.png

Our OOD dataset is constructed by feeding the original image from the training set to GPT-4 (web version), and ask GPT to generate a variant of the input image.
The prompt we used is shown below.
Figure 6 shows a comparison of some example OOD images generated by GPT-4 with original image.

> Generate an image variant containing the creature in the provided image. keep the key features of this creature unmodified. You must show the full body view of this creature.

#### 8.3.3 Human Evaluation Protocol

We conduct user study to access the interpretability of our method and ProtoTree.
For both methods, we send (1) the original image datasets and (2) visualizations of the discovered programs to the human raters, and as the human rater to make predictions based on those programs.
We then compute the accuracy of their predictions, and report the mean and standard deviations.
We select the group of human raters so that they have no background in machine learning research.

Figure: (a) Celaray
Refer to caption: extracted/5689113/Figures/appendix/palworld/Celaray_frame_0445.png

### 8.4 Limitations

We acknowledge the following limitations, which merit further exploration in future studies.
It is important to note that these limitations pertain to the specific, simplified instantiation of the algorithms used in this preliminary study, rather than to the LSP framework itself:

- •
Domain-Specific Language Design: A common practice in NSp is to design DSLs suitable for specific tasks. This work presents only a basic example of a DSL designed for predictive tasks. Investigating a variety of DSL designs could enable LSPs to excel across a broader range of applications.
- •
Program Complexity: Our search algorithm prioritizes accuracy without considering the complexity of the resulting programs, potentially leading to redundancies. The complexity of the learned programs could be reduced either through post-processing (akin to code cleaning) or by integrating complexity regularization during the search process.

### 8.5 Societal Impact

The development and deployment of interpretable predictive models using Large Language Models (LLMs) have significant societal implications.
By enhancing the transparency and interpretability of AI systems, our approach addresses critical concerns related to trust, accountability, and fairness of the decision making process.
These improvements are particularly valuable in high-stakes domains such as healthcare, finance, and legal decision-making, where understanding the rationale behind AI decisions is crucial for gaining user trust and ensuring ethical outcomes.

However, as with any AI technology, careful consideration must be given to the potential risks of misuse or unintended consequences. It is essential to continue developing comprehensive guidelines and regulatory frameworks to ensure that the deployment of these models aligns with societal values and ethical standards. By promoting transparency and interpretability, our approach paves the way for more responsible and beneficial integration of AI into society.

### 8.6 License

The open-source code from GitHub used in this paper adheres to various licenses like MIT, Apache 2.0, and GPL, ensuring the code’s free use, modification, and distribution under specific conditions.
The ChatGPT API from OpenAI and the Gemini API from Google are used in compliance with their respective terms of service, which include usage restrictions, attribution requirements, and provisions for commercial use.
By following these licenses and terms, we maintain ethical and legal standards in utilizing both open-source code and proprietary APIs in our research.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Some questions are in the Weaknesses section.
Other questions :
+ Could the following claim could be discussed : the resulting model is inherently interpretable as the prompt s is expressed in natural language ? 
+ How this idea of using LLMs to transforms signals into high-level concepts, how the approach compared to concept induction approach ? To  Concept-based Explanations for LLMs ? 
+ In the following approach, is the decision making process limited to conditional branching and tree-based models ? Is it a strong limitation ? 
+ Can hallucinations can occur for RuleSum ?
soundness: 3
strengths: The main strengths of the paper are :
+ **Clarity** : the paper is well written with a clear and well motivated idea. The paper provides nice illustration that enable a clear understanding of the proposed approach. The addressed research question are also very clear.  Moreover, a thorough description of the proposed framework, including ablation studies and code for reproducibility is provided.
+ **Originality** : the main originality of the paper is to use prompting and the ability of summarization of LLMs, a method named RuleSum, to obtain concrete rules and to prevent from manually designing operators, one of the bottleneck of NSPs. It is a simple approach but opening the way for LLM-based symbolic programs. The IL-bench is also an interesting contribution of the paper.
+ **Quality** : The paper is of sufficient quality for the ICLR conference standard.
+ **Significance** : the paper propose a new approach for interpretable learning, i.e. interpretable and comprehensible decision making process which an important area for XAI and trust in AI.
summary: The paper proposes a new framwork, named LSP, for LLM-Symbolic Program combining LLMs with Neurosymbolic programs (NSPs). The main idea of the paper is to consider a prompted LLM as an interpretable unit, enabling the use of NSPs with a minimal domain specific language and thus narrowing this important bottleneck of NSPs. The approach is demonstrated on a proposed Interpretable-Learning benchmark. It includes a comparison with SOTA NSPs as well as some ablation study on the components of the approach. It also include an human evaluation protocol to access the interpretability of the approach.
weaknesses: While the core idea is interesting, the paper has several limitations:
+ a first small concerns is about the title of the paper which is for me not really aligned on the content. The authors use LLMs as learnable building blocks for NSPs but are not interpretable as their own. The title of the paper should be slightly changed to better reflect the true claims of the paper.
+ **lack of clear definition of the notion of interpretability and of the underlying assumptions** : as the authors tackle the trade-off between expressiveness and interpretability, a clear definition of them should be given. For instance for me, using a minimalist DSL means less expressivity since there are only two operators. The assumption that relying on natural language brings interpretability should also be discussed. The interpretability seems to be linked to the interpretability of the prompts.
+ a better positioning to recent approach on XAI, in particular concept-based XAI, mentioned in appendix A.1 and Mechanistic Interpretability.
+ **Generality of the findings**  : the IL-Bench should be more motivated. It is not clear for me what a symbolic task is exactly. Moreover, a large part of the task are classification tasks. What about other tasks regarding the proposed approach ?
+ What is $Dist$ in equation 1 ?

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Referring to W1, the author may run an additional evaluation of the proposed method with specific open-source LLMs (e.g. LlaMA3.1-8B, LlaMA3.2) that can be run locally. No matter the results, the authors could discuss some potential limitations to making LSP work with locally deployed LLMs.

The authors claim that the existing LLM benchmark could measure (M)LLM’s IL ability: "all these tasks are all zero-shot solvable, allowing LLMs to make predictions without additional rule learning. Therefore, these benchmarks are unsuitable for evaluating IL tasks."
My other questions are:

1. Are datasets from AIPS or/and AlphaGeometry, which contains IMO level mathematical problems, able to be IL benchmark? 
The authors may discuss the difference between the proposed dataset and the datasets like AIPS or AlphaGeometry in terms of measuring interpretable learning ability.

FYI, AIPS aims to address inequality math problems, and AlphaGeometry aims to address geometrical math problems. Both papers propose a dataset and a problem-solving algorithm. From my point of view, the algorithm is a neural-symbolic method and is similar to LSP, which uses LLM as a module to generate a one-step decision, add a construct for geometry problems, and transform an inequality. Then, designing a high-level search problem to solve the complex problem.

2. Instead of constructing LSP, does SFT or some RL could be applied to LLM to improve the LLM's IL ability?
soundness: 3
strengths: 1. A new benchmark for interpretable learning tasks, for both vision and text scenarios.
2. Design a LLM-symbolic program generation algorithm (called LSP by authors) by a program structure search procedure.
3. Evaluation shows that the LSP significantly outperforms the baselines in the authors' evaluation settings.
summary: The authors in this paper introduce LLM-based Symbolic Programs (LSPs), combining Large Language Models with symbolic programming to create predictive models that balance expressiveness and interpretability. LSPs use LLMs to generate interpretable modules from raw data. With a step-by-step program generation algorithm, the proposed method could generate the symbolic programs. Besides, the authors propose a new benchmark, called IL-Bench, for evaluating interpretable learning tasks. In their evaluation, LSPs outperform traditional methods, offering interpretable, transferable, and generalizable results.
weaknesses: 1. As the authors say, LLM's responsibility is to make decisions in each LLM module in their llm-symbolic programs. Thus, generating a correct LSP relies on the LLM's ability. I am curious whether the proposed method could correspond with other open-source LLMs that could be deployed locally.

---

confidence: 2
contribution: 3
initial_rating: 8
presentation: 2
questions: I was not fully following the reasoning in line 268 -- 286.
Could you elaborate the following two arguments?
> Therefore, with a fixed LLM, the set of natural language prompts, ... provides a massive set of interpretable neural network modules for the task.

Why the prompts can be trivially seen as interpretable neural modules?

> ... the resulting model is inherently interpretable, as the prompt s is expressed in natural language.

Why the resulting model can be seen inherently interpretable?
soundness: 3
strengths: The approach to integrating LLMs into DSL-based neuro-symbolic programming approaches is interesting, although the idea itself may be straightforward. 
By combining Large Language Models (LLMs) with symbolic programs, the authors effectively leverage the strengths of both methods: LLMs for creating interpretable natural language concepts and symbolic programs for incorporating these into decision rules. This hybrid approach not only enhances model interpretability without sacrificing performance but also makes the knowledge easily transferable to humans and adaptable for other LLMs.
Limitations are discussed in an explicit section.
In experiments, the proposed approach outperformed established baselines in multiple aspects, e.g., on OOD examples, expressiveness, and interpretability (transferability).
summary: This paper tackles the challenge of balancing expressiveness and interpretability in predictive models for classification and decision-making. The authors propose LLM-based Symbolic Programs (LSPs) that combine Large Language Models with symbolic programs to bridge this gap. LLMs generate interpretable modules that transform raw inputs into natural language concepts, which are then integrated into decision rules by symbolic programs.
Moreover, the paper proposes IL-Bench, a new benchmark for the interpretable learning capabilities of LLMs. In experiments, it is demonstrated that LSPs outperform traditional neurosymbolic programs and prompt tuning methods on the proposed benchmark.
weaknesses: I found the manuscript somewhat challenging to follow due to the absence of consistent examples within the main text. Currently, major examples are relegated to the supplementary materials. To enhance clarity, I recommend incorporating one or two examples directly into the main manuscript and referencing them throughout.

Moreover, a clear problem statement would significantly improve comprehension. Specifically, outlining the input and output parameters before discussing the methodology would be beneficial.

Apart from these presentation issues, the experiments appear to demonstrate the efficacy of the proposed approach. However, as I feel I lack sufficient expertise in the baselines, I will defer to other reviewers for a critical assessment of the significance of these results.

Minor Points:

The structure of the document feels somewhat convoluted. There is an overuse of emphasized text formats (bold, italic, etc.), particularly noticeable on Page 3, which detracts from the core ideas being presented. I recommend retaining emphasis only on the most critical sections and reducing the use of bold and italic text.

Equation 3 could be better explained with a figure that includes a concrete example and details like $\alpha$ and $y_i$.

The text size in Figure 8 (f) makes it difficult to interpret. Consider increasing the text size for better readability.

Furthermore, the code is not submitted, making it challenging to assess reproducibility.

Meta-review: The paper presents a novel approach combining LLMs with symbolic programs to enhance interpretability in AI. It introduces LSPs, leveraging LLMs' interpretable modules and symbolic rules for decision-making.

Strengths include the innovative integration of LLMs and symbolic learning, the development of a divide-and-conquer training approach, and the introduction of IL-Bench for evaluation.

Weaknesses could be the need for more extensive testing across diverse datasets, and presentation improvement.

The decision to accept is based on the paper's innovative approach to improving AI interpretability, strong empirical results, and the potential impact on the field.

Decision: Accept (Poster)