ECR-Chain: Advancing Generative Language Models to Better Emotion-Cause Reasoners through Reasoning Chains

1 Introduction

Emotion plays an important role in human communication and there are many dialogue-related research works in the NLP field involving analysis and utilization of emotions. Emotion recognition in conversation, for example, aims to detect the emotional status of a conversation utterance based on the context [Majumder et al., 2019; Ghosal et al., 2019; Liu et al., 2022]. Emotional response generation, on the other hand, aims to incorporate emotional factors into dialog systems to enhance user satisfaction [Wei et al., 2019; Zhong et al., 2021]. However, these tasks lack attention to deeply understanding the causes behind emotions, which limits the application in broader areas like emotional support dialogue systems.

* Qin Jin and Jinming Zhao are corresponding authors.

Therefore, a new task called "Causal Emotion Entailment" (CEE) together with a new benchmark dataset "RECCON" [Poria et al., 2021] has been proposed. As depicted in Figure 1, given a two-person conversation, the corresponding emotional state of the speaker of each sentence, and the target utterance, the goal of CEE is to identify which preceding utterances (including the target itself) are causal utterances containing the stimulus factors that lead to the emotion of the target utterance. Based on this benchmark, various methods that attempt to improve emotion-cause prediction have been explored. Modeling the speaker-aware semantic and emotional interaction in the conversation context has been proven to be effective [Zhang et al., 2022a] while introducing external social commonsense knowledge (CSK) [Hwang et al., 2021] to the contextual interaction could also be helpful [Li et al., 2022a; Zhao et al., 2023a]. These methods treat the CEE task as a supervised classification problem, identifying whether each utterance is a causal utterance or not. Nevertheless, they neglect the exploration and learning of the emotiongeneration process, which limits their ability to take a deeper understanding of emotions and restricts them from providing explainable rationales behind the emotion-cause. In contrast to these aforementioned works, we will not only explore to better address the CEE task but also extend it into a more challenging Explainable Emotion-Cause Reasoning task in this paper.

To overcome the limitations of previous models and realize explainable emotion-cause reasoning, we explore using generative language models to reason in our task. Considering that inferring the causes from emotional expression can be seen as a reverse process of emotion generation, we can refer to psychological descriptions of how emotions arise to determine the reasoning steps. According to the cognitive appraisal theory [Arnold, 1960; Ellsworth, 1991], the process of emotion generation can be summarized as "stimulusappraisal-emotion". This sequence starts when a person attends to certain aspects of their environment or events, stimulating them to form interpretations or evaluations internally, which ultimately culminate in a specific emotional response. Therefore, in our task, considering our textual conversation scenarios, we can start by identifying behaviors related to the target emotion based on the target utterance and the global context. Subsequently, we can infer the speaker's inner thoughts based on their behaviors and finally deduce the stimuli that led to these thoughts. Based on the above analysis, we introduce an Emotion-Cause Reasoning Chain (ECRChain), formatted as "theme → reaction → appraisal → stimulus", which can be regarded as a step-by-step reasoning process as shown in Figure 1.

Specifically, inspired by the Chain-of-Thought (CoT) prompting method [Wei et al., 2022], we incorporate our ECR-Chain into the in-context learning [Brown et al., 2020] to guide large language model's reasoning step by step and achieve significant performance improvements under the fewshot CEE task setting. Having verified the effectiveness of this chain in emotion-cause reasoning, we further supplement the RECCON dataset with an automatically generated ECRChain set that can be used for supervised training. For example, we use the constructed ECR-Chain set for multi-task training on smaller generative language models and effectively enhance their emotional reasoning abilities to provide explainable reasoning paths and cause descriptions that were difficult to achieve with previous CEE models.

The main contributions of this work include: 1) We propose an emotion-cause reasoning method, ECR-Chain, and use it to guide the reasoning process of language models via CoT prompting. 2) We automatically construct an ECRChain set to help enhance the emotional reasoning ability of supervised models. 3) Extensive experimental results over various settings demonstrate the effectiveness of our method for predicting emotion-cause utterances and performing explainable emotion-cause reasoning.

2 RelatedWorks

2.1 Causal Emotion Entailment

Poria et al. [2021] address the task of recognizing emotioncauses in conversations. It includes two sub-tasks: Causal Emotion Entailment (CEE) and Causal Span Extraction (CSE). Recent related works mostly focus on the CEE task. Zhang et al. [2022a] propose a two-stream attention model (TSAM) to incorporate both speaker identities and emotional states into utterance features via contextual interaction modeling. Li et al. [2022a] introduce commonsense knowledge (CSK) related to speakers' emotional interactions and build a knowledge-enhanced conversation graph. Zhao et al. [2023a] further leverage event-centered CSK and social-interaction CSK to construct a knowledge-bridged causal interaction network. These above works all use RoBERTa [Liu et al., 2019] to extract contextual utterance-level features and design specific graph structures to model various interactions between utterances. Although their model structures are suited for making classifications for each utterance in a conversation, the explainability of their models is limited. Recently, Zhao et al. [2023b] evaluate the performance of ChatGPT 1 on various emotion-related dialogue tasks, including the CEE. However, they simply instruct the ChatGPT to provide predictions based on the task input, lacking exploration of reasoning methods, which limits their performance. In our work, we explore employing a reasoning process to enhance the emotioncause prediction performance of generative language models and enable them to have explainable reasoning capabilities.

2.2 Chain-of-Thought for Reasoning

Wei et al. [2022] first explore adding a few Chain-ofThought (CoT) demonstrations via few-shot prompting to guide the large language model (LLM) thinking "step-bystep". Following their success, lots of works continue exploring improving the CoT prompting methods, including SelfConsistency [Wang et al., 2022], DiVeRSe [Li et al., 2022c], Auto-CoT [Zhang et al., 2022b], and Active-Prompt [Diao et al., 2023]. On the other hand, though smaller models cannot directly benefit from CoT prompting [Wei et al., 2022], distilling the rationales generated by LLM into smaller models may still be helpful for them to solve the reasoning tasks [Ho et al., 2023]. Li et al. [2022b] first prompt LLM to generate rationales for each question in the dataset. They then propose a multi-task training strategy to utilize the rationales as auxiliary training objectives for smaller models. Hsieh et al. [2023] also apply the multi-task method to distill the reasoning knowledge and improve the smaller models to outperform LLMs on their tasks. Inspired by these works, we first propose a CoT method customized for emotion-cause reasoning, and then improve the smaller models via multi-task training with the rationales automatically constructed by LLMs.

1 https://openai.com/blog/chatgpt

3 Method

3.1 Task Definition

For the Causal Emotion Entailment (CEE) task, given a two-party conversation C, which is denoted as C = [(u1, k1, e1), (u2, k2, e2), ..., (ut, kt, et)], where ki, ui and ei are the speaker identity, the content, and the emotion of the i-th utterance respectively, its goal is to predict which utterances ui (i ≤ t) in the conversation context are responsible for evoking the non-neutral emotion et of the target utterance ut. We can reform it into a question-answer task, where the question is Q = {C, (ut, kt, et)} and the answer is A = {ui}. CEE task only evaluates the predicted answer A and does not care how the answer is derived.

To develop explainable models, we further extend the CEE task to an Explainable Emotion-Cause Reasoning (Explainable ECR) task, where given a question Q in the same format as mentioned above, the model is required to output the predicted answer A along with its rationale R. Explainable CEE may enhance the credibility of the prediction and benefit other emotion-related tasks.

3.2 Overview

Based on the cognitive appraisal theory in psychology, we introduce a reasoning process of "theme → reaction → appraisal → stimulus", which we call it "Emotion-Cause Reasoning Chain (ECR-Chain)". Tailored for emotioncause reasoning in textual conversations, this serialized reasoning scheme is also consistent with the generation mode of generative language models, as they always predict the following words based on the preceding content. Therefore, we consider taking advantage of the ECR-Chain to improve the emotion-cause reasoning of generative language models.

For the two tasks defined in Section 3.1, we explore both the few-shot learning with large language models (LLMs) and the supervised learning with smaller generative language models 2 . For LLMs larger than 100B, inspired by the Chainof-Thought (CoT) method [Wei et al., 2022], we design a few-shot prompt to instruct them to reason step-by-step following our proposed ECR-Chain and then infer the final answer. But for smaller models, due to their limited parameter scales, the effect of directly applying the CoT prompting is not evident [Wei et al., 2022]. So we consider improving their reasoning abilities through supervised training. As no such ECR-Chain data is available, we employ LLMs to automatically construct an ECR-Chain set to enable supervised training for smaller models to enhance their reasoning capability. Ultimately, through multi-task training, we build a model capable of performing the two tasks.

3.3 Few-shot Prompting with ECR-Chain

For generative language models, the most intuitive solution to a question-answer task is to generate an answer A directly based on the question Q, that is, P(A|Q). However, when performing a reasoning task, the indirect correlation between Q and A may limit the performance. For LLMs, we

2 Models with a size smaller than 100B are considered to lack evident CoT ability [Wei et al., 2022].

Please understand the emotion-cause for the target utterance in a given conversation. [Task Description]: ... [Description of Reasoning Process]: 1. Output the "Theme": ... 2. List "Reactions" items of target utterance: ... 3. List "Appraisals" items of target utterance: ... 4. List "Stimuli" items with their corresponding utterance id: ... 5. Based on these "Stimuli" items, output the index number of the causal utterances in the form of Python list without any other content. I will show you some examples: [Example]: ... - To be solved - [Question]: ...

can employ the CoT prompting method to first guide them to generate a rationale R for the question Q, and then derive the final answer A based on R, forming in the format P(R,A|Q). This approach often results in more accurate predictions. Considering that inferring emotion causes from emotional expressions also requires step-by-step reasoning, we design a few-shot prompt, denoted as <reasoning> , to guide the LLMs in reasoning along the ECR-Chain. Figure 2 is a diagram of our prompt, which mainly contains four parts:

• Task Description: Contains the goals of the emotion-cause reasoning task and the input and output formats.
• Description of Reasoning Process: Describe the meaning of each component in the ECR-Chain and specific requirements for each of the 5-step reasoning steps. We instruct the model to list the "Reactions", "Appraisals", "Stimuli" in items to make the reasoning process clearer. Besides, we require that each generated "Stimulus" item be followed by its corresponding utterance indexes so that the model can directly summarize all predicted utterance indexes and provide the final answer.
• Example: We manually write expected rationales for a few of the questions in the training set to serve as exemplars in few-shot prompting. Each exemplar consists of the conversation C, the target utterance ut, and a manually written rationale r. Each utterance with its emotion and speaker label is simply written in this format: #[utterance index]: [speaker] ([emotion]): "[utterance content]".
• Question: Present the conversation and target utterance for each sample in the test data and instruct the model to perform 5-step reasoning.

3.4 Supervised Learning with ECR-Chain

Since the reasoning capability of smaller models is limited, it is hard to teach them to reason along our introduced ECRChain simply through few-shot prompting. However, recent studies have shown that distilling the CoT rationales from LLM to smaller ones can help to enhance the reasoning capabilities of the smaller models on specific tasks [Li et al., 2023; Ho et al., 2023]. To this end, we utilize LLMs to automatically construct an ECR-Chain set, and perform supervised training with ECR-Chain on smaller models.

Automated Construction of ECR-Chain Set

The generation of reasoning chains can be approached in two ways: 1) reasoning through CoT prompting which derives an answer, or 2) generating explanations by rationalization prompting conditioned on labels [Marasovi´c et al., 2022]. The first approach may generate higher-quality rationales if the derived prediction is correct since the rationales have been proven to effectively guide the language model to output our expected answer. However, when the prediction is wrong, the reasoning approach may provide some misleading rationales. Zelikman et al. [2022] and Li et al. [2022b] propose to generate a new rationale by rationalization prompting to supplement for questions that can not be reasoned to a correct answer. However, our ECR-Chain rationales are more complex compared to their works, as our rationales may contain multiple items in the Reaction, Appraisal, and Stimulus part, and different stimulus items may lead to different causal utterance predictions. Therefore, we propose a 4-stage processing procedure to generate and further revise our rationales, which involves reasoning, filtering, rationalization, and consolidation, as illustrated in Figure 3.

a) Reasoning: We first execute a reasoning process using the <reasoning> prompt illustrated in Figure 2 and obtain raw rationales. Here we denote the Reaction, Appraisal, and Stimulus part of our rationals as n, l, s, respectively. Each of them may contain multiple items. Here, we require that for each appraisal item lj generated, the index number of its corresponding reaction item ni be specified. For each stimulus item sk, its corresponding lj needs to be specified similarly. From this, we can determine the corresponding relationship from ni to lj and to sk, linking these three items to a chain, as shown in Figure 3. Besides, we can find the set of all predicted answers apred corresponding to generated stimulus items s.

1. Filtering: Since the ground-truth label is unknown to the LLM in the reasoning stage, the raw rationales may include some chains that lead to wrong answers. With the help of the connections we built in the reasoning stage, we can remove an entire chain {ni, lj, sk} corresponding to a wrong predicted answer apred w . We also remove those items in each part that could not lead to any subsequent items.
2. Rationalization: If there are some answers in the ground-truth label that do not appear in apred , we then need to supplement their corresponding rationales. We perform a rationalization process separately for each missing labeled answer aGT m . Intuitively, rationalization should be the opposite process of reasoning, that is, deducing the target speaker's appraisal of the stimulus factors corresponding to the specified causal utterance, and then further deriving the corresponding reaction. However, extracting the exact stimulus factors from a given causal utterance may not be as straightforward as locating the causal utterance based on already inferred stimulus factors. Because the stimulus factors are often only a part of the full semantic content of its corresponding causal utterance. Therefore, it is necessary to consider the entire process of the emotion generation process first. In our designed <rationalization> prompt, we first add an "explanation" step. In this step, we ask the LLM to explain in free text why the specified causal utterance would trigger the target speaker's target emotion, and what the evoking process is like, to fully consider the connection between the target utterance and the specified causal utterance. Following this, the model can extract a stimulus factor from the causal utterance more precisely and then deduce its subsequent appraisal and response. This approach results in clearer and more precise rationales, especially in the stimulus part.

d) Consolidation: For a conversation sample, we need to merge the reasoning chains after filtering and rationalization.

However, the merged rationale may contain many semantically similar items in each part. To make it more concise and clear, we design a <consolidation> prompt to instruct the LLM to condense the items in the Reaction, Appraisal, and Stimulus parts if needed. We require the LLM to merge items with similar semantics in each part while avoiding excessive modifications to the original phrasing.

Multi-task Training with ECR-Chain Set

After constructing the ECR-Chain set, we can utilize it to assist the supervised training of smaller models. We adopt the MT-CoT method proposed by [Li et al., 2022b] to train on both the golden answer and the collected rationales. Specifically, we utilize two types of instructions. The one uses a simple <answer> prompt that guides the model to directly output the answer based on the question, namely P(A|Q). And the other applies the <reasoning> prompt to instruct the model performing P(R,A|Q). During the training process, we construct each question sample into these two types of instructional inputs separately and calculate the Lreasoning and Lanswer with the referenced rationale constructed by LLM and the golden causal utterance label, respectively. The overall loss function is simply a mixture of these two losses:

This approach enables our trained model to perform inference in different manners. If we only need to identify the causal utterances in applications like the CEE task, we can use the <answer> instruction to predict directly. If we expect an explainable generation, we can use the <reasoning> instruction to provide step-by-step descriptions of the reasoning process.

4 Experiment

4.1 Dataset

We conduct experiments on the RECCON-DD dataset [Poria et al., 2021]. This dataset supplements causal utterance annotations for each non-neutral utterance in the conversations of the DailyDialog dataset [Li et al., 2017]. For a target utterance, its corresponding causal utterances form positive causal pairs with it, while the remaining utterances in the conversation history form negative pairs with it. Following [Zhao et al., 2023a], we only consider the potential causes within the conversation history and remove repetitive positive causal pairs in the original dataset. The statistical details of the dataset are presented in Table 1. Following Poria et al. [2021], we report the F1 scores of both negative and positive causal pairs and the macro F1 scores of them when evaluating performance on the CEE task.

4.2 Implementation Details

We utilize ChatGPT (gpt-3.5-turbo-0613) as our LLM and set the temperature to 0 to reduce the randomness. During the construction of the ECR-Chain set, we employed 4 handwritten exemplars for the <reasoning> prompt, 4 exemplars for the <rationalization> prompt, and 3 for the <consolidation> prompt to enhance the LLM's understanding of our specific requirements. The details about the examplars and prompts are presented in the Appendix. For the smaller language model, we opt for Vicuna-7B-v1.3 3 which is based on the LLaMA [Touvron et al., 2023]. Due to the computation limit, we applied LoRA fine-tuning [Hu et al., 2021] for the supervised training. Our total training batch is set to 256 (with gradient accumulation) and the learning rate is set to 1e-3. We train 10 epochs and pick the model that performed best on the validation set to evaluate on the test set. We report the average results of 3 runs for the supervised model.

4.3 CEE with Few-shot Learning

We first report the results of using LLMs to perform the CEE task in a few-shot manner, as shown in Table 2. Zhao et al. [Zhao et al., 2023b] have evaluated the performance of ChatGPT on various emotion-related tasks, including the CEE task. They construct task-specific prompts and ask the model to predict the answer without attempting to guide the model through reasoning. Since they do not provide prompt details in their paper, we directly reference the results they reported. We then compare the CEE performance of directly predicting the answers with reasoning through our ECRChain, both under our input format. In the 1-shot scenario, the performance of "Answer" in our experiments is inferior to that of [Zhao et al., 2023b], which might be due to discrepancies in input format, ChatGPT version, or the chosen exemplar. But our primary focus here is on the effectiveness of reasoning using the ECR-Chain. According to Table 2, guiding the LLM to reason following the ECR-Chain significantly improves causal utterance prediction over the two aforementioned baselines. In the 4-shot scenario, our proposed reasoning method can bring more than a 7% improvement in the Macro F1 metric over the baseline, which demonstrates the benefit of the reasoning process in correctly identifying emotion-causes.

3 https://lmsys.org/blog/2023-03-30-vicuna/

We also conduct an ablation study to analyze the impact of each part of our proposed reasoning chain, as shown in Table 3. The stimulus part, which is directly associated with the final causal utterances, is considered a detailed description of the cause and thus was retained in all experiments to assess the influence of the presence or absence of other components. When the LLM is instructed to directly provide a stimulus description based on the input, the predicted causal utterances corresponding to the stimulus are often inaccurate. In contrast, the accuracy of tracing the cause improves significantly if the model first deduces the speaker's appraisal associated with the target emotion before inferring the stimulus that evoked that emotion. This indicates that "appraisal" is central to the entire process of emotion generation, and understanding appraisal is crucial for comprehending emotions. Additionally, summarizing the conversation's theme and the speaker's emotional reaction is beneficial. It helps the LLM gain a fuller understanding of the dialogue context and the speaker's state, thereby enhancing the causal tracing.

4.4 CEE with Supervised Learning

As shown in Table 4, we compare our multi-task model against models trained on single tasks, namely the "Answer" and "Reasoning" listed in the table. "Answer" refers to only employing the CEE task labels for training the Vicuna. During inference, the model directly outputs the predicted answers, which are not explainable. "Reasoning" denotes fully supervising the Vicuna by ECR-Chains generated by the LLM during training. The trained model outputs rationales in a step-by-step manner during inference, making the results explainable. The multi-task model, as described in Section 3.4, is trained using both answer-only and reasoning supervision, allowing the model to either directly predict answers or generate rationales to derive the answer, depending on the form of the input instruction. Besides, we report the results of some previous methods based on RoBERTa: KEC [Li et al., 2022a], KBCIN [Zhao et al., 2023a], TSAM [Zhang et al., 2022a], along with the results of vanilla RoBERTa. These previous works extract features from utterances, model interactions between different features within the conversation, and then perform binary classification on each utterance feature to obtain a prediction of either positive or negative. Hence, the predictions from these works are unexplainable.

Compared to the answer-only training strategy, incorporating the ECR-Chain set for multi-task training can bring an obvious performance gain when utilizing the <answer> instruction for inference. Our multi-task model, when directly predicting answers, also surpasses the previous baselines. This indicates that our ECR-Chain set, providing more detailed and comprehensive supervision, can improve the supervised models to capture emotion-causes more precisely.

When comparing the results of "Answer" and "Reasoning", we observe that performing reasoning in training and inference is less effective than directly predicting the answer for the CEE task. We think there are two possible reasons. Firstly, the long length of our rationales may lead to insufficient optimization of the model for the final answer prediction part, which constitutes only a small portion of an entire rationale. Secondly, the reasoning ability of the smaller model may be limited by its scale. We consider this an open problem, as similar phenomena were also observed in the onestage fine-tuning experiments of [Zhang et al., 2023]. The multi-task training method can mitigate the first issue, and our experiments show that the predictions derived through reasoning in multi-task models indeed bring improvement. Moreover, the explainable outcomes achieved by our multitask model via <reasoning> instruction are comparable to those unexplainable baselines specifically training for the CEE task from previous works, further highlighting the advantages of our model.

In summary, our multi-task model can be regarded as a versatile model, capable of providing precise predictions directly via the <answer> instruction, as well as offering explainable reasoning of the predictions through the <reasoning> instruction.

4.5 Explainable Emotion-Cause Reasoning

Here we evaluate the performance of models when performing emotion-cause reasoning in an explainable manner, as shown in Table 5. "Vanilla-Vicuna" refers to the original Vicuna model without our fine-tuning, while "MT-Vicuna" is our multi-task trained model. All models apply the same 1shot <reasoning> instruction as input. "Macro F1" evaluates the final reasoned causal utterance indexes against golden labels. The "GPT-4/Claude3 Score", on the other hand, employs advanced LLMs, GPT-4 and Claude3-Opus, to assess the quality of the generated rationales. Specifically, we follow the evaluation template provided in FairEval [Wang et al., 2023] to design our own evaluating prompt. We instruct it to focus on three aspects of the rationale: logical coherence within the rationale, the relevance of the rationale to the original conversation, and the plausibility of the final stimulus description. It is required to give an overall score for each rationale, together with the scoring explanations. More detailed evaluation settings and evaluation prompts are presented in the Appendix.

For the "Macro F1" score of causal utterance prediction in Table 5, our multi-task model performs the best, even surpassing the results of the teacher model ChatGPT, which indicates that our ECR-Chain set refined based on the golden labels can effectively aid supervised models in deriving the expected answers. And for the metric of rationale quality, "GPT-4/Claude3 Score", our multi-task model also significantly outperforms the vanilla vicuna, proving that our constructed ECR-Chain set can effectively enhance the reasoning abilities and the explainability for emotion causes via supervised training. However, there is still a certain gap between our multi-task model and ChatGPT. On the one hand, this may be due to ChatGPT providing rationales richer in logical coherence and more aligned with the conversation context, which reflects the powerful logical and explanatory capabilities of ChatGPT brought about by its large parameter scale. On the other hand, the reason could also be that ChatGPT offered some causal explanations that led to answers mismatched with the labels, yet were convincing enough for the evaluation LLMs to consider them reasonable. These explanations might also make sense, considering the subjectivity involved in emotion-cause annotations.

We further conduct a case study as shown in Figure 4. In this case, the vanilla Vicuna performs the worst, with its reaction summary not aligning with the target sentence, leading to an unreasonable derivation of the stimulus content. Our multi-task model precisely identifies the direct factor, matching the final answer with the label and presenting a concise and straightforward reasoning chain. The ChatGPT seems to introduce some assumptions in the reaction part, but is considered to provide more detailed stimuli by GPT-4. Actually, in this example, the golden label corresponds to the most direct cause, while the additional two stimulus items provided by ChatGPT can be viewed as indirect background factors. Therefore, if our goal is to extract more precise stimulus factors and acquire more direct reasoning chains, we may opt for the supervised model trained on our ECR-Chain set to avoid excessive irrelevant generated content. If we aim to discover more potential factors, we can directly instruct the LLMwith our proposed ECR-Chains to fully leverage its rich knowledge and powerful reasoning capabilities, which may result in some insightful descriptions related to the emotion generation process.

5 Conclusion

In this paper, we explore emotion-cause reasoning with generative language models. We first introduce the EmotionCause Reasoning Chain (ECR-Chain), which can guide large language models (LLMs) to infer the emotion causes from emotional expressions with CoT prompting. Considering the limited reasoning abilities of smaller models, we utilize LLMs to automatically construct an ECR-Chain set through a four-stage processing workflow and perform supervised training based on the ECR-Chain set through multi-task learning. Experimental results demonstrate that our method can enhance the prediction of emotion-cause utterances while also enabling generative language models with the ability to perform explainable emotion-cause reasoning.

Ethical Statement

In this paper, we utilize ChatGPT to construct a reasoning chain dataset for supervised training. We notice that during the reasoning process, ChatGPT may generate hallucinations, such as conflating the identities of two speakers within a conversation. We propose revising strategies based on task labels and find that they can effectively remove some items that contain factual errors. However, there may still be some misleading content remaining in the set.

Acknowledgments

This work was partially supported by the the National Natural Science Foundation of China (No. 62072462), National Key R&D Program of China (No.2020AAA0108600), and Beijing Natural Science Foundation (No. L233008).