Dialogue Summarization with Static-Dynamic Structure Fusion Graph
Year: 2023

Abstract:
Dialogue summarization, one of the most challenging and intriguing text summarization tasks, has attracted increasing attention in recent years. Since dialogue possesses dynamic interaction nature and presumably inconsistent information flow scattered across multiple utterances by different interlocutors, many researchers address this task by modeling dialogue with pre-computed static graph structure using external linguistic toolkits. However, such methods heavily depend on the reliability of external tools and the static graph construction is disjoint with the graph representation learning phase, which could not make the graph dynamically adapt to the downstream summarization task. In this paper, we propose a Static-Dynamic graph-based Dialogue Summarization model (SDDS)*, which fuses prior knowledge from human expertise and implicit knowledge from a PLM, and adaptively adjusts the graph weight, and learns the graph structure in an end-to-end learning fashion from the supervision of summarization task. To verify the effectiveness of SDDS, we conduct extensive experiments on three benchmark datasets (SAMSum, MediaSum, and DialogSum) and observe significant improvement over strong baselines.

heading: 1 Introduction
text: Dialogue summarization, aiming at distilling the salient information from a dialogue context into a concise summary, is one of the most challenging and intriguing tasks in text summarization (Gurevych and Strube, 2004; Feng et al., 2021a; Cheng et al., 2023a). It can help people quickly capture the highlights of a semi-structured and multi-participant dialogue without reviewing the complex dialogue context (Feng et al., 2022)
*The first two authors contributed equally. †Corresponding Author. *Code available at https://github.com/Hannibal046/
SDDS
and has many real-world applications (Liu et al., 2019; Zhang et al., 2021).
Since dialogue is the most fundamental and specially privileged arena of language (Jurafsky and Martin, 2000), it possesses dynamic interaction nature and presumably inconsistent information flow scattered across multiple utterances by different interlocutors (Li et al., 2022). So the plain document summarization methods (Gehrmann et al., 2018; Zhang et al., 2020a) could not adapt well in this setting. As shown in Figure 1, the plain text summarization method takes dialogue as a long sequence without modeling its structure thus can not generate a proper summary.
To address this problem, the existing dialogue summarization methods mainly focus on modeling dialogue with pre-computed static graph structure using external linguistic toolkits such as discourse parsing (Chen and Yang, 2021; Feng et al., 2021a), dialogue topic modeling (Chen and Yang, 2020; Zhao et al., 2020), dialogue state tracking (Zhao et al., 2021b) and dialogue acts modeling (Goo and Chen, 2018; Chen and Yang, 2021). Although static graph structure captures inconsistent information flow of dialogue to some extent and achieves
13858
sufficient improvements across various datasets, we argue that there exist two fundamental drawbacks: (1) such methods heavily depend on the reliability of external linguistic tools which may not deliver the accurate output and cause error propagation. For example, the commonly used discourse parser in dialogue summarization (Chen and Yang, 2021; Feng et al., 2021a) is a trained model from Shi and Huang (2019), which is optimized for a dialogue summarization-agnostic online game dialogue dataset. This distribution shift may greatly hurt the generalization ability of the parser (Qian and Yu, 2019). (2) the static graph construction is disjoint with the graph representation learning phase and such a fixed graph could not dynamically adapt to the downstream summarization task.
In this paper, we propose the Static-Dynamic graph-based Dialogue Summarization model (SDDS) which contains two graph modules: (1) Static Graph Module and (2) Dynamic Graph Module. For the static graph module, we consider four dialogue structures. Except for the commonly used (1) discourse parsing and (2) keywords cooccurrence relationship, we propose two novel structure modeling methods: (3) speaker relationship and (4) utterance position modeling.
Complementary to these four static graphs that encode human prior into the model, we propose a dynamic graph module that is constructed from a pre-trained language model (PLM). The language model pre-trained on the massive corpora captures oceans of knowledge without human annotation (Warstadt et al., 2019) and shows strong capability in modeling the various textual relationships (Lyu et al., 2021; Chen et al., 2021a). Thus, we propose to use the deep semantic representation for utterances obtained from the PLM to learn the various utterance and speaker relationships. By fusing prior knowledge from human expertise and implicit knowledge from a PLM with a fine-grained 1× 1 convolution, SDDS could adaptively adjust the graph weight and learn the graph structure in an end-to-end learning fashion from the supervision of summarization task.
Figure 1 shows the overall architecture of the SDDS model. First, we employ a pre-trained language model to encode all the utterances into vector representations. Next, we construct four static graphs and propose an early fusion method to combine these static graphs. Then, a dynamic graph module is used to learn the semantic relationships
using utterance vector representations. Finally, we propose a fusion mechanism to combine the static and dynamic graphs into a unified representation and employ a pre-trained language model to generate the summary by incorporating the updated utterance representation of the combined graph. To verify SDDS, we conduct extensive experiments on three benchmark datasets. Experimental results demonstrate that the SDDS achieves substantial improvement over strong baselines. We also carefully examine each key component and gives a detailed analysis of SDDS for future research.
To sum up, our key contributions are: • We are the first to take a deep look into the limitation of the current static graph-based methods. • We propose a novel framework called SDDS which fuses prior knowledge from human expertise and implicit knowledge from a PLM, adaptively adjusts the graph weight, and learns the graph structure in an end-to-end learning fashion from the supervision of summarization task. • Comprehensive experiments conducted on three benchmark datasets show SDDS achieves significant improvement over strong baselines.

heading: 2 Related Work

heading: 2.1 Dialogue Summarization
text: Recent research works in dialogue summarization can be classified into two categories. Since this research task is a newly proposed task, the first category of works focuses on exploring new datasets. AMI (Carletta and et al., 2005) and ICSI (Janin and et al., 2003) corpus are meeting summarization datasets which contain 57 and 137 data samples respectively. To train the neural-based summarization model, researchers also propose several largescale datasets. SAMSum (Gliwa et al., 2019) is a large-scale chit-chat summarization dataset with 14,732 training samples, and most of the samples are two-party dialog with a 2.2 average speaker. MediaSum (Zhu et al., 2021) is a multi-party dialogue summarization dataset collected from news interviews with 463K data samples and 6.5 average speakers.
The second category of research works proposes to incorporate manifold information to help the dialogue summarization. Feng et al. (2021a) and Chen and Yang (2020) propose using a discourse parsing tool or heuristic structure extraction method to help the model capture the dialogue structures. These methods leverage the graph model to capture the di-
alogue structure and they focus on the algorithm of passing messages between utterance nodes in their methods. Feng et al. (2021b) propose to extract the keyword, topic, and redundancy utterances by using DialoGPT and incorporate this manifold information in the summary generation process. Feng et al. (2020) propose using large-scale commonsense knowledge to facilitate dialogue understanding and summary generation. Geng et al. (2022b) propose three speaker-aware supervised contrastive learning tasks to recognize the unique format of the speaker-utterance pair. Ravaut et al. (2022) fuse several summary candidates to produce a novel abstractive second-stage summary. Li et al. (2022) propose a novel curriculum-based prompt learning method with self-training to tackle the insufficient training data problem. Li et al. (2023) propose to learn disentangled representation via domain adaptation for dialogue summarization tasks.

heading: 2.2 Graph Neural Network
text: Graph is widely used in many structure data modeling tasks: recommendation (Liu et al., 2020; Jiang et al., 2018; Fan et al., 2019a), social network modeling (Wu et al., 2019a; Fan et al., 2019b; Yang et al., 2020), and knowledge-graph based tasks (Jiang and Han, 2020; Wu et al., 2019b). In the document summarization task, many existing works (Tan et al., 2017; Wang et al., 2020) employ the graph model to capture the document structures and incorporate this structure into abstractive or extractive summarization. Wei (2012) proposes a heterogeneous graph consisting of topic, word and sentence nodes and uses the markov chain model for the iterative update. Tan et al. (2017) HSG (Wang et al., 2020) employs a heterogeneous graph network to model the words and sentences with in single and multi-documents and then extracts sentences from document. In the dialogue summarization field, using a graph network to modeling the dialogue structure is also a common practice. However, most of the existing works (Feng et al., 2020, 2021a) use the pre-computed graph to capture the dialogue structure and focus on the algorithm of passing messages between utterance nodes in their methods.

heading: 3 Problem Formulation
text: Given a dialogue context D = {u1, · · · , uLd} with Ld utterances and each utterance ui = {wi,1, · · · , wi,Liu} contains Liu words. We use the
si to denote the speaker of i-th utterance and |S| to denote the number of speakers. Our goal is to generate the summary Ŷ = {ŷ1, · · · , ŷLy} which has Ly words. And we use the difference between generated summary Ŷ and the ground truth Y as the training objective.

heading: 4 SDDS Model
text: In this section, we introduce the Static-Dynamic graph based Dialogue Summarization model (SDDS). An overview is shown in Figure 2.

heading: 4.1 Utterance Encoder
text: We employ the pre-trained BART (Lewis et al., 2020) to encode each utterance independently:
{hi,0,hi,1, · · · ,hi,Liu} = Enc([CLS], wi,1, · · · , wi,Liu), (1)
where Enc(·) is the encoder module in BART which outputs the vector representation hi,j of j-th input word wi,j in i-th utterance. To obtain a vector representation of each utterance, we extract the hidden state hi,0 of the input special token [CLS] as the vector representation ui = hi,0 of i-th utterance. And U = {u1, . . . ,uLd} are the representations for all utterances.

heading: 4.2 Static Graph Construction
text: In this section, we first propose 4 heuristic dialogue structure modeling methods to build the relationships between utterances using a graph network.
1. Discourse Parsing Graph. Since dialogue discourse relations can explicitly show the information flow and interaction between utterance (Feng et al., 2021a), we employ a discourse parsing toolkit (Shi and Huang, 2019) to build dependency-based dialogue structure which allows relations between non-adjacent utterances which is applicable for multi-party conversions. There are 16 discourse relations in total: comment, clarification-question, elaboration, acknowledgment, continuation, explanation, conditional, question-answer, alternation, question-elaboration, result, background, narration, correction, parallel, and contrast. After obtaining the discourse parsing result, we use an embedding matrix to project these discreate relations into vector representation:
Gsd(i, j) = Ed (DiscoParse(ui, uj)) , (2)
where Ed ∈ R16,1 denotes the embedding matrix.
2. Keywords Co-occurrence Graph. It is intuitive that when two utterances contain the same keyword, they may focus on the same topic and they are semantically correlated. We employ the function KeyCo-occ to denote the function that calculates the number of common keywords in two utterances.Then we use an embedding matrix to project the integer number of keyword co-occurrence to a vector:
Gsk(i, j) = Ek (KeyCo-occ(ui, uj)) , (3)
where Ek ∈ RNk,1 denotes the embedding matrix, and Nk and D denotes the maximum number of co-occurrence keyword and the hidden size respectively. In this paper, we only use the noun and entity words as the keyword. 3. Speaker Relation Graph. Since it is essential to understand the fine-grained interaction between speakers in dialogue context, in this paper, we propose a simple yet effective speaker relationship modeling method. We use a sliding window around each utterance, and count the frequency of occurrence for each speaker in this sliding window, and the obtain a speaker interaction frequency matrix Ĝss ∈ N|S|,|S|. Intuitively, if an element in Ĝss achieves the relatively high value in both row-wise and column-wise, that means the speakers of the row and column have a strong relationship compared to other speakers. For example, in Figure 4, we can find that speaker C usually talks after A, which indicates the strong relationship between two speakers. Thus, to normalize the frequency
of interaction between speakers, we first apply the row-wise softmax on the interaction frequency matrix Ĝss and then apply column-wise softmax on Ĝss independently. Next, we apply the element-wise product and result in the final speaker relation matrix G̃ss ∈ R|S|,|S|:
G̃ss = softmaxr(Ĝss)× softmaxc(Ĝss), (4) where softmaxr and softmaxc denotes the row-wise and column-wise softmax function respectively. For example, when speaker C usually talks after A, which indicates the strong relationship between two speakers, and we can find that the value between speaker A and C achieves the highest value in the G̃ss . Finally, we fill the utterance-level speaker relation adjacent matrix Gss ∈ RLd,Ld using the value in G̃ss :
Gss(i, j) = G̃ss(si, sj), (5)
where G̃ss(si, sj) ∈ R denotes the value in si-th row and sj column. More details can be found in the Appendix § A.1. 4. Utterance Position Graph. To capture the position information of utterances, we use the relative distance between utterances as the edge feature of utterance position graph Gsp. Similarly, we also employ an embedding matrix to map the discrete distance into vector space:
Gsp(i, j) = Ep (j − i) , (6) where Gsp is the adjacent matrix of utterance position graph and the value denotes the relative distance. And Ep ∈ RLd,1 is the embedding matrix.

heading: 4.3 Static-Dynamic Graph Module

heading: 4.3.1 Static Graph Fusion
text: After obtaining adjacent matrixes for static graphs, to conduct cross-graph fusion and interaction, we can see these adjacent matrixes as different channels and use a simple but efficient 1 × 1 convolutional layer to integrate these adjacent matrixes into a fused relationship representation between utterances:
Gs = Conv ( Gsp ⊕ Gss ⊕ Gsk ⊕ Gsd ) , (7)
where ⊕ denotes the concatenation operator of matrixes and Gs ∈ RLd,Ld is the fused relationship representation.

heading: 4.3.2 Dynamic Graph Module
text: To capture the semantic relationship between utterances based on their deep vector representation, inspired by the Transformer (Vaswani et al., 2017), we propose a dynamic graph module that does not use any pre-computed or heuristic method to build the connections between nodes. We first project the utterance vector representations U = {u1, . . . ,uLd} into two different vector spaces, and calculate the relationship as A ∈ RLd,Ld :
Q = UWQ,K = UWK , A = QK⊤√ dK , (8)
where WQ,WK are all trainable parameters. Next, the relation matrix A can be seen as the adjacent matrix for the utterance graph, and this graph is built dynamically via the multi-head attention mechanism. Since this graph is built by the attention module with trainable parameters, it can capture the task-specific relationship between utterances that may not be covered by the heuristic static graph.

heading: 4.3.3 Fusion Module
text: To integrate the static and dynamic graph, we propose a fusion method to combine the relation matrix A of dynamic graph and the adjacent matrix Gs of the static graph into a unified graph Gu. Similar with the static graph fusion method, we also employ a 1×1 convolutional layer to combine the two matrixes A and Gs as two channel:
Gu = Conv (A⊕ Gs) . (9)
We obtain unified adjacent matrix Gu ∈ RLd,Ld . To unify the static and dynamic graph structures into a final utterance representation, we employ a
self-attention layer as shown in Figure 2. We first project the utterance representation into multiple vector spaces using multi-head attention which is same with Equation 8, and then apply the weighted sum operation using the unified graph Gu as the attention score:
{g1, . . . ,gLd} = softmax(Gu)V, (10) V = UWV (11)
where gi is the graph representation of the i-th utterance.

heading: 4.4 Summary Generator
text: Finally, to incorporate the graph representation which captures the dialogue structure information in the generation process of the summary, we use dual cross attention (Cheng et al., 2022) mechanism by proposing a graph attention layer on the top of original self attention layer. We first apply the self-attention on the masked output summary embeddings, and then use the output ps to crossattend to the token-level dialogue hidden states {h1,1, · · · ,hLd,Liu} produced by the utterance encoder (introducued in Equation 1):
pq = MHAtt(ps, {h1,1, · · · ,hLd,Liu}), (12)
where MHAtt is the standard multi-head attention layer and this procedure is the same as the original BART decoder. After the cross-attention layer, we apply a multi-head graph attention layer which aggregate useful knowledge from the updated graph nodes according to the state of each decoding step:
pg = MHAtt(pq, {g1, · · · ,gLd}). (13)
Finally, we apply a fully connected feed-forward network on pg to predict the distribution over the vocabulary of the generated summary. And we use the cross-entropy loss between generated summary and ground truth summary as the training objective to optimize all the parameters of SDDS. We use the parameters in the pre-trained language model BART to initialize the corresponding parameters in our Transformer based text encoder (Equation 1) and summary generator.

heading: 5 Experimental Setup

heading: 5.1 Dataset and Evaluation
text: We verify the effectiveness of SDDS on three benchmark datasets: SAMSum (Gliwa et al.,
2019), MediaSum-NPR (Zhu et al., 2021) and DialogSum (Chen et al., 2021b). For evaluation metrics, following standard practice in summarization (Zhang et al., 2020a; Cheng et al., 2023b), we adopt ROUGE (R1/2/L) (Lin, 2004), BERTScore (Zhang et al., 2020b), BARTScore (Yuan et al., 2021) and MoverScore (Zhao et al., 2019). More implementation details, dataset statistics, and evaluation metrics can be found in Appendix A.2.

heading: 5.2 Compared Methods
text: To verify the effectiveness of SDDS, we compare with the following baselines: S2SA is the Sequence-to-Sequence framework equipped with the attention and copy mechanism (See et al., 2017). Transformer (Vaswani et al., 2017) is a self-attention-based text generation framework. BART (Lewis et al., 2020) and UniLM (Bao and et al., 2020) are large-scale pre-trained language models. MV-BART (Chen and Yang, 2020) is a BART-based method that incorporates topic and stage information to capture the structure of the dialogue context. FROST (Narayan et al., 2021) prompts target summaries with entity chains—ordered sequences of entities mentioned in the summary. CODS (Wu et al., 2021) propose a granularity controlled dialogue summarization method. GPT-Anno (Feng et al., 2021b) uses the DialoGPT (Zhang and et al., 2020) as an unsupervised dialogue annotator for keyword and topic information. CONDIGSUM (Liu et al., 2021a) proposes two topic-aware contrastive learning objectives to implicitly model the topic change and handle information scattering. SSAnet (Zhao et al., 2021a) proposes a heterogeneous semantic slot graph to enhance the slot features for more correct summarization. Coref-Attn (Liu et al., 2021b) proposes to explicitly incorporate coreference information. SCL (Geng et al., 2022a) proposes speakeraware supervised contrastive learning for better factual consistency. HITL (Chen et al., 2022) incorporates human feedback into the training of summarization model. SummaFusion (Ravaut et al., 2022) fuses several summary candidates to produce a second-stage summary.

heading: 6 Experimental Result

heading: 6.1 Overall Performance
text: Automatic Evaluation We compare our model with the baselines listed in Table 1. Our model
performs significantly better than other dialogue summarization models including the state-of-theart model GPT-Anno with improvements of 1.88%, 2.05%, and 0.98% in terms of R-1, R-2, and R-L on the benchmark dataset SAMSum with p < 0.05. We also find that SDDS can achieve consistently better performance than the strong baselines on other two datasets. This demonstrates that the static-dynamic graph model can fuse the human prior knowledge of dialogue structure and learn the semantic relationship dynamically, which helps the summarization model understand the dialogue context better. Although the baseline methods use the heuristic graph construction method (e.g., using discourse parsing result) or use the pre-trained language model GPT-2 to explore the deep semantic
information, their performance is still worse than SDDS which combines the human prior knowledge of dialogue structure and the deep semantic relationship using the static-dynamic graph. Different from the other datasets, MediaSum-NPR has more speakers (avg. 4.0 speakers) and the dialogue structure is more complex. From Table 1, we can find that SDDS achieves better performance. This demonstrates SDDS can be directly generalized to the multi-speaker scenario. We also conduct more fine-grained analysis on SDDS measured by token-level F-measure. As Figure 3 shows, SDDS surpasses baselines in almost all word frequencies and performs especially well for low-frequency words, which shows the great generalization and robustness of SDDS.
Since ROUGE can only evaluate token level syntactical similarity, we also measure the semantic similarity of generated summary and ground truth on SAMSum by BERTScore (Zhang et al., 2020b), BARTScore (Yuan et al., 2021) and MoverScore (Zhao et al., 2019). Results on Table 2 show that these model-based scores are consistent with the ROUGE and human evaluation (detailed below), and verify the superiority of SDDS.
Human Evaluation For the human evaluation, we asked three graduate students with professional English proficiency to rate the generated summary according to its fluency and factual coherence on SAMSum dataset. The rating score ranges from 1 to 3, with 3 being the best. BART achieves 2.55 and 2.31 in terms of fluency and coherence, GPTAnno achieves 2.54 and 2.35 and SDDS achieves 2.73 and 2.57. The kappa statistics are 0.53 and 0.46 for fluency and coherence, and that indicates moderate agreement between annotators. We also conduct the paired student t-test between SDDS and GPT-Anno and obtain p < 0.05 for both metrics. From this experiment, we find that SDDS outperforms the baselines in both metrics, which demonstrates the SDDS can generate fluent summaries with correct facts. A concrete example is shown in Table 6.
Efficiency Evaluation Since the construction of static graphs is non-parametric and can be precomputed, the additional training and inference latency is negligible. The training time for BART is 2.15 hours and SDDS is 2.89 hours. The inference speed for BART is 6.87 samples/second and that for SDDS is 6.55. All experiments are conducted on the same computing platform.

heading: 6.2 Ablation Study
text: To prove the effectiveness of each module, we conduct ablation studies that gradually remove each key module in SDDS, and form 5 baseline methods: (1) SDDS-SDGraph use relational graph convolutional networks (Schlichtkrull and et al, 2018) to capture high-level hidden features considering different types of edge, and replace the StaticDynamic Graph (SDG) module proposed in our method; (2) SDDS-Dyna only uses the static graph and removes the static-dynamic graph fusion module; (3) SDDS-Static only uses the dynamic graph and removes the static-dynamic graph fusion module; (4) SDDS w/o Graph does not use any graph model or dialogue structure information, and the decoder directly attends to the utterance representation U (calculated in Equation 1) instead of attending to graph node representations {g1, · · · ,gLd} as in SDDS; (5) SDDS Simp. Sta. verifies the effectiveness of using our proposed 1× 1 convolu-
tional layer (shown in Equation 7) to fuse the static graphs, which simply concatenates the adjacent matrixes as Gs.
The results are shown in Table 3. All ablation models perform worse than SDDS in terms of R-1/2/L, which demonstrates the preeminence of SDDS. From the table, we can find that the graph module contributes the most, which demonstrates the necessity of incorporating structural information into the dialogue summarization task. Although the SDDS-SDGraph uses the expressive RGCN to incorporate the dialogue structure information, it is still 2.34% and 1.94% worse than the SDDS in terms of R-1 and R-L scores. Since SDDS Simp. Sta. cannot conduct cross-graph information fusion, it is 1.56% worse than the SDDS in terms of R-1.

heading: 6.3 On the Different Static Graphs
text: To evaluate the contribution of each type of static graph, we ablate each static graph, and the results are shown in Table 4. We can find that the utterance position information contributes most to the final performance which demonstrates utterance position can help the model to understand the structure when summarizing the dialogue. Although the discourse parsing graph is an intuitive way to model the dialogue structures and has been widely used in previous dialogue summarization methods (Chen and Yang, 2021; Feng et al., 2021a), it only contributes 0.68% R-1 score compared to the SDDS which is lower than the speaker relation and utterance position. Compare with the
model SDDS-Static which only uses the dynamic graph module, we can find that the models in Table 4 are all better than SDDS-Static. This phenomenon demonstrates the effectiveness of using pre-computed graph structures since it brings human prior knowledge into the dialogue model and future advances in dialogues structure modeling would further benefit SDDS.

heading: 6.4 On the Positional Encoding
text: In the previous section, we can find that the utterance positional static graph contributes most to the final performance in Table 4. In this section, we also compare our positional encoding methods with two commonly used variants: (1) w/ Posi. Emb: uses a trainable matrix as the positional embedding of each utterance (Gehring et al., 2017; Lewis et al., 2020) (2) w/ Sin. Emb: uses the static sinusoidal function to form a positional encoding vector (Vaswani et al., 2017). From Table 5, we can find that these two methods perform worse than our proposed SDDS. This phenomenon verifies the effectiveness of fusing the positional information into utterance relationships in the static graph.

heading: 7 Conclusion
text: In this paper, we first investigate the limitation of the current static graph-based dialogue summarization methods and propose a Static-Dynamic graphbased Dialogue Summarization method (SDDS). It contains two modules, a static graph module and a dynamic graph module. The former injects human prior into the summarization model and the latter encodes the implicit knowledge from a pretrained language model. By fusing these two kinds of graphs with a fine-grained 1×1 convolution, SDDS could adaptively adjust the graph weight and
learn the graph structure in an end-to-end learning fashion from the supervision of the summarization task. To validate the effectiveness of SDDS, we conduct extensive experiments on three public dialogue summarization datasets (SAMSum, MediaSum, and DialogSum) and observe significant improvement over strong baselines. We also carefully examine each key component and gives a detailed analysis of SDDS for future research.
Limitations
We discuss the limitations of SDDS as follows: (1) Although we propose a general framework for dialogue summarization by incorporating both static and dynamic graphs, we only adopt four static graphs to model the dialogue structure. Since dialogue structure modeling is still an active research direction, we believe future advances would further benefit our framework.
(2) Despite the strong performance achieved by SDDS across three dialogue summarization datasets, we use a pre-trained language model as the backbone of our proposed method, as a consequence, we can not go beyond the limitation of the maximum sequence length of the PLM for the dialog summarization scenario like meeting summarization so it remains a future challenge for dialog summarization in the extremely long format.
Ethical Consideration
The dialogue data would inevitably contain private information about the interlocutors. We take careful consideration of this problem: (1) all data in our experiments are publicly available and anonymized by the original dataset provider. The license for SAMSum dataset is CC BY-NC-ND 4.0 and for DialogSum MIT License. For MediaSum, it adheres to only-for-research-purpose guideline from the National Public Radio; (2) we do not use online user data to train our model and we would use an additional rule-based system to double-check whether our model output contains harmful and prejudicial discrimination when we use it for production.
Acknowlegement
This work was supported by the National Natural Science Foundation of China (NSFC Grant No. T2293773 & No. 62122089 & No. 61876196), the National Key Research and Development Program of China (No. 2020AAA0106600), Beijing Outstanding Young Scientist Program (NO.
BJJWZYJH012019100020098), and Intelligent Social Governance Platform, Major Innovation & Planning Interdisciplinary Platform for the “Double-First Class” Initiative, Renmin University of China. Rui Yan is also supported by Beijing Academy of Artificial Intelligence (BAAI).

heading: A Appendix
text: A.1 Speaker Relation Graph
We use a sliding window around each utterance, and count the frequency of occurrence for each speaker in this sliding window. Figure 4 gives an example to illustrate this method, and we obtain a speaker interaction frequency matrix Ĝss ∈ N|S|,|S|. Algorithm 1 illustrates this method, and we obtain a speaker interaction frequency matrix Ĝss ∈ N|S|,|S|.
A.2 Implementation Details
We implement our experiments using Pytorch (Paszke et al., 2019) on an NVIDIA RTX 3090 GPU. The batch size is set to 16, and we use the gradient accumulation to simulate a large batch size. We pad or cut input utterances to contain exactly 200 words, and the maximum decoding length is set to 100. We initialize BART in our model with BARTLarge† which has 16 attention heads, 1024 hidden size and 12 Transformer layers for encoder and decoder respectively. In our graph transformer, we use 4 self-attention layers with 1024 hidden size and 8 attention head. We use AdamW optimizer (Loshchilov and Hutter, 2019) as our optimizing algorithm and employ beam search with size 5 to generate more fluency summary.
A.3 Dataset Statistics
We list some key statistics of these datasets in Table 7. From this table, we can find that the MediaSum-NPR dataset has more speakers, training samples, and longer dialogue context than the other datasets. Note that, in DialogSum, there are three reference summaries for each data sample, and we use multiple references in the evaluation.
A.4 Evaluation Metrics
For evaluation metrics, following existing dialogue summarization papers (Feng et al., 2021b), we
†https://huggingface.co/facebook/bart-large
adopt ROUGE score (Lin, 2004), which is widely applied for summarization evaluation (Chen et al., 2018). The ROUGE metrics compare generated summary with the reference summary by computing overlapping lexical units, including ROUGE-1 (unigram), ROUGE-2 (bi-gram), and ROUGE-L (longest common subsequence). Following existing dialogue summarization papers (Feng et al., 2021b), we use py-rouge‡ as the implementation of ROUGE score. Since only using automatic evaluation metrics can be misleading (Stent et al., 2005), we also use the embedding based evaluation method and conduct the human evaluation. We employ the BERTScore (Zhang et al., 2020b), BARTScore (Yuan et al., 2021) and MoverScore (Zhao et al., 2019) as the embedding based evaluation. For human evaluation, three welleducated annotators are invited to judge 200 randomly sampled summaries. The statistical significance of two runs is tested using a two-tailed paired t-test and is denoted using ▲(or ▼) for strong significance for α = 0.01.
Algorithm 1 Algorithm of speaker relation construction. Input: Dialog Context with Ld utterances Output: Speaker relation Gss ∈ RLd,Ld
1: Let Ĝss ∈ N|S|,|S| = 0. 2: α(uj) = speaker index of uj 3: for each ui in D 4: for each uj in sliding window of ui 5: Ĝss(α(ui), α(uj)) = Ĝss(α(ui), α(uj)) +
1 6: G̃ss = softmaxr(Ĝss)× softmaxc(Ĝss) 7: for each i in {1, . . . , Ld} 8: for each j in {1, . . . , Ld} 9: Gss(i, j) = Ĝss(α(ui), α(uj))
10: return Gss(i, j)
‡https://pypi.org/project/py-rouge
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: the last section
A2. Did you discuss any potential risks of your work? Not applicable. Left blank.

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: the first two sections
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? in section 6

heading: 3 B1. Did you cite the creators of artifacts you used?
text: in section 5

heading: 3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts?
text: in the ethical consideration section

heading: 3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided
text: that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? in section 5 and appendix
B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? Not applicable. Left blank.
B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? Not applicable. Left blank.
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. in the appendix
C 3 Did you run computational experiments? in section 6

heading: 3 C1. Did you report the number of parameters in the models used, the total computational budget
text: (e.g., GPU hours), and computing infrastructure used? in appendix
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.

heading: 3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found
text: hyperparameter values? in section 5

heading: 3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary
text: statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? in section 6

heading: 3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did
text: you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? in appendix
D 3 Did you use human annotators (e.g., crowdworkers) or research with human participants? section 6

heading: 3 D1. Did you report the full text of instructions given to participants, including e.g., screenshots,
text: disclaimers of any risks to participants or annotators, etc.? section 6

heading: 3 D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students)
text: and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? section 6
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? Not applicable. Left blank.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? Not applicable. Left blank.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? Not applicable. Left blank.

heading: Future Work
text: We also carefully examine each key component and gives a detailed analysis of SDDS for future research. Limitations
We discuss the limitations of SDDS as follows: (1) Although we propose a general framework for dialogue summarization by incorporating both static and dynamic graphs, we only adopt four static graphs to model the dialogue structure. Since dialogue structure modeling is still an active research direction, we believe future advances would further benefit our framework. (2) Despite the strong performance achieved by SDDS across three dialogue summarization datasets, we use a pre-trained language model as the backbone of our proposed method, as a consequence, we can not go beyond the limitation of the maximum sequence length of the PLM for the dialog summarization scenario like meeting summarization so it remains a future challenge for dialog summarization in the extremely long format. Ethical Consideration
The dialogue data would inevitably contain private information about the interlocutors. We take careful consideration of this problem: (1) all data in our experiments are publicly available and anonymized by the original dataset provider. The license for SAMSum dataset is CC BY-NC-ND 4. 0 and for DialogSum MIT License. For MediaSum, it adheres to only-for-research-purpose guideline from the National Public Radio; (2) we do not use online user data to train our model and we would use an additional rule-based system to double-check whether our model output contains harmful and prejudicial discrimination when we use it for production. Acknowlegement
This work was supported by the National Natural Science Foundation of China (NSFC Grant No. T2293773 & No. 62122089 & No. 61876196), the National Key Research and Development Program of China (No. 2020AAA0106600), Beijing Outstanding Young Scientist Program (NO. BJJWZYJH012019100020098), and Intelligent Social Governance Platform, Major Innovation & Planning Interdisciplinary Platform for the “Double-First Class” Initiative, Renmin University of China. Rui Yan is also supported by Beijing Academy of Artificial Intelligence (BAAI)