TCDA: Thread-Constrained Discourse-Aware Modeling for Conversational Sentiment Quadruple Analysis

1 Introduction

With the rapid proliferation of online social media and realtime communication platforms, the task of Conversational Aspect-based Sentiment Quadruple Analysis (DiaASQ) [Li et al., 2023] has emerged to meet the growing demand for fine-grained sentiment understanding in conversations. As shown in Figure 1 and Table 1, the goal of DiaASQ is to automatically extract all existing sentiment quadruples (t, a, o, s) from the given multi-round conversation. In this formulation, target t (the object of discussion), aspect a (the specific attribute of the target) and opinion o (the subjective expression about the aspect) correspond to specific To capture the structural details of the conversation, DMIN [Huang et al., 2024] introduced the concept of "discourse thread structure". As shown in Figure 1, the conversation has a highly structured feature, consisting of multiple utterances and their corresponding speakers. These utterances can be decomposed into different semantic threads [Li et al., 2024b; Vedula et al., 2023]. Under this framework, except for the root node, each utterance is closely related to a specific response target, forming a tree-like topological dependency relationship. This complex interaction pattern implies that the flow of sentiment is not only limited by the sequential arrangement of words but also by the topological structure of the conversation. Although the introduction of the thread structure has brought about performance improvements, the existing methods still have difficulty fully leveraging these complex dependencies. Specifically, current models [Li et al., 2024a; Tong et al., 2025; Huang et al., 2024] typically use a general Graph Neural Networks (GCN) to handle the conversation structure, treating the reply-to relations as a simple edge [Schlichtkrull et al., 2018; Veliˇckovi´c et al., 2018]. However, current paradigms usually have two limitations. Firstly, they ignore the semantic isolation between independent threads, inevitably introducing structural noise from irrelevant threads. Secondly, they treat the dynamic conversation as a static graph structure, ignoring the natural temporal order and different speaker identities in the utterances. This failure to implement sequential and speaker-sensitive constraints results in the complex interaction between local context and overall discourse logic not being fully explored [Li et al., 2025].

∗Corresponding author.

To capture the relative distances between sentiment elements, Rotary Position Embedding (RoPE) [Su et al., 2024] has been widely adopted in recent DiaASQ frameworks [Li et al., 2023; Huang et al., 2024; Li et al., 2024a]. However, existing implementations typically employ a fragmented and cumulative strategy, often restricting entity extraction to the local token context, or simply adding separate attention scores from the token and utterance levels. This token-based modeling introduces a key issue, which we call Distance Dilution: in multi-round conversations, verbose utterances expand the distance between logically adjacent turns (e.g., a Q&A pair separated by 50+ tokens). Under high-frequency RoPE rotations, this expanded distance causes the positional correlation to decay prematurely, cutting off semantic connections. Therefore, these mechanisms are difficult to balance both the high sensitivity to local syntax and the longterm retention ability for the global discourse simultaneously.

To address these challenges, we propose the TCDA framework, which integrates explicit topological structure and implicit positioning. Firstly, we introduce the Thread Constraint Directed Acyclic Graph (TC-DAG) to construct an accurate dialogue structure model. Unlike general GCNs that indiscriminately propagate information, TC-DAG sets strict thread-level boundaries. This design effectively suppresses structural noise from irrelevant branches while retaining the logical evolution from the root node to the leaf nodes. Secondly, we propose Discourse-Aware Rotary Position Embedding (D-RoPE) to alleviate the Distance Dilution and overcome the limitations of additive modeling. Unlike the standard encoding method that loosely couples local and global features through linear superposition, D-RoPE constructs a joint semantic-structural embedding. It projects tokens and utterances to independent subspaces and applies topologyadaptive coordinate transformation. This mechanism ensures that fine lexical cues and coarse discourse logic can be deeply integrated before the interaction, enabling accurate interpretation of cross-turn dependencies, regardless of intervening verbosity.

Our contributions can be summarized as follows:

• We propose the Thread Constraint Directed Acyclic Graph (TC-DAG), which employs intra-thread constraints and a fixed root mechanism to suppress structural noise while preserving logical coherence.
• We introduce Discourse-Aware Rotary Position Embedding (D-RoPE), featuring dual-stream projections that decouple micro- and macro-semantics to mitigate distance dilution and align multi-scale distances.
• TCDA achieves SOTA performance. Our code is available at https://github.com/LiXinran6/TCDA.

2 RelatedWork

2.1 Aspect-Based Sentiment Analysis

Early studies on ABSA mainly focused on simple, isolated sentences with a single structure. Initially, they concentrated on single-element tasks such as aspect extraction [Li et al., 2018] and polarity classification [Li et al., 2021]. To obtain more comprehensive sentiment information, subsequent research shifted to compound tasks, including Aspect-Opinion Pair (AOPE) [Wu et al., 2021] and Triplet Extraction (ASTE) [Chen et al., 2022a; Zhao et al., 2024], which aim to jointly identify aspect terms, opinion terms, and their corresponding polarities. Recently, to provide a comprehensive sentiment picture, the research focus has shifted to Aspect Sentiment Quadruple Prediction (ASQP) [Zhang et al., 2021]. This task extracts the complete (a, c, o, s) quadruple using predefined aspect categories c.

2.2 Conversational Aspect-Based Sentiment Quadruple Analysis

Although the traditional ABSA benchmarks mainly focus on sentence-level [Pontiki et al., 2014; Pontiki et al., 2016], they limit the applicability of existing methods in multi-turn conversation scenarios [Zhang et al., 2023]. To bridge this gap, the DiaASQ task was introduced [Li et al., 2023], which employs three parallel attention matrices to explicitly capture the complex inter-utterance correlations. Subsequently, numerous studies further explored this task from different structural perspectives.

H2DT [Li et al., 2024a] employs a heterogeneous attention network and a ternary scorer to enhance the cohesion of quadruples, while DMCA [Li et al., 2024b] and ICMSR [Zhang et al., 2025b] both utilize a multi-scale mechanism - specifically, windows and the SMM module - to capture long-range dependencies and structural features. Specifically, DMIN [Huang et al., 2024] is the first to use GCN and multi-granularity integration to incorporate thread structure, enabling token interactions to match the utterance-level discourse. Although CA-DAGNet [Zhang et al., 2025a] constructs a Directed Acyclic Graph [Thost and Chen, 2021; Shen et al., 2021] to capture cross-utterance dependencies, it ignores the inherent thread-based topological constraints. Additionally, recent frameworks [Li et al., 2023; Li et al., 2024a] have integrated RoPE [Su et al., 2024] to encode relative distances within the conversational tree. However, these RoPE implementations are typically limited to encoding the local token context or adopting a fragmented strategy of simple linear superposition, which ignores the differences in frequency scales and cannot alleviate the Distance Dilution caused by verbose utterances.

3 Methodology

We propose TCDA, which combines TC-DAG and D-RoPE. Its overall architecture is shown in Figure 2.

3.1 ProblemDefinition

In the DiaASQ task, each conversation is represented as D = {u1, u2, . . . , un}, along with the reply index set R = {l1, l2, . . . , ln} and the speaker sequence S = {s1, s2, . . . , sn}. Here, li indicates that the utterance ui is a direct response to uli . Each utterance ui = {w1, . . . , wmi } consists of mi tokens.

Following the grid tagging framework [Li et al., 2023; Huang et al., 2024], we rephrase the extraction of the quadruple as a unified relation tagging problem. For any pair of words (wa, wb) in the flattened dialogue, the model is trained to identify three types of semantic connections:

• Entity Boundaries (yent ∈ {TGT, ASP, OPI}): These labels define the corresponding range by connecting the start and end tokens of the target, aspect, and opinion. For example, the TGT association from "iPhone" to "14" will identify "iPhone 14" as a target entity.
• Entity Alignment (ypair ∈ {H2H, T2T}): These relationships link different entities together. Specifically, head-to-head (H2H) and tail-to-tail (T2T) tags are used to pair the entities, for example, associating the target "iPhone 14" with its corresponding aspect "battery life".
• Sentiment Polarity (ypol ∈ {POS, NEG, NEU}): This value indicates the sentiment tendency (positive, negative, or neutral) between the related entities.

For each sub-task, if there is no specific relationship between these tokens, a special label other will be assigned to it.

3.2 Textual Feature Extraction

Inspired by DMIN [Huang et al., 2024], each conversation is divided into multiple threads Tk = {u′1 , u′i , u′i+1 , . . . , u′j }, starting from a common root node u′1 , to balance the context window limit on PLM and the discourse interaction. As shown in Figure 1, threads are arranged in sequence and only cross at the root node. Each utterance is formatted as u′i = {[CLS], ui, si} to incorporate speaker information. The encoding form at the thread level is:

where Hu′ i = {hcls i ,Hu i , hsi } contains token features Hu i ∈ Rmi×d .

3.3 Dual-scale Contextual Encoding

To simultaneously capture fine-grained semantic cues and coarse-grained discourse structure, we propose a dual-scale encoding framework. This module refines the text representation by performing knowledge enhancement at the thread level and discourse modeling at the conversation level.

Token-level Knowledge Encoding. In order to strike a balance between global and local interactions within the PLM context window, we first perform knowledge enhancement within each individual thread Tk. Following [Huang et al., 2024], we employ a structure called Concrete Knowledge Encoder (CKEncoder), which consists of parallel Syntactic and Semantic GCNs [Kipf and Welling, 2016; Chen et al., 2022b; Zhang et al., 2022; Vaswani et al., 2017]. Specifically, we extract local knowledge features ˜HTk based solely on the thread-specific context to filter out cross-thread noise:

where Asyn and Asem respectively represent the thread-level syntactic and semantic adjacency matrices. Subsequently, we aggregate the original features HTk and the knowledge features ˜HTk from all threads to reconstruct their global corresponding features Htok and ˜Htok (by averaging the shared root node u′1 ). The final enhanced token representation H′ tok is obtained through global residual connections and layer normalization:

Utterance-level Discourse Modeling. Meanwhile, we abstract the original global token-level feature Htok into an utterance-level representation Hutt = {h1, . . . , hn} through a Top-K aggregator [Huang et al., 2024]. These representations can capture the flow of the conversation, but require powerful structural modeling. Unlike the previous methods that used fully connected graphs, we process Hutt using a Thread-Constrained DAG (TC-DAG) to strictly follow the temporal order and replying topology of the conversation. For more details, please refer to Section 3.4.

3.4 Thread-Constrained DAG

To strictly adhere to the dialogue structure and filter out irrelevant information, we propose the Thread-Constrained Directed Acyclic Graph (TC-DAG), which is represented as G = (V, E,R). Here, V represents the utterances, and there is a directed edge (uj → ui) only when j < i. The relation set R = {0, 1} indicates whether the connected nodes were uttered by the same speaker.

Constructing a Graph through Conversation

A thread refers to a sequence within a local conversation branch. To filter out structural noise, TC-DAG employs a retrospective strategy to limit the connection range of edges to be within these threads: each node is connected to the previous utterance that covers ω instances from the same speaker, including all intermediate background information. To ensure global connectivity, when reaching the thread boundary within the window, the connection extends to the root node u1. This process organizes the conversation into a tree-like DAG (see Figure 3 and Algorithm 1).

Structure-Aware Relational Encoding

Based on the constructed TC-DAG and the initial utterance feature Hutt, we use a relational GNN to propagate context information along the topological structure. Unlike the standard GNNs, which uniformly aggregates neighbors, our model specifically considers the sequential nature of the conversation and the different dependency types defined in R. Let h(l) i represent the hidden state of utterance ui in the lth layer, where the input state h(0) i corresponds to the vector hi ∈ Hutt. Since the DAG is strictly arranged in chronological order, we update the nodes from i = 1 to n sequentially. This ensures that when calculating ui, the updated states h(l) j of all predecessor utterances uj ∈ Ni (where j < i) are already available.

For a specific node ui, the information aggregation is computed via a relation-aware attention mechanism. The attention coefficient α(l) ij for a neighbor uj ∈ Ni is calculated as:

where ∥ denotes concatenation. The context vector m(l) i is then derived by:

where W(l) rij ∈ {W(l) 0 ,W(l) 1 } is a relation-specific projection matrix selected based on whether ui and uj share the same speaker (rij ∈ R). This allows the model to differentially weigh intra-speaker and inter-speaker dependencies.

In order to effectively integrate the aggregated contextual information with the node's own historical records, we adopt a dual gated update mechanism [Shen et al., 2021]. Specifically, we employ two parallel GRU units to capture complementary information flows. The node update unit (GRUH) uses the context as guidance to update the node's state, while

Algorithm 1 Building a Thread-Constrained DAG

Require: Dialogue {u1, . . . , uN}, speaker P(·), thread

mapping T (·), window size ω. Ensure: Graph G = (V, E,R). 1: V ← {u1, . . . , uN}, E ← ∅, R ← {0, 1} 2: for i = 2 to N do 3: c ← 0, τ ← i -1 4: Si ← Start index of thread T(ui) 5: while τ ≥ Si and c < ω do 6: r ← (P(uτ ) = P(ui))?1 : 0 7: E ← E ∪ {(uτ , ui, r)} 8: if r = 1 then 9: c ← c + 1 10: end if 11: τ ← τ -1 12: end while 13: if c < ω and Si > 1 then 14: r ← (P(u1) = P(ui))?1 : 0 15: E ← E ∪ {(u1, ui, r)} 16: end if 17: end for 18: return G = (V, E,R)

the context update unit (GRUC) models the evolution of the context:

Here, the inputs and hidden states are logically swapped between the two GRUs to maximize feature interaction. Finally, the updated representation for node ui at layer l is obtained by summing the outputs:

Finally, we extract the node states H(L) utt = {h(L) 1 , . . . , h(L) n } from the last layer L and apply a residual connection followed by layer normalization to yield the final global representations:

3.5 Global-Local Interaction and Discourse-Aware Position Encoding

After obtaining the global structure-aware representation H′utt through the TC-DAG module, our aim is to reintegrate this global background information into the token-level features and enhance the position sensitivity.

Global-Local Interaction

To bridge the gap between the coarse-grained discourse structure and the fine-grained token features, we employ the crossattention mechanism. Token representation H′ tok is used as the query, while the global utterance representation H′utt serves as the key and value, enabling tokens to focus on the relevant discourse context and generate the comprehensive representation Hf inal .

Algorithm 2 D-RoPE-Enhanced Attention

Require: Queries/Keys Q,K for tok/utt; Indices Ptok, Putt. Ensure: Score matrix S.

• 1: Projection: Vmic/mac ← Linearmic/mac(Vtok/utt ) for V ∈ {Q, K}
• 2: Coordinate Transform: For pair (i, j), let σij = -1 if threads diverge else 1. Set ˆ p(j) ← σijP (j) .
• 3: Dual-Scale Rotation:
• 4: ˜qi ←Concat(R(qmic i , P (i) tok ), R(qmac i , P (i) utt ))
• 5: ˜kj ←Concat(R(kmic j , ˆ p(j) tok ), R(kmac j , ˆ p(j) utt ))
• 6: return S where Sij = ˜q⊤i ˜kj

Discourse-Aware Rotary Position Embedding (D-RoPE)

To alleviate the inherent Distance Dilution phenomenon in the RoPE strategy, our D-RoPE method explicitly separates the semantic granularity into independent subspaces and fuses them before interaction.

Dual-Scale Semantic-Structural Projection. We decompose the integrated representation Hfinal into parallel tokens ( htok ) and utterances ( hutt ) streams, and then project them onto separate subspaces:

whereWmic andWmac are learnable matrices that separate local syntactic cues from the global discourse semantics.

Topology-Adaptive Rotary Encoding. We employ RoPE method with different base frequencies to encode the topological structure. While maintaining the standard relative position property ˜q⊤˜k = q⊤R(pq - pk)k, we introduce a Topology-Adaptive Coordinate Transformation that is applicable at both the micro and macro levels:

1. Micro-RoPE (Token Level): With a standard frequency θmic = 10000, we define the token index ptok as the cumulative topological distance starting from the global root node [Li et al., 2023]. To make the subtraction mechanism of RoPE compatible with the addition distance (i.e., p(i) tok +p(j) tok between different branch threads), we apply the coordinate sign inversion:

This transformation enables R(p(i) tok -ˆ p(j) tok ) to accurately encode the topological path lengths between different threads, while preserving the linear relative distances within the same thread.

1. Macro RoPE (Utterance Level): Relying solely on token indexing can lead to distance dilution, where verbose utterances increase the distance and disrupt the semantic connections under high-frequency rotation. To alleviate this, we introduce Macro-RoPE, using utterance-level index putt, with the base frequency θmac = 100 reduced. This transformation preserves strong attention on logical dependencies:

This ensures constant turn-level distances, serving as a robust discourse anchor.

Fusion. We construct a unified feature vector by concatenating the rotation embeddings of the two subspaces:

Here, [· ∥ ·] represents concatenation. Then, the topological adaptive score is calculated through the dot product:

This ensures dual-scale semantic and positional consistency.

3.6 Quadruple Decoding and Learning

To isolate the semantic influence, we project the Hfinal item into three task-specific spaces (Sent, Srel, Spol). We apply DRoPE to each grid g to derive topology-adaptive probabilities by Softmax:

We minimize weighted cross-entropy loss:

where yg ij represents the true label, while αg ij denotes the category weight.

4 Experiments and Analysis

4.1 Dataset and Implementation Details

Dataset. We conduct experiments on the Chinese (ZH) and English (EN) datasets [Li et al., 2023]. The detailed statistics are presented in Table 2.

Implementation Details. Following existing methods, we use RoBERTa-Large [Liu et al., 2019] and ChineseRoBERTa-wwm-ext-base [Cui et al., 2019] as backbones for EN and ZH, with Top-K ratios λ of 0.5 and 0.8, respectively. Both syntactic and semantic GCNs consist of 3 layers, while the TC-DAG has 2 layers. We employ a sliding window of size w = 3. We train with a batch size of 2 and a 0.1 dropout rate. The AdamW optimizer is used with learning rates of 1e5 for PLMs and 1e-4 for other parameters. All experiments are conducted on a single NVIDIA GeForce RTX 4090 GPU. All results, including baseline comparisons and ablation studies, are reported as the average of five independent runs to ensure statistical significance.

4.2 Baselines

We compare TCDA against several state-of-the-art baselines: MVQPN [Li et al., 2023] (the pioneering grid-tagging baseline), H2DT [Li et al., 2024a], DMCA [Li et al., 2024b], DMIN [Huang et al., 2024], CA-DAGNet [Zhang et al., 2025a], IFusionQuad [Jiang et al., 2025] and ICMSR [Zhang et al., 2025b].

4.3 Main Results

Table 3 shows that TCDA achieves SOTA or competitive performance across all benchmarks.

4.4 Ablation Study

To assess the contribution of each component, we compare TCDA with three variants: (1) w/o TC-DAG, replacing the thread-constrained topology with the standard reply-based GCN; (2) w/o D-RoPE, replacing the Discourse-Aware positioning with the standard RoPE; (3) w/o Both, removing both modules.

Table 4 shows that removing any component degrades performance, with the sharpest decline when both are absent. This confirms that TC-DAG and D-RoPE provide complementary benefits in filtering noise and addressing distance dilution.

4.5 Further Analysis

Parameter Sensitivity. We investigate the impact of the TC-DAG layer L and the speaker window size w on the performance, as shown in Table 5. All other hyperparameters (including the standard RoPE baseline values) are kept constant to ensure the fairness of the comparison.

The best performance can be achieved when L = 2, and increasing L can lead to a decrease in performance due to the over-smoothing effect. Dense connection (w ≥ 2) is always superior to sparse connection (w = 1), as it can facilitate direct information transmission from the root sentence to subsequent nodes, thereby maintaining the overall discourse intention in the case of long-distance attenuation. Performance saturates at w ≥ 2 as the window size often exceeds the actual thread length.

Generality of D-RoPE. To verify the universality of DRoPE, we replace the standard RoPE with our D-RoPE in the competitive benchmark models (i.e., MVQPN and DMIN). As shown in Table 6, D-RoPE consistently improves performance across different architectures and languages. Notably, for MVQPN, its micro F1 value increases by 1.84% on the ZH dataset and 0.80% on the EN dataset. This significant improvement indicates that D-RoPE effectively overcomes the limitations of the base model in capturing multi-scale positional dependencies. Moreover, the continuous improvement of DMIN further confirms that D-RoPE is a robust, modelindependent plugin that can alleviate the Distance Dilution problem.

Effectiveness of TC-DAG Structure. As shown in Table 7, to verify the necessity of our topological consistency design, we compare the proposed TC-DAG with two structural variants: (1) Reply-GCN, which only builds an undirected graph based on reply dependencies, ignoring speaker relationships and directionality; (2) Standard DAG, which follows the chronological order and distinguishes edges by speakers. We use the standard RoPE method in all variants.

Without thread isolation (standard DAG), unrelated thread interference degrades performance below the reply-GCN baseline on the EN dataset. Conversely, TC-DAG eliminates this interference by integrating chronological order with strict topology, achieving superior results across all metrics.

5 Conclusion

We propose the TCDA framework to address the structural noise and scale mismatch issues in DiaASQ. We introduce TC-DAG to filter out irrelevant branches by implementing topological constraints, and introduce D-RoPE to solve the Distance Dilution by aligning the semantic granularity with the hierarchical structure of the separated subspace. TCDA achieves SOTA results in two benchmarks. The generalization ability of D-RoPE further highlights its potential as a model-agnostic plugin suitable for a wider range of multi-turn dialogue tasks.

Acknowledgments

This work was supported by the National Natural Science Foundation of China Project (No. 62372078).