ABSINSTRUCT: Eliciting Abstraction Ability from LLMs through Explanation Tuning with Plausibility Estimation (2024)

Abstract: Abstraction ability is crucial in human intelligence, which can also benefit various tasks in NLP study. Existing work shows that LLMs are deficient in abstract ability, and how to improve it remains unexplored. In this work, we design the framework ABSINSTRUCT to enhance LLMs’ abstraction ability through instruction tuning. The framework builds instructions with in-depth explanations to assist LLMs in capturing the underlying rationale of abstraction. Meanwhile, we introduce a plausibility estimator to select instructions that are more consistent with the abstraction knowledge of LLMs to be aligned. Then, our framework combines abstraction instructions with general-purpose ones to build a hybrid dataset. Extensive experiments and analyses1 demonstrate that our framework can considerably enhance LLMs’ abstraction ability with strong generalization performance while maintaining their general instruction-following abilities.ion ability is crucial in human intelligence, which can also benefit various tasks in NLP study. Existing work shows that LLMs are deficient in abstract ability, and how to improve it remains unexplored. In this work, we design the framework ABSINSTRUCT to enhance LLMs’ abstraction ability through instruction tuning. The framework builds instructions with in-depth explanations to assist LLMs in capturing the underlying rationale of abstraction. Meanwhile, we introduce a plausibility estimator to select instructions that are more consistent with the abstraction knowledge of LLMs to be aligned. Then, our framework combines abstraction instructions with general-purpose ones to build a hybrid dataset. Extensive experiments and analyses1 demonstrate that our framework can considerably enhance LLMs’ abstraction ability with strong generalization performance while maintaining their general instruction-following abilities.

heading: 1 Introduction
text: Abstraction ability is central to human cognition (Minsky, 1980), which is identifying shared traits among items to build a broader concept, like deriving the concept of “beverage” from “coffee” and “tea.” With this ability, we can derive general rules and principles from past experiences, which enables us to adeptly navigate new situations in our daily life (Russell and Norvig, 2010; Saitta and Zucker, 2013). In NLP, building abstraction resources has long been a vital challenge to which the community has devoted many efforts (Hosseini et al., 2018; He et al., 2022).
Among them, Wang et al. (2023d) built the first comprehensive benchmark, ABSPYRAMID, of abstract concepts for nouns, verbs, and events. In this benchmark, models are asked to detect the validity of an abstract concept, as shown in Figure 1. Their
1The code and data are available at https://github.com/ HKUST-KnowComp/AbsInstruct
evaluations on the benchmark reveal that abstraction remains challenging even for state-of-the-art LLMs. For example, ChatGPT (OpenAI, 2022) only modestly exceeds majority voting and substantially trails behind fine-tuned smaller models. While prior works have explored ways for generaldomain LLM alignment (Sanh et al., 2022; Ouyang et al., 2022), how to elicit the abstraction knowledge of LLMs remains unexplored.
Nonetheless, enhancing LLMs’ abstraction ability is a non-trivial task. We only observe slight improvements when gathering vanilla instructions from randomly sampled data for detecting abstract concepts. First, the responses of vanilla instructions only express the validity of abstract concepts as “Yes/No.” As a result, LLMs might only grasp the surface-level styles but miss underlying rationales in deciding the validity of abstract concepts (Kung and Peng, 2023). Moreover, existing studies show that LLMs acquire most of the knowledge and abilities during pre-training (Zhou et al., 2023; Jha et al., 2023). Thus, instructions from randomly sampled data might not be consistent with
973
the abstraction knowledge of pre-trained models for better elicitation.
To tackle those issues, we propose the framework ABSINSTRUCT to build instructions with detailed explanation traces and well-crafted data selection, as shown in Figure 1. The framework forms explanation traces by collecting meanings of each given instance and abstract concept. These traces can help LLMs better comprehend the underlying reasoning process of detecting abstract concepts. Moreover, we introduce a plausibility estimator to select instruction data consistent with the abstraction knowledge of a pre-trained model to be aligned. The estimator assesses the plausibility score of each example based on the probability computed by the pre-trained model. Then, we only retain examples with higher plausibility scores, which align better with the model’s knowledge. We also introduce a collection of filters based on lexical overlap, keywords, and predicted labels to ensure diversity and quality further. Ultimately, a hybrid dataset is constructed by combining instructions for abstraction detection with those in the general domain.
For evaluation, the framework first builds instructions for abstraction detection based on ABSPYRAMID (Wang et al., 2023d) and combines them with instructions from Alpaca (Taori et al., 2023). Next, we conduct extensive experiments and analyses of several popular LLMs instruction-tuned with our framework. The evaluation results show that applying ABSINSTRUCT can effectively unlock LLMs’ abstraction ability, with the performance surpassing existing alignment methods by a large margin of 6- 10%. Also, thorough ablation studies corroborate the efficacy of explanation traces, the plausibility estimator, and various filters. Meanwhile, we conduct detailed analyses to show the robustness of our framework and the generalization ability of LLMs trained with our framework. Last but not least, the automatic and human evaluations on two generaldomain instruction datasets, SuperNI (Wang et al., 2022b) and SELF-INSTRUCT (Wang et al., 2023b), manifest that our framework can enhance abstraction ability without compromising LLMs’ performance of following general instructions.

heading: 2 Related Work
text: Abstraction has long been widely applied across various tasks, including question answering (Zheng et al., 2023a), machine translation (Padó et al.,
2009), and many others (Yoshikawa et al., 2019; Khot et al., 2018; McKenna et al., 2021). While some works have studied entity abstraction (Clark et al., 2000; Wu et al., 2012; Song et al., 2015) without considering contexts, our work explores event abstraction with a few relevant fields:
Event Abstraction: This field focuses on studying abstraction within an event as context. One line of works studied extracting entailment graphs for verbs with two arguments from large corpora (Berant et al., 2011; Hosseini et al., 2018, 2019, 2021; Guillou et al., 2020; Chen et al., 2022; McKenna et al., 2021, 2023). Meanwhile, He et al. (2022) curated abstract concepts for nouns and events based on ATOMIC (Sap et al., 2019). Recently, Wang et al. (2023d) compiled a large benchmark that unifies the scopes of the abovementioned works. They collected abstraction descriptions of events and hypernyms of nouns and verbs using ChatGPT (OpenAI, 2022) and WordNet (Miller, 1995), which are then manually annotated. Their studies suggest that LLMs still struggle with abstraction knowledge with various mistakes. Thus, we present the first attempt to unlock the stronger abstraction abilities of LLMs.
Linguistic Entailment: In linguistics, the studies of event abstraction are guided by the concept of linguistic entailment (Beth, 1955; Murphy, 2010; Indarti, 2015), which is enforced by lexical semantics combined with the laws of logic. For example, Bella is a friendly kitten entails Bella is a cat, as one cannot be a friendly kitten without being a cat. Importantly, linguistic entailment contrasts with textual entailment (Dagan et al., 2005), also called NLI (Bowman et al., 2015; Conneau et al., 2018), which emphasizes what typicially can be inferred from a premise and can be fallible.
Instruction Tuning: Aligned LLMs are strongly preferred by humans over original ones (Zheng et al., 2023b; Chiang et al., 2023), and diverse methods are studied to curate instructions, such as NLP tasks (Mishra et al., 2022; Chung et al., 2022), real user requests (Conover et al., 2023), and synthetic instructions (Wang et al., 2023b). Recent studies (Mukherjee et al., 2023; Mitra et al., 2023) suggest that instructions with detailed responses can provide underlying rationales and enhance alignment efficacy. Meanwhile, several works (Zhou et al., 2023; Jha et al., 2023; Song et al., 2023) demonstrate that an LLM captures almost all the
knowledge during pre-training, which can be unlocked even with a small number of instructions during alignment. Motivated by these discoveries, we collect abstraction instructions with explanation traces and try to select instructions more consistent with LLMs’ knowledge for better elicitation.

heading: 3 Method
text: Eliciting abstraction knowledge from pre-trained LLMs can be challenging since it requires (1) underlying rationales in determining the validity of abstract concepts and (2) carefully curated instructions to better elicit the knowledge. Here, we describe the process of ABSINSTRUCT, which builds instructions with explanation traces and employs a plausibility estimator and several filters for data selection. This pipeline is depicted in Figure 2.

heading: 3.1 Data Format Definition
text: Our work concentrates on detecting valid abstract concepts (Wang et al., 2023d), defined as a binary classification task. The task input is a five-element tuple in the format of (head event, entailment relation, tail event, instance, concept). In detail, the instance is a component of the head event, which can be a noun, verb, or entire event. Then, we replace the instance with its concept to build the tail event. Models are asked to decide whether the concept is a valid abstraction of the instance, where the head event linguistically entails the tail event. Here, we study three entailment relations defined on instance types: Noun-Entail, Verb-Entail, and Event-Entail. We provide concrete examples in Appendices D.9 and E.
The format of instruction data consists of three elements: instruction, input, and response. An instruction outlines the task using natural language
while an input and response serve as a task example. Note that the input is optional because of the blurred boundary between it and the instruction. For example, while “Give me a report about the following topic” and “global economics” can serve as separate instruction and input, we also can combine them as a sole instruction: “Give me a report about global economics.”

heading: 3.2 Instruction and Input Compilation
text: We manually build instructions for all entailment relations: Noun-Entail, Verb-Entail, and EventEntail. Since our framework introduces detailed responses with explanation traces, the instructions for each relation comprise two steps, asking LLMs to (1) consider the meanings of the given instances and concepts and (2) predict the label based on the explanation in the first step.
Next, we collect the input of abstraction detection for each relation. Our framework samples five-element tuples with balanced labels from the training set of ABSPYRAMID (Wang et al., 2023d). To build the input, we verbalize each tuple using prompts that ask whether the concept is a valid abstraction of the instance, given the head event as context. We provide concrete prompts for building the instructions and input in Appendix A.1.

heading: 3.3 Response Collection with Explanation
text: In conformity with instructions, our framework collects responses consisting of two steps: (1) the explanation step, which contains the meanings of given words, and (2) the conclusion step, which confirms the concept validity by comparing word meanings. The easy-to-build component is the conclusion step. For each example, we verbalize the binary label as “Yes” or “No” and append a short comparison, such as “Yes, the meaning of [cpt]
encompasses [ins],” where [ins] and [cpt] are two placeholders for the given instance and concept.
For the rationale step, we first conduct a pilot study about using taxonomies to build explanation traces, such as WordNet (Miller, 1995), which can provide meanings of nouns and verbs. Our findings disclose two problems with using a taxonomy. First, the coverage of nouns in WordNet is inadequate. Only 6.32% of nominal phrases can be found in WordNet. For example, while “cat” is incorporated in WordNet, many specific types are absent, such as fluffy cat and ginger cat. Moreover, we need word sense disambiguation (Pradhan et al., 2007) to choose correct word meanings, which may accumulate errors in our framework. For example, the expert annotation shows that only 61.0% of WSD results from GlossBERT (Huang et al., 2019) are correct (Details in Appendix B).
To overcome those challenges, we build explanation traces with the help of an LLM. In detail, we prompt GPT4 under the zero-shot setting with the instruction asking the meaning of a given word. We collect the meanings of the instance and concept separately and then concatenate them to build the whole explanation trace. After collecting both steps, the framework constructs the whole response with the format:
Step1: <ins mean> Meanwhile, <cpt mean> Step2: Yes/No, the meaning of ...
where <ins mean> and <cpt mean> stand for the meanings of the instance and concept. The whole response interprets and compares the given instance and concept, assisting LLMs in seizing the underlying reasoning processes. We provide concrete prompts for using GPT4 in Appendix A.2.

heading: 3.4 Example Postprocessing
text: After gathering many examples, we employ several filters and a plausibility estimator to select instructions. First, two quality filters are introduced to remove basic errors: the prediction filter and the keyword filter. Then, we introduce a diversity filter based on ROUGE-L (Lin, 2004) to remove similar examples. Lastly, we design a plausibility estimator to select abstraction examples consistent with pre-trained LLMs’ knowledge.
Prediction Filter: A faithful explanation trace should assist LLMs in reaching the correct prediction. Therefore, given the explanation trace we built, we prompt GPT4 to predict a label for each
example. Then, we discard all examples that GPT4 cannot give the right answer:
{ ŷ = θLLM (i, x, e)
fpred(ŷ, y) = 1 {ŷ = y} , (1)
where θLLM signifies the parameters of GPT4 that outputs a predicted label ŷ given the instruction i, input x, and explanation trace e. Then, the filter fpred compares ŷ with ground truth y.
Keyword Filter: We observe that GPT4 may explain the meaning of another word in the head event rather than the given one due to hallucination (See cases in Appendix E). Thus, we design the keyword filter to discard examples whose explanation trace omits its instance or concept. Take Figure 1 as an example. The explanation must contain both the keywords “Labrador Retriever” and “dog.”
Diversity Filter Our framework collects a large pool of examples from ABSPYRAMID, which could result in multiple examples with similar instances or concepts. To promote diversity, a new example is added only if its ROUGE-L similarity with any existing example is below 0.7, following prior works (Wang et al., 2023b; Taori et al., 2023).
Plausibility Estimator Existing studies (Zhou et al., 2023; Jha et al., 2023) show that a model obtains its knowledge almost entirely during pretraining, which can be elicited with a modest set of examples during alignment. For better elicitation, we select examples that are more consistent with the knowledge of the pre-trained LLM to be aligned. Here, we measure the LLM-intrinsic plausibilities of each example, which is determined by
the model’s knowledge. Concretely, the plausibility is computed as the normalized conditional probability of the response r given the instruction i and input x:
Plausibility(i, x, r) = Pθ(r|i, x) 1 N , (2)
where θ are the parameters of the pre-trained model, and N is the number of tokens in r. The above equation is equivalent to the reciprocal of the perplexity of r conditional on i and x. Then, the framework only retains examples with top-K plausibilities. Note that we compute plausibilities based on a model’s intrinsic knowledge, in contrast to those definitions on real-world knowledge (Wu et al., 2012; Chalier et al., 2020). In practice, we take the logarithm of the above equation to ensure numerical stability.

heading: 3.5 Mixed Alignment Data
text: Our framework combines the abstraction instructions we collected and general-domain instructions to build the final dataset. The dataset is then used to finetune the same model that we use to compute plausibility scores. We concatenate an instruction and the input as a prompt (See details in Appendix C.1) and train the model to generate the response in a standard supervised way.

heading: 4 Abstraction Instruction Overview
text: In this section, we apply ABSINSTRUCT for inducing instruction data as a case study, with Llama2 (7B) (Touvron et al., 2023) used to estimate plausibilities. Our framework constructs 200 examples for each relation, derived from ABSPYRAMID.

heading: 4.1 Diversity
text: We identify the verb-noun structure in the head events of examples to examine the diversity of collected examples. We use the Berkeley Neural Parser (Kitaev and Klein, 2018; Kitaev et al., 2019) to parse each event and then extract the verb that is
closest to the root as well as its first nominal object. 391 out of 600 head events contain such structure as other events usually are more complex, such as “PersonX began renting the space to businesses.” We plot the 15 most common verbs and their top 3 direct nominal objects in Figure 3, which makes up 9.67% of the entire set. Overall, we see diverse topics and textual formats in these examples.
We further study the diversity of collected examples. For each example we collect, we compute its highest ROUGE-L similarity with other ones. We plot the distribution of these ROUGE-L scores in Figure 4. The results indicate a decent number of unique examples, which do not overlap much with the remaining.

heading: 4.2 Quality
text: To investigate the quality, we sample 150 examples and ask three experts to label the correctness of the meanings of instances and concepts (See details in Appendix B). Results in Table 1 demonstrate that most of the collected explanation traces are meaningful. While some traces may contain noise, we found that explanation traces can provide useful guidance for tuning LLMs for abstraction ability.

heading: 5 Experiment
text: We conduct extensive experiments and compare our framework with various baselines.

heading: 5.1 Dataset and Evaluation Metric
text: We study LLMs’ abstraction ability on ABSPYRAMID, a large-scale dataset of abstraction knowledge with statistics in Appendix D.1. Our framework and baselines build examples based on five-element tuples from its training set. Meanwhile, the generalpurpose instruction dataset we use is Alpaca (Taori et al., 2023), which contains 52K instructions generated with the SELF-INSTRUCT framework (Wang et al., 2023b). We mix instructions for abstraction with those general-purpose ones to fine-tune LLMs in the following experiments.
We calculate Accuracy and Macro F1-score for metrics between predicted and ground truth labels to evaluate all models’ abstraction ability.

heading: 5.2 Baseline Methods
text: We compare our framework to three baselines and provide implementation details in Appendix C, including learning rates, example numbers, API specifics, prompts for baselines, etc.
API-based LLM: We evaluate a series of closedsource LLMs under the zero-shot and few-shot (10-shot) settings, covering GPT3.5 (Ouyang et al., 2022), ChatGPT (OpenAI, 2022), and GPT4 (Achiam et al., 2023). In addition, we test ChatGPT with the self-consistency decoding strategy (Wang et al., 2022a).
Alpaca LLM: An intuitive method is to align open-source LLMs and test their abstraction ability with in-context learning. Here, we choose to tune LLMs with Alpaca (Taori et al., 2023), including models of MPT (7B) (Team, 2023), Falcon (7B) (Penedo et al., 2023), Mistral (7B) (Jiang et al., 2023), Llama2 (7B, 13B) (Touvron et al., 2023).
For inference, we test models with ten exemplars randomly sampled from ABSPYRAMID.
Direct Injection: This baseline randomly samples tuples from ABSPYRAMID and builds examples with the vanilla prompts (in Appendix C.2), where responses are solely “Yes” or “No.” Then, we mix abstraction examples with Alpaca for alignment. Similarly, the LLMs we tested are MPT (7B), Falcon (7B), Mistral (7B), and Llama2 (7B, 13B).

heading: 6 Main Evaluation
text: We present the results of each entailment relation and the average on the test set of ABSPYRAMID in Table 2. In general, our framework ABSINSTRUCT can unlock stronger abstraction ability from LLMs, exceeding the performance of all baselines by a large margin. For example, Mistral (7B) tuned with our framework correctly classifies 70.78% of test examples, increasing by 6.04% compared to the “Direct Injection” baseline. Meanwhile, Llama2 (13B), tuned with our framework, outperforms all the API-based LLMs, even GPT4.
Our results unequivocally demonstrate that the “Direct Injection” baseline possesses limited efficacy in eliciting abstraction knowledge. For example, Falcon (7B) only achieves performance slightly higher than a random guess. Similarly, we observe that LLMs tuned with Alpaca only capture limited generalization ability in abstraction detection, even with ten exemplars. For instance, Falcon (7B) only achieves a Macro F1-score of 52.13%, lagging behind our framework by about 10 points.

heading: 6.1 Ablation Study
text: To better understand how to unlock abstraction ability, we conduct several ablation experiments to show the effectiveness of explanation traces, quality filters, and plausibility estimators. The results of ablation studies are presented in Table 3.
Plausibility Estimator: We conduct two experiments to verify the efficacy of the plausibility estimator. First, we remove the estimator and randomly select examples (⋄ w P-Random). From the results in Table 3, we can find noticeable performance declines, verifying the plausibility estimator’s efficacy. Moreover, we consider another way to measure plausibilities instead of normalized conditional probabilities of explanation traces. Here,

heading: Models Acc Ma-F1 ∆Acc ∆Ma-F1 Fine-tuned on AbsPyramid
text: we compute the normalized probabilities of example input (⋄ w P-Input). As the performance consistently drops, we can see that explanation traces play a pivotal role in selecting plausible examples.
Quality Filters: We also conduct ablation studies for quality filters, including the prediction and keyword filters. Results (⋄ w/o Q Filter) show that LLMs’ performance deteriorates drastically after we remove these filters. Then, we further remove the plausibility estimator besides quality filters (⋄ w/o P&Q Filter). The results, like the decline of 8.44% on average, again show the efficacy of our filters and the plausibility estimator. Meanwhile, we analyze the role of the diversity filter in Appendix D.5, where we find that our framework can collect highly diverse examples and explanation traces, even without the diversity filter.
Explanation Traces: First, we remove explanation traces and employ the vanilla prompt, also used by the “Direct Injection” baseline. The results (⋄ w/o E Trace) show that LLMs cannot perform well. Further, we remove all the filters, estimator, and explanation traces (⋄ w/o All Parts), where we observe greater decreases in performance. Here, Llama2 (7B) significantly drops by 8.58% in the Macro F1-score. These findings demonstrate the utility of the explanation traces we collect.

heading: 6.2 Out-of-Domain Evaluation
text: This section studies if our framework can generalize to other tasks requiring abstraction knowledge. We conduct experiments on two out-of-domain
datasets: AbstractATOMIC (He et al., 2022) and Levy/Holt dataset (Levy and Dagan, 2016; Holt, 2018), with statistics in Appendix D.2.
AbstractATOMIC: First, we test our framework on the AbstractATOMIC dataset and treat “Direct Injection” as a baseline. We also fine-tune LLMs on ABSPYRAMID to test their transferring ability on AbstractATOMIC. As depicted in Figure 5, our framework can equip LLMs with broader generalization abilities. Particularly, Mistral (7B) attains a Macro F1-score of 76.7%, which is substantially higher than “Direct Injection.” Also, Llama2 (7B) exhibits improvements of over 10 points compared to its fine-tuned counterpart, which demonstrates our work’s essence of eliciting abstraction ability instead of fitting a specific dataset.
Levy/Holt Dataset: This dataset is primarily used to evaluate verb entailment graphs. We test the performance of models tuned with our framework and take the same baselines as AbstractATOMIC. As shown in Table 4, our framework performs better on the Levy/Holt dataset than the “Direct Injection” baseline. More generally, instruction-tuning methods can obtain better generalization than fine-tuning on ABSPYRAMID, given that instruction-tuning only needs a tiny fraction of training data. With our framework, the Macro F1-score of Llama2 (13B) improves considerably by 8.64% compared to the fine-tuned one.

heading: 6.3 Discussion of Explanation Trace
text: In previous sections, we collect explanation traces by prompting GPT4. Here, we evaluate our framework with explanation traces from a less advanced model, ChatGPT, to gain a deeper insight into the robustness. We plot and compare the Macro F1scores in Figure 6. The outcomes suggest that our framework maintains its strong performance with some fluctuations below 1 point. In particular, the score of Falcon (7B) improves by only 0.2% while Llama2 (13B) declines by only 0.6%.

heading: 6.4 Task Instruction Following
text: Prior experiments demonstrate the effectiveness of our framework in abstraction ability. Additionally, we also evaluate the ability of LLMs to follow general-purpose instructions for NLP tasks. Here, we choose the test set of SuperNI (Wang et al., 2022b), consisting of 119 tasks with 100 examples in each task. Following previous works (Wang et al., 2023b; Xu et al., 2023), we evaluate LLMs by
calculating ROUGE-L (Lin, 2004), BLEU-1/2 (Papineni et al., 2002), and Meteor (Banerjee and Lavie, 2005). For baselines, we train LLMs on the instruction dataset Alpaca (Taori et al., 2023), as it is also used in our framework. The results in Table 5 show that LLMs tuned with our framework can attain comparable scores to those fine-tuned on Alpaca. For instance, MPT (7B) obtains a slightly higher Rouge-L while Llama2 (7B) drops by only 0.09%. These findings manifest that injecting a few instructions for abstraction knowledge does not sacrifice the general ability of instruction following.
Meanwhile, previous works (Ouyang et al., 2022; Zhao et al., 2023) suggest a disparity between NLP tasks and human requests. Thus, we also conduct a human evaluation on expert-curated instructions (Wang et al., 2023b) to better understand the alignment with human values. The evaluation setups and results are shown in Appendix D.8, which again manifests that our framework can preserve LLMs’ general capabilities.

heading: 7 Conclusion
text: Abstraction knowledge is a critical kind of knowledge in human intelligence, as shown in previous cognitive studies (Minsky, 1980). Meanwhile, recent research (Zheng et al., 2023a; Gao et al., 2024) shows that using LLMs’ abstraction ability can better solve general NLP tasks, including STEM questions (Hendrycks et al., 2020; Miao et al., 2020), Knowledge QA (Yang et al., 2018; Kwiatkowski et al., 2019; Joshi et al., 2017), and Multi-Hop Reasoning (Trivedi et al., 2022; Geva et al., 2021). Given this evidence, we can see that abstraction is also essential for a broad range of complex language understanding and reasoning tasks.
In this paper, we propose ABSINSTRUCT, which is the first attempt to elicit stronger abstraction abilities from pre-trained LLMs. Our framework builds instructions for abstraction detection with explanation traces and a plausibility estimator. Then, these abstraction instructions are combined with generaldomain ones from Alpaca. In the experiments, we compare our framework with a lot of strong baselines to demonstrate the framework’s effectiveness. We also provide comprehensive ablation studies of our framework and show its effectiveness on two out-of-domain datasets. What’s more, evaluations on instruction datasets also show that our framework can improve the abstraction ability of LLMs without sacrificing LLMs’ general instruction following ability.
For future work, we can study how to equip LLMs with more abstraction knowledge during pre-training. More importantly, we also leave the study of using this enhanced abstraction knowledge in downstream tasks as future work.

heading: Limitations
text: Prior research (Zhou et al., 2023) indicates that LLMs primarily acquire their knowledge during the pre-training phase, while the alignment phase only teaches LLMs about the specific subdistribution of interactions with users. In this work, we mainly focus on the alignment phase, while it remains unclear what abstraction knowledge is captured by LLMs during pre-training. Following previous works of knowledge probing (Hou et al., 2023; Sun et al., 2023), future research can probe recent LLMs, like Llama2, to better understand this question and explore how to equip LLMs with more abstraction knowledge during pre-training.
Meanwhile, instruction tuning only elicits the
existing knowledge of pre-trained LLMs. We leave for future works about equipping LLMs with new abstraction knowledge through other techniques, like knowledge editing (Wang et al., 2023a; Zhang et al., 2024; Hase et al., 2023), retrieval augmented generation (Lewis et al., 2020; Gao et al., 2023b; Wu et al., 2024), event-centric knowledge (Wang et al., 2023c, 2022c; Gao et al., 2023a; Do et al., 2024), intention detection (Wu et al., 2023), and knowledge population (Shen et al., 2023). Meanwhile, we can extend our abstraction knowledge to multimodal, like exploring knowledge from given images (Shen et al., 2024; Cui et al., 2024).

heading: Ethics Statement
text: We evaluate the abstraction ability on ABSPYRAMID (Wang et al., 2023d), which is a free and opensource dataset. The out-of-domain (OOD) datasets, namely AbstractATOMIC (He et al., 2022) and Levy/Holt (Levy and Dagan, 2016; Holt, 2018), are also freely available and open-source. The instruction datasets SuperNI (Wang et al., 2022b) and SELF-INSTRUCT (Wang et al., 2023b) are released under the Apache-2.0 License. Meanwhile, the Alpaca (Taori et al., 2023) dataset is released under the CC BY NC 4.0 License.
Human evaluations are performed by three expert annotators with at least one year of expertise in NLP to ensure quality. The annotation works are compensated at the hourly rate of 7.6 USD, higher than the local minimum wage.

heading: Acknowledgements
text: The authors of this paper were supported by the NSFC Fund (U20B2053) from the NSFC of China, the RIF (R6020-19 and R6021-20), and the GRF (16211520 and 16205322) from RGC of Hong Kong. This paper was also supported by the Tencent AI Lab Rhino-bird Focused Research Program. We also thank the support from NVIDIA AI Technology Center (NVAITC) and the UGC Research Matching Grants (RMGS20EG01-D, RMGS20CR11, RMGS20CR12, RMGS20EG19, RMGS20EG21, RMGS23CR05, RMGS23EG08).

heading: A ABSINSTRUCT Prompts
text: This appendix lists the concrete prompts we use in our framework. First, we provide the prompts of building instructions, input, and responses. Then, we show the concrete prompts we use to collect word meanings from GPT4.

heading: A.1 Prompts for Instructions and Examples
text: We manually collect the prompt templates of instructions, input, and responses used in our framework, shown in Table 6. Models are given fiveelement tuples on the ABSPYRAMID dataset: (head event, entailment relation, tail event, instance, concept).
In our prompt templates in Table 6, there are three placeholders [head], [cpt], and [ins] for head events, concepts, and instances. Specifically, [ins] is the same as [head] for Event-Entail. Meanwhile, we indicate the entailment relations implicitly by using different instructions for different relations. For example, for Noun-Entail, the instruction contains “Identify the hypernym of a specific noun.” Note that the tail event can be built by replacing the instance with the concept in the head event. In conclusion, our prompt does not lose any information provided by five-element tuples.

heading: A.2 Prompts for Word Meanings
text: To build explanation traces, we also prompt GPT4 to collect the meanings of instances and concepts in a zero-shot manner. Here, we ask GPT4 to provide meanings of given words and then detect whether the given concept is valid. The prompt is shown in Table 7. We collect the meanings of instances and concepts in the first and second steps separately. Then, we concatenate them to build explanation traces.

heading: B Human Annotation
text: We conduct a few human evaluations in our study, including the Accuracy of GlossBERT (Huang et al., 2019), the quality of examples collected by our framework, and the ability of our framework to follow human instructions. In this appendix, we discuss the details of annotation and agreement between annotators.
All annotation tasks are performed by three postgraduate NLP researchers with at least one year of expertise in NLP. They understand our annotation tasks clearly and can serve as experts. Two annotators are authors of the paper, and the third
is another NLP researcher within the same institution for a more objective perspective. The authors’ involvement in the annotation process is part of their academic responsibilities, and no additional compensation is provided. The third annotator is compensated at the hourly rate of 7.6 USD, higher than the local minimum wage.
GlossBERT Accuracy: We sample 500 examples from ABSPYRAMID and run GlossBERT to disambiguate the given noun or verb. Three experts are asked to evaluate whether the disambiguation results are right, yielding 1500 ratings in total. The IAA score is 78.8% calculated using pairwise agreement proportion, and the Fleiss’s κ (Fleiss, 1971) is 0.57.
Quality of Collected Examples: We sampled 150 explanation traces collected by our framework ABSINSTRUCT. Similarly, three experts are asked to label two aspects: the correctness of explanations for given instances and concepts. This leads to 900 total ratings (150 examples × 2 aspects × 3 annotators). The Fleiss’s κ (Fleiss, 1971) is 0.62.
Human Instruction Following: There are 252 instructions in the test set of SELFINSTRUCT (Wang et al., 2023b), which are curated manually by experts. Here, the expert annotators are asked to annotate which response is preferred between our framework and the Alapca baseline. This leads to 756 ratings for each model. The IAA score is 80.95% calculated using pairwise agreement proportion, and the Fleiss’s κ (Fleiss, 1971) is 0.71.
C Implementation Details
We access open-source language models using Transformers (Wolf et al., 2020) and fine-tune them on 8 NVIDIA A100 (80G) GPUs. We fine-tune 7B
and 13B LLMs with LoRA (Hu et al., 2021) and load them with BF16. For LoRA, we only add new parameters to attention layers with the rank and α equal to 512 and 1024. The best checkpoint is selected according to the sum of all metrics on the validation set. The batch size and training epoch are 128 and 3, respectively. We grid search learning rates of 5e-6, 1e-5, 2e-5, 3e-5 and 5e-5.
We collect rationales for about 2,000 examples for each entailment relation and keep 200 examples with the highest LLM-intrinsic plausibility after filtering. For a fair comparison, the “Direct Injection” baseline also incorporates 200 examples for each entailment relation. We discuss choices of example numbers and show that 200 is proper in Appendix C.4. For APIbased LLMs, We access ChatGPT, GPT4, and GPT3.5 via OpenAI API2. The specific versions are gpt-3.5-turbo-0613, gpt-4-1106-preview, and gpt-3.5-turbo-instruct-0914. They are evaluated on one thousand examples that we randomly sampled from the test set of each entailment relation due to the trade-off between API expenses and our evaluation’s precision. For self-consistency, we sample 5 responses independently for each example and take the majority vote.
2https://platform.openai.com/docs/api-reference

heading: C.1 Prompts for Concatenation
text: We should concatenate the instructions and input as a prompt for our framework and the instructiontuned baselines: “Alpaca LLM” and “Direct Injection.” In our experiments, we employ the same prompt template as used by Alpaca (Taori et al., 2023), which is shown in Table 8.

heading: Verb-Entail

heading: Event-Entail

heading: C.2 The Vanilla Prompt of the “Alpaca LLM” and “Direct Injection” Baselines
text: This appendix provides the vanilla prompt used by the “Alpaca LLM” and “Direct Injection” baseline to build instructions and examples for abstraction detection, as demonstrated in Table 9. In contrast to our framework, the responses of this vanilla prompt are simply “Yes” or ”No,” verbalized directly from the binary labels.

heading: C.3 The Prompt of the “API-based LLM” Baseline
text: We employ the same prompt as those utilized in ABSPYRAMID (Wang et al., 2023d), which exhibit considerable robustness when benchmarked against other prompts featured in the study of ABSPYRAMID. We provide zero-shot prompts used by the
“API-based LLM” baseline in Table 10. The incontext learning prompts used by the “API-based LLM” baseline are shown in Table 11.

heading: C.4 Discussion of Example Number K
text: In our experiments, we collect K = 200 examples of abstraction detection for each relation in our framework and the “Direct Injection” baseline. In this appendix, we study the proper values of this hyperparameter and grid search different example numbers K of 50, 100, 150, 200, and 250. Here, we combine different numbers of abstraction instructions with Alpaca and instruction-tune Llama2 (7B) with our ABSINSTRUCT framework and the “Direct Injection” baseline. We plot the performance in Figure 7. For the “Direct Injection” baseline, the Macro F1-score shows rapid improvements as the number of examples increases from 50 to 200. Then, the improvement stagnates (i.e., lower than 0.5 points) at the number of 250. Similarly, for our framework, we observe the first decrease when the example number is 250. For both methods, we can find that the improvements are small when the example numbers are higher than 200. Thus, we recommend choosing 200 examples for each relation in our framework and the “Direct Injection” baseline when considering the tradeoff between abstraction ability and general-domain ability.

heading: D Supplementary Experiments
text: This appendix provides more supplementary experiments and analysis of the ABSINSTRUCT framework.

heading: SPLIT Noun Verb Event All Pos %

heading: D.1 Abstraction Data Statistics
text: We study LLMs’ abstraction ability on ABSPYRAMID (Wang et al., 2023d), a large-scale benchmark of abstraction knowledge comprising more than 221K examples. The dataset samples head events from ASER (Zhang et al., 2020, 2022) and collects abstract concepts of three components of head events: nouns, verbs, and entire events. ABSPYRAMID collects candidates of abstract concepts using WordNet (Miller, 1995) and ChatGPT (OpenAI, 2022), which is then manually verified. Our framework only builds 200 examples for each entailment relation based on five-element tuples from the training split. We present comprehensive statistics of ABSPYRAMID and our examples in 12.

heading: D.2 Out-of-Domain Datasets Statistics
text: As we conduct experiments on two out-of-domain datasets: AbstractATOMIC (He et al., 2022) and Levy/Holt dataset (Levy and Dagan, 2016; Holt, 2018), we provide comprehensive statistics of these two datasets in Table 13. AbstractATOMIC samples base events from ATOMIC (Sap et al., 2019) in the commonsense domain and collects thousands of abstract concepts for nouns and entire events. Meanwhile, the Levy/Holt dataset is primarily used in the study of verb entailment graphs, where events are simplified as a verb with two entity types as arguments (i.e., subject and object).
D.3 Validation Results on Abstraction Detection
We collect the performance of our framework ABSINSTRUCT and baselines on the validation set of

heading: Models Noun Verb Event All ∆All
text: the ABSPYRAMID in Table 23.

heading: D.4 Full Results of Ablation Study
text: Here, we present the full ablation study results of all LLMs trained with our framework ABSINSTRUCT in Tables 14 and 15.

heading: D.5 Study of Diversity Filter
text: In this appendix, we study the role of diversity filters in our framework ABSINSTRUCT. Here, we remove the diversity filter and analyze the performance of the ablated framework.
First, we inspect the diversity of examples collected by the ablated framework. We compute the average ROUGE-L similarity between the head events and between explanation traces. From the Table 18, we can see that the average ROUGE-L similarities are no more than 0.2 for head events and 0.3 for explanation traces. Meanwhile, we also compute the proportion of unique head events and explanation traces based on ROUGE-L, following previous work (Wang et al., 2023b). A head event x is unique if RougeL(C, x) ≤ 0.7, where C is other head events collected by our framework. We apply the same criterion to identify unique data for expla-
nation traces. From Table 18, we can see that more than 96% of head events and explanation traces are unique. These findings of average ROUGE-L and uniqueness percentages demonstrate that our dataset can collect quite diverse examples even without the diversity filter.
Then, we test the performance of the ABSINSTRUCT framework without the diversity filter, shown in Table 19. We can observe that the performance of all LLMs varies slightly. While we add a filter in our framework to guarantee the diversity of collected examples, our study verifies that the data collected by the ablated framework is already highly diverse.

heading: D.6 Full Results of Out-of-Domain Evaluation
text: As we only plot the Macro F1-scores in Figure 5, we provide the full results on the AbstractATOMIC dataset across all metrics in Table 16. Meanwhile, we provide the results of all LLMs on the Levy/Holt dataset in Table 17.

heading: D.7 Full Results of ChatGPT Rationales
text: As we only plot the Macro F1-score on the whole test set of ABSPYRAMID in Figure 6, we provide the full results on each entailment relation of ABSPYRAMID in Table 20.

heading: D.8 Human Instruction Following
text: As previous works (Ouyang et al., 2022; Zhao et al., 2023) suggest a disparity between NLP tasks and human requests, we manually evaluate our framework on the 252 expert-curated instructions

heading: Models Acc Ma-F1 ∆Acc ∆Ma-F1 Fine-tuned on AbsPyramid
text: of SELF-INSTRUCT (Wang et al., 2023b) to better understand the alignment with human values. Similar to our evaluation on SuperNI, we consider LLMs trained on Alpaca as baselines. Three expert annotators are asked to compare responses from our framework to the baseline and label which one they prefer. We provide annotation details in Appendix B. Our human preference annotation results are plotted in Figure 8. We observe that a significant portion of prompts are labeled as “Tie.” Also, the winning rates appear to be comparable to, or even exceed, those of baselines preferred. These findings again manifest that our framework preserves LLMs’ general capabilities while enhancing their abstraction ability.

heading: D.9 Case Study and Error Analysis
text: In this section, we provide two examples with responses from our framework and the “Direct Injection” baseline. Here, the LLM we use is Llama2 (7B). As shown in Table 21, we can see that the baseline model cannot generate the correct answers. In contrast, our framework can explain and compare meanings of the instances and concepts in these examples and then give correct labels.
Then, we also provide an example in Table 22, where our framework (Llama2 7B) gives wrong predictions. We can see that the model makes wrong conclusions while it explains the instance and concept correctly.

heading: E Study of Filtered Examples
text: In this appendix, we provide a few examples discarded by each quality filter to show their effec-
tiveness. First, we provide two examples that are discarded by the prediction filter in Table 24. In these cases, GPT4 generates wrong explanations and predicts wrong labels for these examples. For example, GPT4 considers “marriage” as “a social and legal institution,” while it refers to “the legal relationship between a husband and wife” in the current context. Meanwhile, GPT4 considers “concession” as a “grant or a contract,” while it refers to “a right or an advantage that is given to a group of people, an organization, etc.” We can find that GPT4 can generate wrong explanations and in turn, get wrong answers.
Then, we also list two examples discarded by the keyword filter in Table 25. While GPT4 predicts the correct labels for these examples, it fails to explain the correct instance or concepts. For example, GPT4 explains “dad-mouthing” in the first example instead of the correct instance “quoted.” In the second example, GPT4 changes the original sentence to “the things that happen to PersonY,” which is indeed a fragment and lacks a complete sentence structure.

heading: Example #1

heading: Example #2

heading: Example #1

heading: Example #2

heading: Example #1

heading: Example #2

heading: Example #1

heading: Future Work
text: , 2023), future research can probe recent LLMs, like Llama2, to better understand this question and explore how to equip LLMs with more abstraction knowledge during pre-training. Meanwhile, instruction tuning only elicits the
existing knowledge of pre-trained LLMs. We leave for future works about equipping LLMs with new abstraction knowledge through other techniques, like knowledge editing (Wang et al. , 2023a; Zhang et al. , 2024; Hase et al. , 2023), retrieval augmented generation (Lewis et al. , 2020; Gao et al. , 2023b; Wu et al. , 2024), event-centric knowledge (Wang et al. , 2023c, 2022c; Gao et al. , 2023a; Do et al. , 2024), intention detection (Wu et al. , 2023), and knowledge population (Shen et al. , 2023). Meanwhile, we can extend our abstraction knowledge to multimodal, like exploring knowledge from given images (Shen et al. , 2024; Cui et al. , 2024)