Knowledge Enhancement and Semantic Information-Fused Emotion–Cause Pair Extraction

Abstract

Emotion–cause pair extraction is a crucial task in natural language processing that identifies emotional expressions and their corresponding causes within text. Despite substantial progress, most current approaches depend on sequence modeling or standard attention mechanisms, which frequently overlook intricate inter-sentential relationships and fail to utilize causal commonsense knowledge to enhance semantic links between clauses. To address these limitations, this paper introduces KESIF, a novel emotion–cause pair extraction model that integrates knowledge enhancement with enriched semantic information for improved performance. The proposed model incorporates a graph attention network to capture semantic dependency relationships between sentences, integrates causal commonsense knowledge from the ATOMIC knowledge base to enrich semantic representations, and utilizes a bidirectional MRC mechanism for achieving effective bidirectional matching between emotions and causes. The model’s performance is assessed using core metrics, such as precision, recall, and F1 score. Experimental results on both Chinese and English datasets demonstrate that our method outperforms SOTA baselines.

1. Introduction

Identifying the causes behind emotions is a critical and challenging research topic in sentiment analysis that has received increasing attention in recent years [1]. Early studies primarily focused on the sentence-level emotion–cause extraction (ECE) task, which aims to retrieve cause clauses associated with emotion clauses. However, the ECE task faces limitations in practical applications due to its reliance on emotion annotation. To address this issue, recent research has introduced the emotion–cause pair extraction (ECPE) task [1], which aims to extract potential emotion–cause clause pairs from documents, thus broadening the scope of sentiment analysis applications. As illustrated in Figure 1, in the ECPE corpus example, blue and green clauses represent emotion clauses and cause clauses, respectively. Red phrases indicate commonsense reasoning knowledge (extracted from ATOMIC) associated with each clause. This document contains seven distinct clauses, among which two are emotion clauses: clause c1 (“Weary and agonized”) and clause c7 (“Strong and positive”). For emotion clause c1, the corresponding cause clauses are c2 and c3; for emotion clause c7, the corresponding cause clauses are c5 and c6. The output consists of all emotion–cause pairs in the document: (c1, c2), (c1, c3), (c7, c5), and (c7, c6).

Current research on the emotion–cause pair extraction task faces several critical challenges: the two-stage processing paradigm for subtasks hinders joint optimization, thereby limiting the effectiveness of information interaction and global modeling; most existing methods inadequately capture fine-grained lexical, semantic, and syntactic features—this limitation is particularly prominent in scenarios involving multiple causal relationships; task decomposition and sliding window mechanisms often fail to capture complex relationships, including one-to-many, many-to-one, and long-distance dependencies. As a result, these approaches may provide incomplete coverage and hinder generalization in real-world scenarios.

Most initial methods for the emotion–cause pair extraction task adopted a two-stage processing paradigm to establish associations between emotions and causes. The core logic involves decomposing ECPE into two independent subtasks executed sequentially. The first stage is clause classification, which requires identifying emotion clauses and cause clauses separately in the document. Notably, this stage does not establish any association between emotions and causes. The second stage is pairing and association. Based on the sets of emotion clauses and cause clauses extracted in the first stage, rule-based matching or simple classification models are used to select emotion–cause pairs that conform to causal logic. While this two-stage paradigm reduces the modeling complexity in early tasks, it has become a core bottleneck in subsequent research: on the one hand, the independence of the two stages leads to the direct propagation of classification errors from the first stage to the next, resulting in error accumulation; on the other hand, the optimization objectives of emotion extraction and cause extraction are inconsistent—the former emphasizes emotion word matching, while the latter focuses on causal clue capture), making it impossible to achieve global information interaction, particularly in scenarios involving multiple causal relationships, where pairing accuracy and generalization ability are significantly constrained.

To address these challenges, this paper proposes a knowledge-enhanced and semantic information-fused emotion–cause pair extraction model (KESIF). KESIF leverages ATOMIC knowledge, graph attention, and bidirectional machine reading comprehension to better handle long-distance dependencies and implicit causality. The main contributions of this study are as follows: (1) We propose a commonsense-enhanced semantic representation framework specifically designed for ECPE tasks. This study introduces the ATOMIC commonsense knowledge base, selecting emotion- and intention-related knowledge (xReact, xWant) to enhance clause representations. To address inaccurate knowledge matching, Sentence-BERT calculates semantic similarity between clauses and ATOMIC knowledge tuples, enabling precise retrieval and integration of relevant commonsense for causal reasoning. This design enables the model to recognize implicit causal relationships—a key limitation of traditional models that rely solely on explicit textual clues. (2) A graph attention network (GAT)-based global dependency modeling approach to handle complex inter-clause relationships. The GAT constructs a fully connected clause graph, dynamically adjusting edge weights via attention mechanisms based on contextual distance and commonsense similarity. This enables the model to comprehensively capture global semantic and causal associations among clauses, overcoming the limitations of local context modeling in previous methods. (3) A bidirectional cross-validation mechanism with four custom query types is designed to optimize emotion–cause matching accuracy. This study proposes two reasoning directions (emotion-to-cause and cause-to-emotion) and four query types (static: emotion extraction, cause extraction; dynamic: emotion-specific cause query, cause-specific emotion query) to cover all ECPE reasoning scenarios. This bidirectional framework reduces one-way reasoning bias and significantly improves extraction accuracy for documents with multiple emotion–cause pairs, where traditional models often underperform.

The KESIF model directly targets joint extraction of emotion–cause pairs by fusing the three core components above. This enables global information interaction and semantic modeling and also resolves key issues of error accumulation and mismatched optimization in two-stage tasks, improving the model’s robustness and generalization.

2. Related Work

2.1. Emotion–Cause Extraction

Lee et al. [2] introduced the emotion–cause extraction task, built a dataset, and defined it as a word-level tagging problem. Early studies adopted rule-based [3] and machine learning methods [4]. Chen et al. [5] proposed a clause-level approach. Gui et al. [6] expanded linguistic clues and released a benchmark corpus. In the deep learning era, Li et al. [7] used CNNs and attention mechanisms to optimize extraction by integrating positional information [8]. Xia and Ding [1] proposed the emotion–cause pair extraction (ECPE) task. Early step-wise methods suffered from error propagation. Subsequent end-to-end models [9,10] used ensemble frameworks but struggled to capture context. Hua et al. [11] addressed ECPE challenges in unsupervised domain adaptation. Hu et al. [12] split ECPE into emotion-oriented cause and cause-oriented emotion prediction modules. Recently, rapid NLP advances have seen the rise of large language models (LLMs), such as LLAMA [13], which excel at various NLP tasks [14] in zero- or few-shot settings without parameter updates. Given their power and potential, this paper leverages LLMs to solve ECPE. However, due to the generative paradigm, directly applying large models to information extraction often yields high recall but low precision [15]. Wang et al. [16] constrained prompts to require only one emotion–cause pair as output. This approach fails to achieve satisfactory performance and conflicts with practical requirements. Most LLM-based methods also suffer from large parameter sizes and high inference costs, leaving room to optimize lightweight models for resource-limited scenarios.

2.2. Machine Reading Comprehension

Machine reading comprehension (MRC) focuses on text-based question-answering tasks, with answers presented in diverse formats. Numerous natural language processing tasks have been reformulated as MRC, such as relation extraction [17]. Multi-turn MRC has been applied to entity-relation extraction [18], where multi-turn QA improves handling of complex problems. Li et al. [19] addressed event extraction by framing trigger identification, classification, and argument extraction as multi-turn MRC in a pipeline. Liu et al. [20] explored unsupervised question generation for event extraction. Mao et al. [21] constructed two MRC questions and solved aspect-based sentiment analysis via end-to-end training. Chen et al. [22] proposed a bidirectional MRC framework for aspect sentiment triplet extraction.

2.3. ATOMIC Knowledge Retrieval and Query Formulation

External knowledge is widely used in sentiment analysis. Russo et al. [23] constructed a commonsense knowledge base; Neviarouskaya et al. [24] developed OCC-based rules; Ma et al. [25] used frameworks, lexicons, and knowledge paths for analysis. However, existing methods rely on explicit emotion words, while the ATOMIC knowledge graph demonstrates reasoning advantages in emotion detection [26]. ATOMIC is a large-scale commonsense knowledge base that contains event-centric sociocultural characteristics and “if-then” reasoning tuples. Of its nine relation types, xReact and xWant infer an individual’s emotional state toward a given event. Integrating explicit emotional and intent features, emotional states help detect implicit causal expressions and reasoning clues. Thus, reaction- and intent-type commonsense are extracted for each clause from xReact and xWant in ATOMIC. A common knowledge acquisition approach links events in text to ATOMIC commonsense tuples using matching [27]. Sentence-BERT is designed for clause-level semantic similarity [28]. For each clause, Sentence-BERT matches each event in the knowledge graph, and the corresponding reaction and intent commonsense are adopted as external knowledge for the clause.

As shown in Figure 2, this paper adopts four main query types: emotion extraction, cause identification, linking an emotion to its cause, and identifying the emotion triggered by a given cause. These are grouped into two categories: static and dynamic queries. Static queries use templates that need no target, covering emotion and cause extraction. Dynamic queries combine templates with specific target content, including emotion-specific cause queries and cause-specific emotion queries.

3. Methodology

The architecture of the KESIF model for emotion–cause pair extraction is shown in Figure 3. It includes three parts: a document encoder for contextual representation, a graph attention module for semantic dependency, and a prediction module for joint extraction of emotion–cause pairs.

3.1. Task Definition

In the emotion–cause pair extraction task, the input is a document d containing multiple clauses, $d=[c_1,c_2,\dots ,c_N]$, where each clause $c_i$ consists of multiple words: $c_i=\left[t_1^i,t_2^i,\dots ,t_{n_i}^i\right]$. Here, N denotes the number of clauses in the document, and $n_i$ represents the number of tokens in clause $c_i$, respectively.

The goal of the ECPE task is to extract all clause-level emotion–cause pairs from the document d:

$$\mathbf{P}=\left\{\dots ,(c^e,c^c),\dots \right\}$$

where $c^e$ denotes an emotion clause, and $c^c$ denotes the corresponding cause clause.

3.2. Document Encoding

BERT-Base [29] serves as the base encoder to generate clause representations. By integrating external commonsense knowledge, the model effectively fuses implicit information. For each clause, relevant knowledge is retrieved and concatenated as a third sequence, separated by [SEP] tokens. The query, clause, and this external knowledge are then input into BERT. This third sequence helps BERT produce richer clause representations.

To generate the representation of clause $c_i=\left[t_1^i,t_2^i,\dots ,t_{n_i}^i\right]$, [CLS] and [SEP] tokens are added at the beginning and end of the clause: $\left[\mathtt{CLS}\right],t_1^i{t}_2^i,\dots ,t_{n_i}^i\left[\mathtt{SEP}\right]$. To distinguish different clauses in the document, alternating segment embeddings $(E_A,E_B,E_A,\dots )$ are assigned: clauses at odd positions use $E_A$, while those at even positions use $E_B$.

Semantic similarity between input clauses and all event tuples in ATOMIC is calculated with Sentence-BERT. For each clause, the xReact and xWant knowledge with the highest similarity is retrieved. To ensure knowledge quality and reduce noise, a similarity threshold (0.5 in experiments) is used. If similarity falls below this threshold, the clause is considered to have no highly relevant external knowledge, and no external sequence is introduced; instead, the model then relies solely on the original clause text for encoding.

3.3. Graph Attention Module

The BERT encoder takes the query, document, and ATOMIC external commonsense knowledge as inputs, generating a representation matrix $\mathbf{H}=\{{\mathbf{h}}_{c_0},{\mathbf{h}}_{c_1},\dots ,{\mathbf{h}}_{c_N}\}\in {\mathbb{R}}^{(N+1)\times m}$, where N denotes the number of clauses in the document, and m is the output representation dimension of BERT. Subsequently, a clause graph is constructed based on the representation matrix $\mathbf{H}$ output by the BERT encoder, and a graph attention network is used to model the relationships between clauses. Each clause representation ${\mathbf{h}}_{c_i}$ serves as a node in the graph. A fully connected graph is constructed using contextual distance and commonsense similarity between clauses, with edge weights dynamically computed by an attention mechanism. For each node $c_i$, the GAT updates its representation as follows:

$${\mathbf{z}}_{c_i}=\mathbf{W}{\mathbf{h}}_{c_i}$$

where $\mathbf{W}\in {\mathbb{R}}^{d\times m}$ denotes a learnable weight matrix, and ${\mathbf{z}}_{c_i}\in {\mathbb{R}}^d$ represents the transformed representation of clause $c_i$. The attention coefficient between clause $c_i$ and its neighboring clause $c_j$ is calculated as follows:

$$e_{c_i{c}_j}=\mathrm{LeakyReLU}\left({\mathbf{a}}^T\left[{\mathbf{z}}_{c_i}\oplus {\mathbf{z}}_{c_j}\right]\right)$$

where $\mathbf{a}\in {\mathbb{R}}^{2d}$ denotes the parameter vector of the attention mechanism, the symbol ⊕ represents vector concatenation, and $e_{c_i{c}_j}$ denotes the attention score between clause $c_i$ and clause $c_j$. The normalization of attention coefficients is achieved using the softmax function.

$${\alpha }_{c_i{c}_j}={\displaystyle \frac{exp\left(e_{c_i{c}_j}\right)}{{\sum }_{k\in \mathcal{N}\left(c_i\right)}exp\left(e_{c_{i}k}\right)}}$$

where $\mathcal{N}\left(c_i\right)$ denotes the set of neighboring clauses of $c_i$, and ${\alpha }_{c_i{c}_j}$ represents the normalized attention weight from clause $c_i$ to clause $c_j$. The node representation is updated by aggregating information from neighboring nodes via weighted summation, thereby updating the representation of clause $c_i$ in the l-th graph attention layer:

$${\mathbf{z}}_{c_i}^{\prime \left(l\right)}=\sigma \left(\sum _{j\in \mathcal{N}\left(c_i\right)}{\alpha }_{c_i{c}_j}{\mathbf{W}}^{\left(l\right)}{\mathbf{z}}_{c_j}^{\prime (l-1)}\right)$$

where $\sigma$ denotes the ReLU nonlinear activation function, ${\mathbf{W}}^{\left(l\right)}$ is the learnable weight matrix of the l-th layer, ${\mathbf{z}}_{c_j}^{\prime (l-1)}$ represents the input representation of clause $c_j$ for the l-th layer (the output representation of the $(l-1)$-th layer), and ${\mathbf{z}}_{c_i}^{\prime \left(l\right)}$ denotes the updated representation of clause $c_i$ after processing by the l-th graph attention layer.

By stacking L layers of graph attention networks, the global emotional and causal relationships between clauses are captured incrementally. The output of the l-th layer is formulated as:

$${\mathbf{Z}}^{\left(l\right)}={\mathrm{GAT}}^{\left(l\right)}\left({\mathbf{Z}}^{(l-1)}\right)$$

where ${\mathbf{Z}}^{\left(l\right)}=\left[{\mathbf{z}}_{c_1}^{\prime \left(l\right)};{\mathbf{z}}_{c_2}^{\prime \left(l\right)};\dots ;{\mathbf{z}}_{c_N}^{\prime \left(l\right)}\right]\in {\mathbb{R}}^{N\times d}$ denotes the output representation matrix of the l-th layer (the semicolon indicates vertical stacking of vectors), and ${\mathbf{Z}}^{\left(0\right)}=\mathbf{H}$ (the output of the BERT encoder).

After processing graph attention network layers by L, the final clause representation matrix is obtained:

$$\mathbf{Z}={\mathbf{Z}}^{\left(L\right)}=\left[{\mathbf{z}}_{c_1}^{″};{\mathbf{z}}_{c_2}^{″};\dots ;{\mathbf{z}}_{c_N}^{″}\right]\in {\mathbb{R}}^{N\times d}$$

where ${\mathbf{z}}_{c_i}^{″}={\mathbf{z}}_{c_i}^{\prime \left(L\right)}$ (i.e., the output representation of clause $c_i$ from the L-th graph attention layer) represents the final representation of clause $c_i$, which integrates global semantic information and commonsense knowledge. The clause representations output by the graph attention network (GAT) are then fed into a bidirectional long short-term memory network (BiLSTM) to further optimize the contextual representations of the clauses.

Since the method involves four distinct query types, the corresponding outputs of BiLSTM are represented using the following sets:

$${\mathbf{H}}^e=\left\{{\mathbf{h}}_{c_0}^e,{\mathbf{h}}_{c_1}^e,\dots ,{\mathbf{h}}_{c_N}^e\right\},{\mathbf{H}}^c=\left\{{\mathbf{h}}_{c_0}^c,{\mathbf{h}}_{c_1}^c,\dots ,{\mathbf{h}}_{c_N}^c\right\},$$

$${\mathbf{H}}^{ec}=\left\{{\mathbf{h}}_{c_0}^{ec},{\mathbf{h}}_{c_1}^{ec},\dots ,{\mathbf{h}}_{c_N}^{ec}\right\},{\mathbf{H}}^{ce}=\left\{{\mathbf{h}}_{c_0}^{ce},{\mathbf{h}}_{c_1}^{ce},\dots ,{\mathbf{h}}_{c_N}^{ce}\right\}\in {\mathbb{R}}^{(N+1)\times m},$$

where ${\mathbf{h}}_{c_i}^e,{\mathbf{h}}_{c_i}^c,{\mathbf{h}}_{c_i}^{ec}$, and ${\mathbf{h}}_{c_i}^{ce}$ denote the contextual representations of the i-th clause $c_i$ (corresponding to different query types).

BiLSTM is not used as a standalone sequential model, but as a complement to GAT for two key reasons. First, GAT captures non-sequential global dependencies but may miss temporal order and local context—BiLSTM’s bidirectional propagation compensates for this, preserving linear semantic coherence. Second, compared with complex sequential models (e.g., Transformer variants), BiLSTM is computationally efficient and uses fewer parameters, aiding a balance between performance and inference speed. Integrating BiLSTM also stabilizes performance on long documents, confirming its unique role in robust contextual representation.

3.4. Pair Prediction

After obtaining clause representations, our model predicts the four query types. Although MRC is used in NLP tasks, the bidirectional MRC framework proposed here differs from traditional single-directional designs and shows unique value in ECPE tasks. Unlike existing MRC-based ECPE models focusing solely on “emotion-to-cause” reasoning, our framework covers both “emotion-to-cause” and “cause-to-emotion” directions, enabling cross-validation to reduce false positives from one-way bias. Second, the four query types are tailored to ECPE: emotion and cause extraction queries support candidate screening, while bidirectional association queries focus on pair matching, integrating subtasks with the main task. Third, unlike LLM-based generative MRC methods, our bidirectional MRC framework avoids high inference costs and low precision, and is more compatible with knowledge enhancement and graph modeling, enabling end-to-end optimization of knowledge fusion, dependency modeling, and pair prediction. A bidirectional loss function $L_1$ fusing various loss terms is then used to train the model:

$$L_1=L_{EC}+L_{CE}$$

$$L_{EC}=-\sum _{i=1}^N{y}_i^{e}log\left(p_i^e\right)-\sum _{i=1}^N\sum _{j=L_e}{y}_i^{e{c}_j}log\left(p_i^{e{c}_j}\right)$$

$$L_{CE}=-\sum _{i=1}^N{y}_i^{c}log\left(p_i^c\right)-\sum _{j\in L_c}\sum _{i=1}^N{y}_j^{e{c}_i}log\left(p_i^{e{c}_j}\right)$$

where $y_i^e$ and $p_i^e$ denote the ground-truth label and predicted probability for the emotion query of clause $c_i$; $y_i^{e{c}_j}$ and $p_i^{e{c}_j}$ correspond to the ground-truth label and predicted probability for the emotion-to-cause query (associating emotion clause $c_i$ with cause clause $c_j$); $y_i^c$ and $p_i^c$ represent the ground-truth label and predicted probability for the cause query of clause $c_i$; and $y_j^{e{c}_i}$ and $p_i^{e{c}_j}$ denote the ground-truth label and predicted probability for the cause-to-emotion query (associating cause clause $c_j$ with emotion clause $c_i$).

In training, the second round of machine reading comprehension constructs specific queries using actual emotion and cause clauses. In inference, queries are generated from the previous round’s outputs, causing a distribution mismatch between training and inference. This mismatch introduces exposure bias, which can lead to error accumulation. To address this, we follow [29] and define the loss function $L_2$ as:

$$L_2=-\sum _{j\in {\widehat{L}}^e}\sum _{i=1}^N{y}_i^{e{c}_j}log\left(p_i^{e{c}_j}\right)-\sum _{j\in {\widehat{L}}^c}\sum _{i=1}^N{y}_i^{c{e}_j}log\left(p_i^{c{e}_j}\right)$$

where ${\widehat{L}}^e$ denotes the index set of pseudo-emotion clauses, and ${\widehat{L}}^c$ denotes the index set of pseudo-cause clauses. $y_i^{e{c}_j}$ corresponds to the cause clause $c_i$ under the condition of pseudo-emotion clause $c_j$; correspondingly, $y_i^{c{e}_j}$ represents the emotion clause $c_i$ under the condition of pseudo-cause clause $c_j$.

The final loss of the KESIF model is determined by the sum of $L_1$ and $L_2$:

$$L=L_1+L_2+\lambda {\parallel \theta \parallel }^2$$

where $\lambda$ is the regularization parameter based on the $L_2$ norm, and $\theta$ includes all parameters used in the model. During inference, due to the lack of real emotion and cause clause datasets, we construct second-round MRC queries from first-round results. To integrate the candidate sets, the model uses the Harmonics and Complementary strategies from [29]. After integration, we apply emotion filtering: a valid emotion clause must contain at least one emotion word from the lexicon to ensure extraction accuracy.

4. Experiments

4.1. Datasets and Settings

We conducted experiments on two benchmark datasets: a Chinese dataset [1] and an English dataset [30]. The Chinese dataset consists of 1945 documents collected from SINA city news, while the English dataset contains 2843 documents gathered from novels. Each document in both datasets includes at least one emotion–cause pair. Detailed statistical data are presented in

Table 1. Statistical data of Chinese and English datasets.

Statistical Data	Chinese	English
Number of Documents	1975	2843
Number of Emotion–Cause Pairs	2167	3215
Average Clauses per Document	14.77	7.69
Documents with One Emotion–Cause Pair	1746	2537
Documents with Two Emotion–Cause Pairs	177	256
Documents with More Than Two Emotion–Cause Pairs	22	50

. For the Chinese dataset, we adopted the same data split as used by Xia and Ding [1], and the dataset is split into two parts: 90% for training and the remaining 10% for testing. For the English dataset, we used the same data split as Singh et al. [31], and the dataset is divided into a training/development/test set in a ratio of 8:1:1. To obtain statistically reliable results, we repeated the experiment for 20 rounds and report the average results to ensure robust outcomes across all settings. In the experiments, the BERT-Base model [32] was used, with AdamW as the optimizer and a batch size of 2. The learning rate of BERT was set to $2\times {10}^{-5}$, while the learning rate of other parameters (e.g., BiLSTM and fully connected layers) was $1\times {10}^{-4}$. The hidden layer dimension of BiLSTM was 100, and the $L_2$ regularization coefficient was $1\times {10}^{-5}$. The value of $\alpha$ was set to 0.1. The learning rate adopted a linear warm-up in the first 10% of training steps, followed by linear decay. The training process employed an early stopping strategy, with a maximum of 15 training epochs.

The emotion lexicon ANTUSD [33] and external knowledge ATOMIC-zh [27] were used. This study adopts an emotion classification scheme based on Ekman’s basic emotion model, with a null category designated to represent neutral or non-emotional content. The evaluation metrics included precision (P), recall (R), and F1-score (F1). In addition to the main emotion–cause pair extraction task, the performance of two key subtasks was also evaluated: emotion clause extraction (EE) and cause clause extraction (CE).

4.2. Baselines

Indep [1]: This model first extracts emotions and causes separately in the first step; the extracted emotions and causes are paired in subsequent steps, and invalid emotion–cause pairs are filtered out.

Inter-EC [1]: This model is similar to the Indep model, with the main difference in the first step: the results of emotion extraction are used to assist in improving the performance of cause extraction.

Inter-CE [1]: This model is similar to the Indep model, with the main difference in the first step: the results of cause extraction are used to assist in improving the performance of emotion extraction.

ECPE-2D [9]: This model adopts a joint modeling approach, integrating the representation, interaction, and prediction processes of emotion–cause pairs into a single model.

GANU [34]: This model leverages information at three different levels (word, clause, and document). Its architecture includes a base encoder, a multi-head attention module for processing emotional and causal clues, and a graph attention network with a cross-graph co-attention mechanism; finally, a neural classifier is integrated to implement the prediction function.

RANKCP [10]: This model uses a graph attention network to model the relationships between clauses, then ranks potential emotion–cause pairs to obtain the final results.

GAT-ECPE [35]: This model proposes a knowledge-aware graph network to facilitate interaction between different tasks. It aggregates the features of phrase pairs via an inter-sentence dependency graph and leverages the encoded relationship information to improve the performance of emotion–cause pair extraction.

MMN [36]: This model introduces a modular interaction network, which aims to capture the interactivity in relationships. It consists of a perception encoder, an interaction optimization module, and a double regularization predictor.

MGSAG [25]: This model is a multi-granularity semantic-aware graph model. It enriches clause representations at the semantic level by incorporating emotional information from external emotion lexicons.

JFTA [37]: This model integrates feature encoding and task alignment mechanisms. By synchronously processing the features of emotion pairs and cause pairs, it resolves the inconsistency in label prediction between related tasks, thereby improving the accuracy of emotion–cause pair extraction.

MEKIT [38]: This model is based on an instruction-tuned multi-source heterogeneous knowledge injection method. By integrating internal emotional knowledge and external causal knowledge, it simultaneously enhances the emotion perception and causal reasoning capabilities of LLMs.

LLM-MTLN [39]: The model enhances text representation by fine-tuning a large language model and integrating external knowledge, modeling inter-clause dependencies using a relational graph convolutional network, and achieving multi-task feature sharing and collaborative learning via a partition filtering network.

4.3. Main Results

As shown in

Table 2. Experimental results of Chinese dataset comparison.

Model	Emotion Extraction			Cause Extraction			Emotion–Cause Pair Extraction
	P (%)	R (%)	F1 (%)	P (%)	R (%)	F1 (%)	P (%)	R (%)	F1 (%)
Indep	83.75	80.71	82.10	69.02	56.73	62.05	68.32	50.82	58.18
Inter-EC	83.64	81.07	82.30	70.41	60.83	65.07	67.21	57.05	61.28
Inter-CE	84.94	81.22	83.00	68.09	56.34	61.51	69.02	51.35	59.01
ECPE-2D	86.27	92.21	89.10	73.36	69.34	71.23	72.92	65.44	68.89
GANU	86.34	89.72	87.91	74.10	74.64	74.33	72.95	71.02	71.89
RANKCP	91.23	89.99	90.57	74.61	77.88	76.15	71.19	76.30	73.60
GAT-ECPE	90.98	91.03	90.99	76.17	78.72	77.34	72.65	77.52	74.92
MMN	90.37	87.85	89.07	79.01	75.54	77.21	76.11	73.96	75.02
MGSAG	92.08	92.11	92.09	79.79	74.68	77.12	77.43	73.21	75.21
JFTA	90.13	88.80	89.44	78.78	77.01	77.83	76.41	75.81	76.05
LLM-MTLN	91.24	89.57	90.39	78.45	79.01	78.71	75.18	77.29	76.20
KESIF	96.68	89.91	93.20	78.94	77.96	78.45	82.26	73.45	77.61

, the KESIF model performs excellently in the emotion clause extraction (EE), cause clause extraction (CE), and emotion–cause pair extraction (ECPE), especially in emotion extraction and ECPE, where it outperforms other models. Compared to MGSAG, RANKCP, and GAT-ECPE, KESIF achieves a higher F1, demonstrating superior performance. In the ECPE task, the F1-score of KESIF reaches 77.61%, surpassing most models. Additionally, compared to GAT-ECPE and JFTA, KESIF better balances precision and recall, highlighting stronger generalization in multi-clause emotion–cause pair extraction.

In emotion extraction, KESIF achieves an F1 of 93.20%, outperforming MGSAG (92.09%) and RANKCP (90.57%). Compared to GAT-ECPE and JFTA, it better balances precision and recall, further demonstrating robustness in emotion extraction. Integrating ATOMIC commonsense knowledge and the graph attention network allows KESIF to comprehensively analyze context and semantic associations between clauses, significantly boosting performance in emotion–cause pair tasks.

As shown in

Table 3. Experimental results of English dataset comparison.

Model	Emotion Extraction			Cause Extraction			Emotion–Cause Pair Extraction
	P (%)	R (%)	F1 (%)	P (%)	R (%)	F1 (%)	P (%)	R (%)	F1 (%)
Indep	71.73	68.11	69.66	61.64	51.74	56.11	49.48	40.42	44.32
Inter-EC	70.08	68.85	69.39	63.70	52.45	57.37	49.50	42.72	45.68
Inter-CE	72.38	67.45	69.80	62.53	51.25	56.18	50.27	40.72	44.83
ECPE-2D	74.35	69.68	71.89	64.91	53.53	58.55	60.49	43.84	50.73
RANKCP	61.32	66.17	63.64	54.82	57.32	56.01	44.94	48.32	46.52
MEKIT	–	–	–	–	–	–	65.04	58.31	61.49
KESIF	83.80	73.92	78.55	69.21	59.51	64.00	69.81	66.75	68.02

, MEKIT adopts an instruction-tuned multi-source heterogeneous knowledge injection to integrate internal emotional and external causal knowledge, boosting LLMs’ emotion–cause pair extraction—but with many parameters and high inference cost. With a collaborative framework of knowledge enhancement, graph attention, and bidirectional machine reading comprehension, KESIF ensures strong performance (68.02% on the English dataset) while using fewer parameters and providing faster inference, making it preferable for resource-limited settings. KESIF also excels at handling multi-causal and implicit causal relationships, further proving its effectiveness in emotion–cause pair extraction.

RANKCP adopts a ranking-first coverage strategy, improving recall by keeping more candidate pairs, but its precision is just 71.19%. In contrast, KESIF balances precision and recall via commonsense filtering and bidirectional verification—raising precision to 82.26% with only a slight recall drop (within 3%). This trade-off better suits practical needs (e.g., public opinion sentiment analysis). In summary, KESIF’s strategy offers greater practical value.

4.4. The Impact of the Number of Emotion–Cause Pairs

Since documents with multiple pairs are harder to handle than those with only one, we further examine the impact of emotion–cause pair count on model performance. The test set is split: one subset has documents with a single pair, the other with two or more. As shown in

Table 4. Effect of the number of emotion–cause pairs in documents.

Pairs	Model	P (%)	R (%)	F1 (%)
One per doc	RANKCP	72.32	79.07	75.56
	KESIF	75.12	76.34	75.73
Two or more per doc	RANKCP	67.62	51.46	58.67
	KESIF	72.69	55.02	62.78

, KESIF is compared to RANKCP. KESIF achieves the best results on both subsets, showing it performs well across document types. RANKCP’s recall exceeds KESIF’s for single-pair documents because RANKCP always extracts at least one pair, resulting in high recall but low precision. All models perform worse on documents with two or more pairs than on those with one, indicating that handling multi-pair documents remains a bottleneck for ECPE.

4.5. Ablation Study

As shown in

Table 5. Ablation study on F1 score across ECPE, EE, and CE tasks.

Ablation Study	ECPE	EE	CE
	F1 (%)	F1 (%)	F1 (%)
KESIF	77.42	93.07	76.86
– w/o ATOMIC	72.22	89.08	73.42
– w/o GAT	74.77	92.69	75.98
– w/o Emotion-driven cause	75.15	92.64	74.81
– w/o Cause-driven emotion	75.99	92.36	76.64
– w/o Emotion filtering	77.01	92.50	76.10

, to further assess each component’s impact on emotion–cause pair extraction, we conducted ablation experiments using the F1 metric. These experiments analyze model performance by sequentially removing or replacing key modules: graph attention network, ATOMIC commonsense knowledge, bidirectional extraction (emotion-to-cause and cause-to-emotion), and emotion filtering.

Without ATOMIC, KESIF no longer acquires commonsense knowledge and relies only on query and clause context for emotion–cause pair extraction, causing the F1 to drop from 77.61% to 72.22%. These results show that commonsense knowledge is crucial for understanding clause semantics and capturing causal relationships.

Removing the graph attention network drops the F1-score from 77.61% to 74.77%. The model then relies solely on local information, failing to capture global causal relationships between clauses. This issue is especially evident in cross-clause causal relationship extraction, reducing the accuracy and robustness of extracted emotion–cause pairs.

Removing the emotion-driven cause or cause-driven emotion direction module lowers the F1-score from 77.61% to 75.15% and 75.99%, respectively. The model cannot jointly optimize the bidirectional relationship between emotion and cause. Removing the emotion lexicon reduces the F1-score from 77.61% to 77.01%; the model becomes more susceptible to noise during emotion clause extraction, leading to inaccurate matching between emotion and cause clauses and reducing overall extraction quality. The emotion filtering mechanism significantly improves the accuracy of emotion clause extraction and ensures high-quality emotion–cause pair extraction.

4.6. Case Study

This paper presents a comparative case study, with results shown in

Table 6. Case comparison of emotion–cause pair extraction results between GAT-ECPE and KESIF.

Document	Golden	GAT-ECPE	KESIF
(c1) To rescue the woman as soon as possible
(c2) The commander immediately formulated a rescue plan
(c3) The first team laid an air cushion downstairs
(c4) And evacuated irrelevant personnel around	(c12, c10)	(c12, c10)	(c12, c10)
(c5) Another team quickly climbed to the 6th floor
(c6) To persuade the woman inside the building	(c12, c9)	(c12, c9)	(c12, c9)
(c7) During the persuasion process
(c8) The firefighter learned that	(c12, c11)	(c12, c10)	(c12, c11)
(c9) The woman was owed wages
(c10) The family was in urgent need of money
(c11) The life pressure was very high
(c12) She had to attempt suicide by jumping off the building out of helplessness

, comparing predictions of the GAT-ECPE and KESIF models. The goal is to clearly demonstrate the advantages of the proposed KESIF model by directly comparing the two models’ outputs.

As shown in Table 6, the document has three emotion–cause pairs: $(c_{12},c_9)$, $(c_{12},c_{10})$, and $(c_{12},c_{11})$. The GAT-ECPE model identified two pairs correctly, $(c_{12},c_9)$ and $(c_{12},c_{10})$, but missed $(c_{12},c_{11})$. In contrast, the KESIF model identified all pairs accurately. This shows KESIF better captures causal relationships between emotions and their causes. The GAT-ECPE model’s error may result from biased selection of contextual window clauses, reducing emotion–cause pair extraction accuracy. The KESIF model is more accurate in causal and contextual reasoning, enabling successful extraction of all correct emotion–cause pairs.

To comprehensively evaluate the performance of the proposed model under complex contextual conditions, as shown in

Table 7. Case comparison of emotion–cause pair extraction results between RANKCP and KESIF.

Document	Golden	RANKCP	KESIF
(c1) 18 years ago
(c2) Chengwei Sun killed his uncle
(c3) and then began to flee
(c4) He changed his name and got married	$(c_7,c_2)$	$(c_7,c_6)$	$(c_7,c_2)$
(c5) but he could not escape the law
(c6) He said that for 18 years
(c7) he has been living in fear
(c1) 25 years ago
(c2) my mother went missing
(c3) In April
(c4) I got news from my friends	$(c_6,c_5)$	$(c_6,c_7)$	$(c_6,c_5)$
(c5) and finally found my mother in Henan Province	$(c_7,c_7)$	$(c_7,c_7)$	$(c_7,c_7)$
(c6) In addition to happiness
(c7) I also worry about my mother’s difficulty in settling down

, we conduct comparative analyses with baseline methods, focusing particularly on long-distance dependencies and scenarios with multiple emotion–cause pairs.

The first case shows a long-distance dependency: emotion clause $c_7$ (“he has been living in fear”) is causally linked to the distant cause clause $c_2$ (“Chengwei Sun killed his uncle”). RANKCP’s wrong prediction $(c_7,c_6)$ shows it relies too much on local context and can not handle long-range reasoning. KESIF solves this by using global semantic dependencies via graph attention network (GAT) and adding commonsense knowledge from ATOMIC, correctly finding $(c_7,c_2)$. The second case has intertwined pairs, including an implicit self-cause $(c_7,c_7)$. RANKCP finds $(c_7,c_7)$ but confuses $(c_6,c_5)$ with $(c_6,c_7)$, showing it struggles to tell apart close clauses in multi-pair cases. KESIF’s success at finding both pairs shows its bidirectional MRC and knowledge-augmented representations help with complex, multi-pair documents.

In summary, KESIF shows strong robustness in tough cases—like long-distance dependencies and documents with many emotion–cause pairs—thanks to its commonsense-augmented semantic representation, global dependency modeling, and bidirectional MRC verification. Compared to RANKCP and other baselines, KESIF achieves higher recall and maintains a better balance between precision and recall with commonsense filtering and bidirectional cross-checking, making it more practical for real-world tasks like public opinion analysis.

5. Conclusions

This paper presents an emotion–cause pair extraction model that combines knowledge enhancement and semantic information. Using the ATOMIC knowledge base, the model gives clauses commonsense knowledge about emotions and causes. It addresses causal correlations, strengthens semantic links between clauses, and greatly improves extraction accuracy—especially for long-distance dependencies and implicit causal relationships. The model also uses a graph attention network to efficiently capture causal and knowledge associations among clauses. At the same time, it uses a bidirectional machine reading comprehension (MRC) framework for both emotion-to-cause and cause-to-emotion directions and applies cross-validation to optimize emotion–cause matching and boost model performance. In summary, KESIF advances emotion–cause pair extraction by fusing knowledge enhancement, graph attention networks, and a bidirectional MRC framework. This gives clear advantages for tasks with implicit causality, long-distance dependencies, and multi-clause extraction. Future work may further strengthen knowledge integration, improve computational efficiency, and apply the model to datasets in other languages to broaden its use.