SlowGuess/NAACL_2022_OCR huggingface dataset:
Lin Tian
RMIT University, Australia s3795533@student.rmit.edu.au
Xiuzhen Zhang  
RMIT University, Australia  
xiuzhen.zhang@rmit.edu.au
Jey Han Lau  
The University of Melbourne, Australia  
jayhan.lau@gmail.com
Social media rumours, a form of misinformation, can mislead the public and cause significant economic and social disruption. Motivated by the observation that the user network — which captures who engages with a story — and the comment network — which captures how they react to it — provide complementary signals for rumour detection. In this paper, we propose DUCK (rumour _detection with _user and _comment networks) for rumour detection on social media. We study how to leverage transformers and graph attention networks to jointly model the contents and the structure of social media conversations, as well as the network of users who engage in these conversations. Over four widely used benchmark rumour datasets in English and Chinese, we show that DUCK produces superior performance for detecting rumours, creating a new state-of-the-art. Source code for DUCK is available at: https://github.com/tian678/DUCK-code.
Social media platforms bring easy access to a wealth of information. On the flip side, social media has also accelerated the spread of misinformation (Starbird et al., 2014; Jin et al., 2017). Rumours, a form of misinformation typically defined as stories or statements with unverified truth value (Allport and Postman, 1947), can mislead the public and cause significant economic and social disruption.
Since the seminal work on prediction of information credibility on social media by Castillo et al. (2011), automatic rumour detection on social media has attracted significant research, which aims to detect rumour stories (in contrast to news articles by credible news sources) or determine their veracity — true, false or unverified. Although the task is related to fake news detection, the use of social media for propagation means that various
social context features can be leveraged for detection. This is a contrast to FEVER-style fake news detection (Thorne et al., 2018) which relies mainly on a source of world knowledge (e.g. Wikipedia) to fact-check stories.
Early studies of rumour detection focus on supervised learning algorithms incorporating features manually engineered from post contents, user profiles as well as information propagation patterns (Castillo et al., 2011; Liu et al., 2015; Kwon et al., 2013; Ma et al., 2015; Rath et al., 2017). Recent neural approaches typically explore fusing different feature representations for rumour detection. Sequence processing models such as BERT are used to encode the contents of social media conversations, e.g. source posts and the stream of comments (Kochkina et al., 2017; Tian et al., 2020), while graph models have been experimented to model the structure of social media conversations (Bian et al., 2020; Ma et al., 2018; Lu and Li, 2020). Although prior approaches explored a combination of content and user features for rumour detection, how to leverage pretrained sequence and graph networks to model them effectively remains under-explored.
Research found that misinformation propagates differently from genuine information on social media (Vosoughi et al., 2018). Reply comments of a story contain user opinions and captures how users react to the story, which provides a strong signal for understanding the truthfulness of a story. On the other hand, the network of users who reply to and repost/retweet a story captures who engage with it, which provides a complementary signal. Most studies (Ma et al., 2018; Liu and Wu, 2018; Tian et al., 2020; Bian et al., 2020) typically use only one of these signals.
In this paper we propose DUCK (rumour detection with user and comment networks), a framework that jointly models the user and comment propagation networks. Our study presents an
Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 4939 - 4949 July 10-15, 2022 ©2022 Association for Computational Linguistics
extensive exploration on how we can best model these networks, and compared to previous studies, there are several key differences: (1) we model comments as both (i) a stream to capture the temporal nature of evolving comments; and (ii) a network by following the conversational structure (see Figure 1 for an illustration); (2) our comment network uses a sequence model to encode a pair of comments before feeding them to a graph network, allowing our model to capture the nuanced characteristics (e.g. agreement or rebuttal) exhibited by a reply; and (3) when modelling the users who engage with a story via graph networks, we initialise the user nodes with encodings learned from their profiles and characteristics of their "friends" based on their social networks.
We conduct experiments on four widely used benchmark rumour datasets in English and Chinese, and show that DUCK produces superior performance, creating a new state-of-the-art. Although both users and comments provide complementary signals for our task, the comments have a stronger impact. Also, when modelling the network of users who engage with a story, incorporating the social relations of users proves to be very beneficial.
Early studies of rumour detection focus on supervised learning algorithms incorporating engineered features from post contents, user profiles as well as information propagation patterns (Castillo et al., 2011; Liu et al., 2015; Kwon et al., 2013; Ma et al., 2015; Rath et al., 2017). Turenne (2018) analysed lexical content and information propagation based on Allport's theory of transmission (Allport and Postman, 1947). It identified 53 features within six categories to represent a rumour message, from semantic meaning to information transmission.
Recent research focuses on neural models to automatically extract features for rumour detection. Sequence processing models leverage the textual contents from the source posts and user reply comments for rumour detection. Signals such as writing style, stance and opinions as well as emotions are extracted from the text for rumour detection. Shu et al. (2017) introduce linguistic features to represent writing styles and other features based on sensational headlines from Twitter to detect misinformation. To detect rumours as early as possible, Zhou et al. (2019) incorporate reinforcement learning to dynamically decide how
many responses are needed to classify a rumour. Tian et al. (2020) explore the relationship between a source tweet and its comments by transferring stance prediction model to classify rumours. Most of these approaches model user comments as a sequence of posts and ignore the conversational structure among the comments.
Graph neural models leverage information propagation patterns for rumour detection. Liu and Wu (2018) experiment with using convolutional and recurrent neural networks to process user features in the retweet propagation path of stories, and Ma et al. (2018) present a tree-structure recursive neural network to model information propagation for rumour detection. Bian et al. (2020) propose a bi-directional graph network to model the upward and downward information propagation structure among user comments to distinguish false from true rumours.
There are also studies combining signals from contents, users and propagation networks for rumour and fake news detection. An ensemble deep learning architecture is presented in Lu and Li (2020), which incorporates source post content and retweet network. Nguyen et al. (2020) propose to learn representations for misinformation detection based on the heterogeneous graph of news, news sources, users and their stances in comments. Leveraging dual attention mechanism on source text and user propagation structure, Ni et al. (2021) leverage dual attention mechanism on source text and user propagation structure via graph attention networks for fake news detection task. All these studies largely model the superficial characteristics of comments and users, e.g. comments are represented using static features such as bag-of-words (Bian et al., 2020; Nguyen et al., 2020) and users with simple features extracted from their profiles (Liu and Wu, 2018; Lu and Li, 2020; Ni et al., 2021). Deeper interactions, such as the relation between a post and its reply and the social relations of users (e.g. followers), remain under-explored. Table 1 summarises the differences between previous studies and our work.
Beyond rumour detection, recent studies explore combining modern pretrained language models and graph models for modelling texts and their interactions. Using the FEVER dataset, Zhong et al. (2020) use pretrained models to perform semantic role labelling to understand the relation between clauses in evidence passages and then encode the
Figure 1: Overall architecture of DUCK. The structure of user tree differs from that of comment tree, as the former captures both comments (♀) and reposts/retweets (♂), while the latter considers only comments.
S	C	CN	UF	UN
RvNN (Ma et al., 2018)	✓	✓	✓
RNN+CNN (Liu and Wu, 2018)	p	rt
Multitask (Li et al., 2019)	✓	✓	✓	p
stance-BERT (Tian et al., 2020)	✓	✓
Bi-GCN (Bian et al., 2020)	✓	✓	✓
GCAN (Lu and Li, 2020)	✓	p	rt
DUCK (our work)	✓	✓	✓	p+s	rt+rp
Table 1: Information used in various studies. S: source post, C: comments, CN: comment network, UF: user features, UN: user network, p: user profile, s: social relations, rt: repost/retweet, and rp: reply.
network with graph models to detect fake news. Liu et al. (2020) use BERT to encode a pair of claim and evidence passage and then propose a kernel graph network to model the fully connected network of evidence passages. Although these two studies combine sequence and graph models, their task has a different data structure and hence their methods cannot be trivially adapted to the rumour detection task.
Let  $X = \{x_0, x_1, x_2, \ldots, x_n\}$  be a set of stories, where a story  $x_i$  consists of a source post and its reply comments, defined as  $x_i = \{(c_0, u_0, p_0, t_0), \ldots, (c_m, u_m, p_m, t_m)\}$ , where  $c$  refers to the textual content of the post (empty string if it is a repost/retweet),  $u$  is the user ID
who submits the post,  $p$  is the parent post ID that the current post replies to (null if it is a source post, e.g.  $p_0 = \mathrm{null}$ ), and  $t$  the timestamp of the post. Each story  $x_i$  is associated with a ground-truth label  $y_i \in Y$ , where  $Y$  represents the label set (binary or 4 classes depending on the rumour dataset). Our goal is to learn a classifier from the labelled rumour dataset, that is  $f: X \to Y$ .
The overall architecture of our rumour detection approach is presented in Figure 1. It consists of four modules: (1) comment tree: models the comment network by following the reply-to structure using a combination of BERT (Devlin et al., 2019) and graph attentional networks (Veličković et al., 2018); (2) comment chain: models the comments as a stream using transformer-based sequence models; (3) user tree: incorporates social relations to model the user network using graph attentional networks; (4) rumour classifier: combines the output from comment tree, comment chain and user tree to classify the source post. Note that the network structure of the user tree differs from that of the comment tree as the former captures both comments and reposts/retweets but the latter considers only comments (Figure 1).
4.1 Comment Tree
Here we aim to model the conversational structure of the comments that a source post generates. Previous studies typically model this via graph networks, but most use simple features (e.g. bag-of-words) to represent the text (Bian et al., 2020), which fail to capture the nuanced relationships (e.g. agreement) between a parent post and its child-reply post.
To capture the relations of crowd opinions in the comment tree, we propose to use a pretrained language model (BERT; (Devlin et al., 2019)) and graph attention network (GAT; (Vieweg et al., 2010)) to model comment tree; see Figure 2 for an illustration. We first process the set of parent-child posts with BERT (Devlin et al., 2019) before feeding them to a graph network to model the full conversational structure. The self-attention mechanism between the words in the parent and child posts would produce a more fine-grained analysis of their relationship, which representations such as bag-of-words cannot model. Using the comment tree in Figure 2 as an example, this means we would first process the following pairs of posts using BERT:  $\{(0,0),(0,1),(0,2),(2,6),(2,7),(6,9)\}$ , where  $(0,0)$  is a pseudo pair created for the source post. $^{1}$  Formally:
$$
h _ {p + q} = \operatorname {B E R T} \left(\operatorname {e m b} \left([ C L S ], c _ {p}, [ S E P ], c _ {q}\right)\right) \tag {1}
$$
where  $c$  represents the text,  $\mathrm{emb}()$  the embedding function and  $h$  the contextual representation of the [CLS] token produced by BERT.
To model the conversational network structure, we use graph attentional networks (GAT; (Veličković et al., 2018)). Different from graph convolutional networks (Kipf and Welling, 2017), GAT iteratively learns node encodings via multi-head attention with neighbouring nodes, and has the advantage to infer encodings for new nodes after it is trained. To compute  $h_i^{(l + 1)}$ , the encoding for node  $i$  at iteration  $l + 1$ :
$$
\begin{array}{l} e _ {i j} ^ {(l)} = \operatorname {L R} \left(a ^ {(l) T} \left(W ^ {(l)} h _ {i} ^ {(l)} \oplus W ^ {(l)} h _ {j} ^ {(l)}\right)\right) \\ h _ {i} ^ {(l + 1)} = \sigma \left(\sum_ {j \in \mathcal {N} (i)} \operatorname {s o f t m a x} \left(e _ {i j} ^ {(l)}\right) z _ {j} ^ {(l)}\right) \tag {2} \\ \end{array}
$$
where LR denotes the LeakyReLU activation function,  $\oplus$  the concatenation operation,  $\mathcal{N}(i)$  the
Figure 2: The architecture of BERT+GAT.
neighbors of node  $i$ ,  $e_{ij}^{(l)}$  the unnormalised attention score between node  $i$  and  $j$ , and  $a$  and  $W$  are learnable parameters. Note that  $h_i^{(0)}$  represents the encodings produced by BERT (Equation 1).
To aggregate the node encodings to get a graph representation  $(z_{ct})$ , we explore four methods:
root: Uses the root encoding to represent the graph as the source post is ultimately what we are classifying:
$$
z _ {c t} = h _ {0} ^ {L} \tag {3}
$$
where  $L$  is the number of GAT iterations.
- root: Mean-pooling over all nodes except the root:
$$
z _ {c t} = \frac {1}{m} \sum_ {i = 1} ^ {m} h _ {i} ^ {L} \tag {4}
$$
where  $m$  is the number of replies/comments.
$\triangleleft$  : Mean-pooling of the root node and its immediate neighbours:
$$
z _ {c t} = \frac {1}{| \mathcal {N} (0) |} \sum_ {i \in \mathcal {N} (0)} h _ {i} ^ {L} \tag {5}
$$
all: Mean-pooling of all nodes:
$$
z _ {c t} = \frac {1}{m + 1} \sum_ {i = 0} ^ {m} h _ {i} ^ {L} \tag {6}
$$
4.2 Comment Chain
Here we model the posts as a stream in the order they are posted. As such, we have a chain or list structure (rather than a tree structure); see "comment chain" in Figure 1.
We explore three ways to model the comment chain, using: (1) one-tier transformer; (2) longformer (Beltagy et al., 2020); and (3) two-tier transformer.
One-tier transformer: Given a source post  $(c_0)$  and the comments  $\left(\{c_{1},\dots,c_{m}\}\right)$ , we simply concatenate them into a long string and feed it to BERT
${}^{1}$  Preliminary experiments found that the pseudo pair is important because it allows us to maintain the original network structure.
and use the contextual representation of the [CLS] token as the final representation:
$$
z _ {c c} = \operatorname {B E R T} (\operatorname {e m b} ([ C L S ], c _ {0}, [ S E P ], c _ {1}, \dots , c _ {m ^ {\prime}}))
$$
where  $m^{\prime}(< m)$  is the number of comments we can incorporate without exceeding BERT's maximum sequence length (384 in our experiments).
Longformer: To circumvent the sequence length limit, we experiment with using a longformer, which can process up to 4,096 subwords, allowing us to use most if not all the comments. Longformer has a similar architecture as the one-tier transformer, but uses a sparser attention pattern to process longer sequences more efficiently. We use a pretrained longformer $^2$ , and follow the same approach as before for modelling the comment chain:
$$
z _ {c c} = \operatorname {L F} \left(\operatorname {e m b} \left([ C L S ], c _ {0}, [ S E P ], c _ {1},..., c _ {m ^ {\prime \prime}}\right)\right)
$$
where  $m''\approx m$
Two-tier transformer: An alternative approach to tackling the sequence length limit is to model the comment chain using two tiers of transformers: one for processing the posts independently, and another for processing the sequence of posts using representations from the first transformer. Formally:
$$
h _ {i} = \operatorname {B E R T} \left(\operatorname {e m b} _ {1} ([ C L S ], c _ {i})\right)
$$
$$
z _ {c c} = \operatorname {t r a n s f o r m e r} \left(\operatorname {e m b} _ {2} ([ C L S ]), h _ {0}, h _ {1}, \dots , h _ {m}\right)
$$
where BERT and transformer denote the first- and second-tier transformers respectively. The second-tier transformer has a similar architecture to BERT, but has only 2 layers and its parameters are initialised randomly.
4.3 User Tree
Moving away from the post content, here we model the network of users that interact with a source post ("user tree" in Figure 1). Previous studies found that the user characteristics are different for those that engage with rumours vs. those who don't (Vosoughi et al., 2018; Shu et al., 2018), motivating us to model the user network. Note that unlike previous studies, our user network captures all users who reply to or repost the source post (previous studies use only the reposts, see Table 1).
We explore three methods to model the user network. All methods use a GAT (Veličković et al.,
2018) to model the network (following Equation 2), and we aggregate the node encodings by mean-pooling over all nodes to produce the graph representation:
$$
z _ {u t} = \frac {1}{m + 1} \sum_ {i = 0} ^ {m} h _ {i} ^ {L}
$$
where  $L$  is number of GAT iterations.
The main difference between the three methods is in how they initialise the user nodes  $(h_i^{(0)})$ :
$\mathbf{GAT}_{\mathbf{rnd}}$ : This is the base method where we initialise the user nodes with random vectors.
$$
h _ {i} ^ {0} = r a n d o m [ v _ {1}, v _ {2}, \dots , v _ {d} ]
$$
$\mathbf{GAT}_{\mathbf{prf}}$ : Following Liu and Wu (2018), this method initialises the user nodes based on features derived from their user profiles: username, user screen name, user description, user account age, number of followers and following users, number of posts and favourite posts, whether the profile is protected, whether the account is GPS-enabled, and the time difference with the source post. Thus, the static user node  $h_i^0$  is given by with  $v_i \in \mathbb{R}^k$  from user profiles
$$
h _ {i} ^ {0} = [ v _ {1}, v _ {2}, \dots , v _ {k} ]
$$
$\mathbf{GAT}_{\mathbf{prf} + \mathbf{rel}}$ : This method initialises the user nodes with representations learned by a variational graph autoencoder (GAE; Kipf and Welling (2016)) based on the user features (defined above) and their social relations (based on "follow" relations).<sup>4</sup>
Intuitively, GAE is an unsupervised graph learning algorithm that takes in an adjacency matrix as input, and learns node representations that can reconstruct the adjacency matrix in the output. Note that the network structure of the GAT and GAE is intrinsically different — the former captures the users that engage with a source post while the latter the network of users who follow one another. The idea for using GAE-learned encodings to initialise user nodes is that they are more informative, since they capture information about a user and their peers.
3The last feature is technically not user profile information, but it is a form of user characteristic as it captures how quickly they engage with a post.
For the unseen or isolated users, we initialise them based on their user features (used in  $\mathrm{GAT}_{\mathrm{prf}}$ ), and project them via a learned matrix into the same space as the GAE-initialised user nodes.
$^{2}$ https://huggingface.co/transformers/model_doc/longformer.html
Given the social graph  $G_{s}$  constructed based on the training data, we can derive an adjacency matrix  $\mathrm{A} \in \mathbb{R}^{n \times n}$ , where  $n$  is the number of users. Let  $X = [x_{1}, x_{2}, \ldots, x_{n}]$ ,  $x_{i} \in \mathbb{R}^{k}$  be the input node features. Our goal is to learn a transformation matrix  $Z \in \mathbb{R}^{n \times d}$ , which converts users to a latent space with the dimensionality of  $d$ . We use a two-layer GCN as the encoder. It takes an adjacency matrix  $\mathrm{A}$  and a feature matrix  $\mathrm{X}$  as inputs and generates the latent variable  $Z$  as output. The decoder is defined by an inner product between latent variable  $Z$ . The output of our decoder is a reconstructed adjacency matrix  $\hat{A}$ . Formally:
$$
\begin{array}{l} Z = \operatorname {e n c} (\mathbf {X}, \mathbf {A}) \\ = \operatorname {G C N} (f (\operatorname {G C N} (\mathbf {A}, \mathbf {X}; \theta_ {1})); \theta_ {2}) \\ \end{array}
$$
$$
\hat {A} = \mathrm {d e c} (Z, Z ^ {\top}) = \sigma \left(Z Z ^ {\top}\right)
$$
The output  $h_i^{(0)} \in \mathbb{R}^d$  is given by
$$
h _ {i} ^ {(0)} = \left\{ \begin{array}{l l} \operatorname {R e L U} (W \cdot [ v _ {1}, \ldots , v _ {k} ]), & \text {i f} \operatorname {u s e r} _ {i} \notin G _ {s} \\ Z _ {i}, & \text {i f} \operatorname {u s e r} _ {i} \in G _ {s} \end{array} \right.
$$
where  $W_{i}$  is the weight of the fully-connected layer and  $v_{i}\in \mathbb{R}^{k}$  from user profiles.
4.4 Rumour Classifier
In each module (comment tree, comment chain and user tree), we explore a number of approaches to model its structure (e.g. there are several ways to aggregate the node encodings to produce  $z_{ct}$  for the comment tree and 3 different methods to produce  $z_{cc}$  for the comment chain). Given an optimal approach for each module (Section 5), DUCK combines the output from all modules to classify a source post and is trained using standard cross-entropy loss. Formally:
$$
z = z _ {c t} \oplus z _ {c c} \oplus z _ {u t}
$$
$$
\hat {y} = \operatorname {s o f t m a x} \left(W _ {c} z + b _ {c}\right)
$$
$$
\mathcal {L} = - \sum_ {i = 1} ^ {n} y _ {i} l o g (\hat {y _ {i}})
$$
where  $n$  denotes the number of training instances.
In this section, we first introduce the datasets for our experiments and then present the performance of DUCK by comparing against a number state-of-the-art models.
Twitter15	Twitter16	WEIBO	CoAID
#stories	1,490	818	4,664	143,009
#users	276,663	173,487	2,746,818	114,484
Comment graph
#nodes	331,612	204,820	3,805,656	248,742
Avg. # of nodes/s	223	251	816	7
Max. # of nodes/s	1,768	2,765	1,768	228
Min. # of nodes/s	55	81	10	1
Avg. time delay/s	1,337	848	2460.7	15.4
User social network
#nodes	39,869	19,211	2,746,818	1,601
#connections	3,086,741	1,232,100	-	25,605
Table 2: Statistics of rumour datasets. "s" denotes a story (source post and its comments).
We evaluate our method on four widely used rumour datasets: Twitter15 (Ma et al., 2017); Twitter16 (Ma et al., 2017); CoAID (Cui and Lee, 2020); and WEIBO (Ma et al., 2016). Twitter15 and Twitter16 are Twitter datasets with four rumour classes: true rumour, false rumour, non-rumour and unverified rumour. CoAID (Cui and Lee, 2020) collects of a set of COVID-19 news articles shared on Twitter, and they are annotated with two classes (true or fake). WEIBO (Ma et al., 2016) contains a collection of stories from Sina Weibo, a Chinese social media platform, and is annotated with two classes (rumour and non-rumour). Table 2 presents some statistics of these datasets. For Twitter-based datasets (Twitter15/16 and CoAID), we crawl the tweets and additional user information (e.g. user profile metadata and followers) via the official Twitter API. For WEIBO, the platform does not provide a means to crawl social relations and so the user tree uses  $\mathrm{GAT}_{\mathrm{prf}}$ .