LEX-GAN: L AYERED E XPLAINABLE R UMOR D ETECTOR B ASED ON G ENERATIVE A DVERSARIAL N ETWORKS
Anonymous authors
Paper under double-blind review
A BSTRACT
Social media have emerged to be increasingly popular and have been used as tools for gathering and propagating information.
However, the vigorous growth of social media contributes to the fast-spreading and far-reaching rumors.
Rumor detection has become a necessary defense.
Traditional rumor detection methods based on hand-crafted feature selection are replaced by automatic approaches that are based on Artiﬁcial Intelligence (AI).
AI decision making systems need to have the necessary means, such as explainability to assure users their trustworthiness.
Inspired by the thriving development of Generative Adversarial Networks (GANs) on text applications, we propose LEX-GAN, a GAN-based layered explainable rumor detector to improve the detection quality and provide explainability.
Unlike fake news detection that needs a previously collected veriﬁed news database,
LEX-GAN realizes explainable rumor detection based on only tweet-level text.
LEX-GAN is trained with generated non-rumor-looking rumors.
The generators produce rumors by intelligently inserting controversial information in non-rumors, and force the discriminators to detect detailed glitches and deduce exactly which parts in the sentence are problematic.
The layered structures in both generative and discriminative model contributes to the high performance.
We show LEX-GAN’s mutation detection ability in textural sequences by performing a gene classiﬁcation and mutation detection task.
I NTRODUCTION
Sequential synthetic data generation such as generating text and images that are indistinguishable to human generated data have become an important problem in the era of Artiﬁcial Intelligence (AI).
Generative models, e.g., Variational AutoEncoders (VAEs) (Kingma & Welling, 2013), Generative
Adversarial Networks (GANs) (Goodfellow et al., 2014), Recurrent Neural Networks (RNNs) with
Long Short-Term Memory (LSTM) cells (Hochreiter & Schmidhuber, 1997), have shown outstanding generation power of fake faces, fake videos, etc.
Consequently, we require discriminative models capable of detecting AI-generated fake data with explainability in order to manage the malicious viral information (Knight, 2019).
A black box decision maker without explainability that does not shed light into how the decision are made may hence lose the trust of its users.
GANs estimate generative models via an adversarial training process (Goodfellow et al., 2014).
Powerful real-valued generators have found applications in image and video generation.
However,
GANs face challenges when the goal is to generate sequences of discrete tokens such as text (Yu et al., 2017).
Given the discrete nature of text, backpropagating the gradient from the discriminator to the generator becomes infeasible (Fedus et al., 2018).
Training instability is a common problem of GANs, especially those with discrete settings.
Unlike image generation, the autoregressive property in text generation exacerbates the training instability since the loss from discriminator is only observed after a sentence has been generated completely (Fedus et al., 2018).
In addition to the recent development in GAN-based text generation, discriminator-oriented GANstyle approaches are proposed for detection and classiﬁcation applications, such as rumor detection (Ma et al., 2019).
Differently from the original generator-oriented GANs, discriminator-oriented
GAN-based models take real data as input to the generator instead of noise.
Hence fundamentally, the detector may get high performance through the adversarial training technique.
Current adversarial training strategies improve the robustness against adversarial samples.
However, these methods lead to reduction of accuracy when the input samples are clean (Raghunathan et al., 2019).
On a related note, social media and micro-blogging have become increasingly popular (Yazdanifard et al., 2011; Viviani & Pasi, 2017).
The convenient and fast-spreading nature of micro-blogs fosters the emergence of various rumors.
Commercial giants, government authorities, and academic researchers take great effort in diminishing the negative impacts of rumors (Cao et al., 2018).
Rumor detection has been formulated into a binary classiﬁcation problem by a lot of researchers.
Traditional approaches based on hand-crafted features describe the distribution of rumors (Castillo et al., 2011; Kwon et al., 2013).
More recently, Deep Neural Network (DNN)-based methods extract and learn features automatically, and achieve signiﬁcantly high accuracy on rumor detection (Chen et al., 2018).
Generative models have also been used to improve the performance of rumor detectors (Ma et al., 2019).
However, binary rumor classiﬁcation lacks explanation since it only provides a binary result without expressing which parts of a sentence could be the source of problem.
The majority of the literature deﬁnes rumors as “an item of circulating information whose veracity status is yet to be veriﬁed at the time of posting” (Zubiaga et al., 2018).
Providing explainability for unveriﬁed rumor detection is challenging.
A related research area works with fake news is more well-studied since fake news has a veriﬁed veracity.
Attribute information, linguistic features, and semantic meaning of post (Yang et al., 2019) and/or comments (Shu et al., 2019) have been used to provide explainability for fake news detection.
A veriﬁed news database has to be established for these approaches.
However, for rumor detection, sometimes a decision has to be made based on the current tweet only.
Text-level models with explainability that recognize rumors by feature extraction should be developed to tackle this problem.
In this work, we propose LEX-GAN, a GAN-based layered explainable framework for text-level rumor detection.
LEX-GAN keeps the ability of discriminating between real-world and generated samples, and also serves as a discriminator-oriented model that classiﬁes real-world and generated fake samples.
We overcome the infeasibility of propagating the gradient from discriminator back to the generator by applying Reinforcement Learning (RL) to train the layered generators.
The training instability of long sentence generation is lowered by selectively replacing words in the sentence.
We solve the per time step error attribution difﬁculty by word-level generation and evaluation.
We show that our model outperforms the baselines in terms of addressing the degraded accuracy problem with clean samples only.
The major contributions of this work are listed as follows:
• LEX-GAN delivers an explainable rumor detection without requiring a veriﬁed news database.
Rumors could stay unveriﬁed for a long period of time because of information insufﬁciency.
Providing explainability of which words in the sentence could be problematic is critical especially when there is no veriﬁed fact.
When a veriﬁed news database is achievable, LEX-GAN can be applied to fake news detection with minor modiﬁcation.
• The layered structure of LEX-GAN avoids the function mixture and boosts the performance.
During framework design, we found that using one layer to realize two functions either in generative or discriminative model causes function mixture and hurts the performance.
LEX-GAN generates high-quality rumors by ﬁrst intelligently selecting words to be replaced, then choosing appropriate substitutes to replace.
The explanation generation and rumor detection are realized separately by two layers in the discriminative model.
• LEX-GAN is a powerful framework in textural mutation detection.
We demonstrate the mutation detection power by applying LEX-GAN to a gene classiﬁcation and mutation detection task.
LEX-GAN accurately identiﬁes tokens in the gene sequences that are likely from the mutation, and classiﬁes mutated gene sequences with high precision.
R ELATED W ORK
GANs in continuous space promise full differentiability.
When dealing with discrete elements such as text, the discrete nature results in non-differentiability (Husz´ar, 2015).
Researchers work with discrete element generation to either avoid the issue and reformulate the problem, or consider RL methods (Yu et al., 2017).
Gulrajani et al.
(Gulrajani et al., 2017) propose a fully differentiable
Convolutional Neural Network (CNN)-based wasserstein GAN that produces sequences of 32 characters.
However, the quality of generated sentences would be sufﬁcient only if spelling errors are frequent.
RNN-based GANs, on the other hand, generate a sequence word by word, hence the quality issues such as spelling errors are rare.
Many researchers have explored the non-differentiable problem in RNN-based GANs.
Wolf et al.
(Press et al., 2017) extend the work of (Gulrajani et al., 2017) by training RNN using curriculum learning.
They start by training on short sequences and then slowly increase the sequence length.
SeqGAN (Yu et al., 2017) bypasses the generator differentiation problem by performing gradient policy update.
The RL reward signal coming from the discriminator is calculated on a complete sequence.
Differently from SeqGAN, MaskGAN (Fedus et al., 2018) employs an actor-critic training procedure on a text inﬁlling task designed to provide rewards at every time step.
Inspired by the thriving development of GANs on text applications, GAN-style rumor detection has become the state-of-the-art.
GAN-GRU (Ma et al., 2019) is one of the latest GAN-based rumor detectors.
By utilizing adversarial training, a generator is designed to create uncertainty.
Hence, the complicated sequences pressurise the discriminator to learn stronger rumor representations.
GANGRU reaches the highest accuracy of 78 .
1% on a bench-marking rumor dataset PHEME (Kochkina et al., 2018).
Although GAN-GRU outperforms other models, it does not offer explainability, nor does it provide any information regarding the parts of the sentences that are problematic.
Addressing such deﬁciencies has been the main motivation for our work.
LEX-GAN
Figure 1 shows the architecture of our proposed LEX-GAN.
In rumor detection task, the generators have to intelligently construct a rumor that appears like non-rumor to deceive the discriminators.
Since a good lie usually has some truth in it, we choose to replace some of the tokens in the sequence and keep the majority to realize this goal.
Two steps for intelligently replacing tokens in a sequence are: i) determine where to replace, and ii) choose what substitutes to use.
G where and G replace are designed to realize these two steps.
After constructing the strong generators, the discriminators are designed to provide a defense mechanism.
Through adversarial training, the generators and discriminators grow stronger together, in terms of generating and detecting rumors, respectively.
In rumor detection, given a sentence, there are two questions that need to be answered: i) is it a rumor or a non-rumor, and ii) if a rumor, which parts are problematic.
D classify and D explain are designed to answer these two questions.
We found that realizing two functions by one layer either in discriminative model or generative model hurts the performance.
Hence the layered structure is designed.
3. G ENERATIVE M ODEL
The sequence generation task of LEX-GAN is done by the generative model: G where and G replace .
Given a human-generated real-world sequence input x = ( x 1 , x 2 , ..., x M ) with length M , for example a tweet-level sentence containing M words, G where outputs a probability vector p
=
( p 1 , p 2 , ..., p M ) indicating the probabilities of each item x
i ( i ∈ [1 , M ] ) being replaced.
p is applied to input x to construct a new sequence x where with some items replaced by blank.
For example, xbecomes a blank and x where =
( x 1 , , ..., x M ) .
[Equation]
where f ( · ) binarizes the input based on a hyperparameter N replace .
It determines the percentage of the words to be replaced in a sentence.
Operator ◦ works as follows.
If a = 1 , then a ◦ b = b .
If a = 0 , then a ◦ b = .
G replace is an encoder-decoder model with attention mechanism.
It takes x where and ﬁlls in the blank, then outputs a sequence x replace = ( x 1 , x replace, ..., x M ) .
The generative model is not fully differentiable because of the sampling operations on G where and G replace .
To train the generative model, we adopt policy gradients (Sutton et al., 2000) from RL to solve the non-differentiable issue.
3.1. G replace GRU- BASED E NCODER
Gated Recurrent Units (GRUs) (Cho et al., 2014) are improved versions of standard RNNs that use update gates and reset gates to resolve the vanishing gradient problem of a standard RNN.
In our
GRU-based encoder, the hidden state h t is computed as GRU encoder ( x wheret , h t − 1 ) :
[Equation]
where W encz , W ench , W encr , U encz , U ench and U encr are encoder weight matrices.
σ ( · ) is the sigmoid function.
(cid:12) represents element-wise multiplication.
3.1. G replace GRU- BASED D ECODER WITH A TTENTION M ECHANISM
In LEX-GAN, our encoder-decoder G replace utilizes attention mechanism (Bahdanau et al., 2014) to automatically search for parts of a sentence that are relevant to predicting the target word.
The content vector c t summarizes all the information of words in a sentence.
It depends on the annotations h t and is computed as a weighted sum of these h t :
[Equation]
[Equation]
where e tj scores how well the inputs around position j and the output at position t match
Alignment model a is a neural network that jointly trained with all other components.
The GRU decoder takes the previous target y t − 1 and the context vector c t as input, and utilizes GRU to compute the hidden state s t as GRU decoder ( y t − 1 , s t − 1 , c t ) :
[Equation]
[Equation]
where W decz , W decs , W decr , U decz , U decs , U decr , C decz , C decs and C decr are decoder weight matrices.
Through this attention-equipped encoder-decoder, G replace intelligently replaces items in sequences and outputs adversarial samples.
3. D ISCRIMINATIVE M ODEL
The generated adversarial samples x replace combined with original data x are fed to the discriminative model.
D classify and D explain are trained independently.
We note that the two discriminators can depend on each other, but we have chosen to explore the dependency as part of our future work on LEX-GAN.
D classify provides a probability in rumor detection, and D explain provides the probability of each word in the sentence being problematic.
The explainability of LEX-GAN is gained by adversarial training.
We ﬁrst insert adversarial items in the sequence, then train D explain to detect them.
Through this technique, LEX-GAN can not only classify data with existing patterns, but also classify sequences with unseen patterns that may appear in the future.
Adversarial training improves the robustness and generalization ability of LEX-GAN.
We will show in Section 5 the effectiveness of LEX-GAN in addressing the accuracy reduction problem, when compared to prior work.
3. T RAINING
In rumor detection, a sequence x has a true label Y being either a rumor R or a non-rumor N .
After manipulating the sequence x , output of the generative model x replace is labeled as R since it is machine generated.
The objective of a φ -parameterized generative model is to mislead the θparameterized discriminators.
In our case, D θ classify ( x replace ) indicates how likely the generated x replace is classiﬁed as N .
D θexplain ( x replace ) indicates how accurately D θexplain detects the replaced words in a sequence.
The error attribution per time step in LEX-GAN is achieved naturally since D θexplain evaluates each token and therefore provides a ﬁne-grained supervision signal to the generators.
For example, a case where the generative model produces a sequence that deceives the discriminative model.
Then the reward signal from D θexplain indicates how well the position of each replaced word contributes to the error result.
The reward signal from D θclassify represents how well the combination of the position and the replaced word deceived the discriminator.
The generative model is updated by applying a policy gradient on the received rewards from the discriminative model.
The rumor generation problem is deﬁned as follows.
Given a sequence x , G φwhere is used to produce a sequence of probabilities p indicating the replacing probability of each token in x .
G φreplace takes x where and produces a new sequence x replace .
This newly generated x replace is a sentence, part of which is replaced and labeled as R .
At time step t , the state s consists of s where and s replace .
s
where = ( p 1 , ..., p t − 1 ) , s replace = ( x replace, ..., x replacet −) .
The policy model
G φwhere ( p t | p 1 , ..., p t − 1 ) and G φreplace ( x replacet | x replace, ..., x replacet −) are stochastic.
Following RL,
G φwhere ’s objective is to maximize its expected long-term reward:
[Equation]
where Q G φ D θ ( s 0 , a ) is the accumulative reward following policy G φ starting from state s
= { s where, s replace} .
− D θexplain ( s replace ) indicates how much the generative model misleads
D θexplain .
a is an action set that contains output of both G φwhere and G φreplace .
R T is the reward for a complete sequence.
Similarly to G φwhere , G φreplace maximizes its expected long-term reward:
[Equation]
We apply a discriminative model provided reward value to the generative model after the sequence is produced.
The reason is that our G φ replace doesn’t need to generate each and every word in the sequence, but only ﬁlls a few blanks that are generated by G φwhere .
Under this assumption, long-term reward is approximated by the reward gained after the whole sequence is ﬁnished.
The discriminative model and the generative model are updated alternately.
The loss function of discriminative model is deﬁned as follows:
[Equation]
L explainD = − E y ∼ f
( G φwhere ( x ))
[ ylog ( D θexplain ( x replace ))
+(1 − y ) log
(1 − D θexplain ( x replace ))] (17)
L classifyD = − E y ∼ Y [ ylog ( D θclassify ( x replace ))
+ (1 − y ) log
(1 − D θclassify ( x replace ))] (18) where λ explainD and λ classifyD are the balancing parameters.
We adopt the training method in GANs to train the networks.
In each epoch, the generative model and the discriminative model are updated alternately.
Over-training the discriminators or the generators may result in a training failure.
Thus hyper-parameters G STEP and D STEP are introduced to balance the training.
In each epoch, the generators are trained G STEP times.
Then discriminators are trained D STEP times.
E XPERIMENT S ETTINGS 4. D ATASETS
We evaluate LEX-GAN on a benchmarking Twitter rumor detection dataset PHEME (Kochkina et al., 2018), and splice site benchmark dataset NN269 (Reese et al., 1997).
PHEME has two versions.
PHEMEv5 contains 5792 tweets related to ﬁve news, 1972 of them are rumors and 3820 of them are non-rumors.
PHEMEv9 contains 6411 tweets related to nine news, 2388 of them are rumors and 4023 of them are non-rumors.
NN269 dataset contains 13231 splice site sequences.acceptor splice site sequences with length of 90 nucleotides, 5643 of them are positive AP andof them are negative AN . 6246 donor splice site sequences with length of 15 nucleotides, 4922 of them are positive DP and 1324 of them are negative DN .
4. M ODELS
In the rumor detection task, we compare LEX-GAN with six popular rumor detectors: RNN with
LSTM cells, CNN, VAE-LSTM, VAE-CNN, a contextual embedding model with data augmenting (DATA-AUG)
(Han et al., 2019), and a GAN-based rumor detector (GAN-GRU) (Ma et al., 2019).
One of the strengths of LEX-GAN is that under the delicate layered structure that we designed, the choice of model structure effects the results but not signiﬁcantly.
To showcase this ability of the layered structure, we generate a variation of LEX-GAN as one baseline.
LEX-LSTM is generated by replacing LEX-GAN’s G replace with a LSTM model.
LEX-GAN generates a set of sequences by substituting 10% of the words in original sequences.
We pre-train the D classify by ﬁxing N replace = 10% .
We then freeze D classify and train the other three models.
During training, we lower N replace from 50% to 10% to guarantee data balancing for D explain and hence better results in terms of explainability.
All the embedding layers in the generators and discriminators are initialized withdimension GloVe (Pennington et al., 2014) pre-trained vectors.
Early stopping technique is applied during training.
LEX-LSTM is trained under the same training process.
The generated data in the rumor task are labeled as R , and we denote this dataset as PHEME’.
For fairness and consistency, we train baselines LSTM, CNN, VAE-LSTM, and VAE-CNN with PHEME and PHEME+PHEME’.
For all baselines, we use two evaluation principles: (i) we hold out 10% of the data for model tuning.
(ii) Leave-one-out (L) principle, i.e., leave out one news for test, and train the models on other news.
Final results are calculated as the weighted average of all results.
L principle constructs a realistic testing scenario and evaluates the rumor detection ability under new out-of-domain data.
For DATAAUG and GAN-GRU, we import the best results reported in their papers.
For the gene classiﬁcation and mutation detection task, LEX-GAN generates a dataset NN269’ by replacing nine characters in each sequence.
We compare LEX-GAN with ﬁve models: RNN with
LSTM cells, CNN, VAE-LSTM, VAE-CNN, LEX-LSTM, and a state-of-the-art splice site predictor
EFFECT from (Kamath et al., 2014).
The ﬁrst four baselines are trained under NN269+NN269’, and tested on both NN269+NN269’ and clean data NN269.
We import EFFECT’s results from (Kamath et al., 2014).
To evaluate LEX-GAN’s generalization ability, we label the generated sequences by the following rule: if the input sequence x has label Y , then the output sequence x replace is labeled as Y (cid:48) , indicating that x replace is from class Y but with modiﬁcation.
The ﬁnal classiﬁcation output of LEX-GAN is two-fold: AP , AN for acceptor, or DP , DN for donor.
We merge the generated classes AP (cid:48) , AN (cid:48) and DP (cid:48) , DN (cid:48) with original classes to evaluate the generalization ability of
LEX-GAN. Given a sequence, LEX-GAN can classify it into one of the known classes, although the sequence could be either clean or modiﬁed.
Architecture setup of LEX-GAN is as follows.
G where is a RNN with Bidirectional LSTM (BiLSTM).
It has two hidden BiLSTM layers followed by a dense layer.
The one we used in all experiments has the architecture of EM-32-32-16-OUT, where EM, OUT represent embedding and output, respectively.
G replace is an encoder-decoder with attention mechanism.
The encoder has two GRU layers, and the decoder has two GRU layers equipped with attention mechanism.
The architecture of G replace we used in all experiments is EM-64-64-EM-64-64-OUT.
D explain has the same architecture as G where .
D classify is a CNN with two convolutional layers followed by a dense layer.
The one we used in all experiments has the architecture of EM-32-64-16-OUT.
LEX-LSTM utilizes an LSTM-based encoder-decoder with architecture EM-32-32-EM-32-32-OUT as G replace .
For baselines architecture details, see Appendix A.
[Table]
R ESULTS 5. R UMOR D ETECTION
Comparison between LEX-GAN D classify and baselines in the rumor detection task is shown in
Table 1.
In this experiment [Table] we use PHEME data to train LEX-GAN.
During training, LEX-GAN generates PHEME’ to enhance the discriminative model.
In real world applications, original clean dataset is available all the time.
However, the modiﬁed or adversarial data that contains different patterns are not always accessible.
Models like LSTM and CNN do not have generalization ability and usually perform worse facing adversarial input.
Generative models such as GANs are more robust.
In VAE-LSTM and VAE-CNN, we ﬁrst pre-train VAEs, then LSTM and CNN are trained under latent representations of pre-trained VAEs.
Under the ﬁrst evaluation principle (described in Section 4.2), LEX-GAN and LEX-LSTM outperform all baselines in terms of both macro-f1 and accuracy.
Accuracy is not sufﬁcient when the test data are not balanced, hence macro-f1 is provided for comprehensive comparison.
Under the ﬁrst evaluation principle, the robustness and generalization ability of LEX-GAN and LEX-LSTM are shown by comparing with baselines under PHEME+PHEME’.
LEX-GAN reaches the highest values in both versions of PHEME+PHEME’ and LEX-LSTM follows as the second best. Under L principle, LEX-GAN and LEX-LSTM achieves highest macro-f scores in all cases.
These results conﬁrm the rumor detection ability of the proposed layered structure under new, out-of-domain data.
Adversarial training of baselines improves generalization and robustness under PHEME+PHEME’, but hurts the performance under clean data as expected.
Although LEX-GAN and LEX-LSTM are trained adversarially, they achieves the highest macro-f  under clean data PHEME.
The results conﬁrm that LEX-GAN outperforms the baselines in terms of addressing accuracy reduction problem.
LEX-GAN’s D explain recognizes the modiﬁed parts in sequences accurately.
Its macro-f1 on PHEME’v5 and PHEME’v9 are 80 .
42% and 81 .
23% , respectively.
Examples of D explain predicting suspicious parts in rumors are shown in Table 2.
In the ﬁrst rumor, “hostage escape” is the most important part in the sentence, and if these two words are problematic, then the sentence is highly likely to be problematic.
Given an unveriﬁed or even unveriﬁable rumor, D explain provides reasonable explanation without requiring a previously collected veriﬁed news database. Additional results of LEX-GAN’s comparison with baselines can be found in Appendix B. [Table]
[Table]
G ENE C LASSIFICATION AND M UTATION D ETECTION
In this experiment, all models are trained under NN269+NN269’ to ensure fairness.
When test with
NN269+NN269’, there are 8 classes in total: AP , AN , DP , DN from NN269 and AP (cid:48) , AN (cid:48) , DP (cid:48) , DN (cid:48) from NN269’.
If solely clean data from NN269 are accessible during training, then LEX-GAN and LEX-LSTM are the only models that can recognize if a given sequence is modiﬁed or unmodiﬁed.
Comparison between LEX-GAN’s (and LEX-LSTM’s) D classify and baselines is shown in Table 3.
Under long acceptor data, baselines perform signiﬁcantly worse than LEX-GAN and LEX-LSTM.
Under short donor data, LEX-GAN and LEX-LSTM achieve highest AURoCs. This implies that LEX-GAN and LEX-LSTM are stronger when the input is long sequence. For short sequences, although LEX-GAN and LEX-LSTM provide highest AURoC, simpler models such as CNN can also give good classiﬁcation results.
Under NN269’, LEX-GAN’s D classify and D explain achieve 92 .
25% and 72 .
69% macro-f1, respectively.
Additional gene mutation detection experiments can be found in Appendix B.2. [Table] VAE-LSTM (A) 0 .0 .0 .0 .0 .0 .0 .0 .0 . 8806 VAE-CNN (A) 0 .0 .0 .0 .0 .0 .0 .0 .0 .
8411 EFFECT (A) - - 0 .
9770 ∗ - - - - - - LEX-LSTM (A) 0 .0 .0 .0 .0 .0 .0 .0 .0 .
9879 LEX-GAN (A) 0.
0.9894 LSTM (D) 0 .0 .0 .0 .0 .0 .0 .0 .0 .
CNN (D) 0 .0 .0 .0.
9596 VAE-LSTM (D) 0 .0 .0 .0 .0 .0 .0 .0 .0 .
9194 VAE-CNN (D) 0 .0 .0 .0 .0 .0 .0 .0 .0 .
9190 EFFECT (D) - - 0 .
9820 ∗ - - - - - - LEX-LSTM (D) 0 .0 .0. [Table] 5. L IMITATIONS AND E RROR C ASES IN R UMOR D ETECTION Examples of error cases of LEX-GAN in rumor detection task are presented in Table 4.
For some short sentences, D explain sometimes fails to predict the suspicious parts. The reason is that the majority of LEX-GAN’s training data are long sentences, hence for short sentences, D explain does not perform as well as in long sentences. This problem could be solved by feeding more short sentences to LEX-GAN. In most cases, although D explain does not generate predictions, D classify still can provide accurate classiﬁcation.
As shown in Table 4, D classify outputs low score, i.e., classiﬁes the input as rumor, for four out of ﬁve rumors.
[Table]
D ISCUSSION
In this work, we proposed LEX-GAN, a layered explainable text-level rumor detector based on
GAN.
We used the policy gradient method to effectively train the layered generators.
LEX-GAN outperforms the baseline models in mitigating the accuracy reduction problem, that exists in case of only clean data.
We demonstrate the classiﬁcation ability and generalization power of LEX-GAN by applying it to two applications: rumor detection and gene classiﬁcation and mutation detection.
On average, in the rumor detection task, LEX-GAN outperforms the baselines on clean dataset
PHEME and enhanced dataset PHEME+PHEME’ by 26 .
85% and 17 .
04% in terms of macro-f1, respectively.
LEX-GAN provides reasonable explanation without a previously constructed veriﬁed news database, and achieves signiﬁcantly high performance.
In the gene classiﬁcation and mutation detection task, LEX-GAN identiﬁes the mutated gene sequence with high precision.
On average,
LEX-GAN outperforms baselines in both NN269 and NN269+NN269’ (2-class) by 10 .
71% and 16 .
06% in terms of AURoC, respectively.
In both rumor detection and gene mutation detection tasks, LEX-GAN’s explainability is demonstrated by identifying the mutations accurately (above 70% macro-f1).
We found that using two discriminators to perform classiﬁcation and explanation separately achieves higher performance than using one discriminator to realize both functions.
We also found the pre-train of D classify and varying N replace contribute to the high accuracy of D explain .
As part of our future work, we would like to explore the application of hierarchical attention network (Yang et al., 2016) to improve the performance of our generative model.
We will also investigate the dependencies between the discriminators of LEX-GAN.
A B ASELINES A RCHITECTURE S ETUP
The architectures of baselines LSTM, CNN, VAE-LSTM, and VAE-CNN are deﬁned as in Table 5.
VAE-LSTM and VAE-CNN use a pre-trained VAE followed by LSTM and CNN with the architectures we deﬁned in Table 5.
The VAE we pre-trained is a LSTM-based encoder-decoder.
The encoder with architecture EM-32-32-32-OUT has two LSTM layers followed by a dense layer.
The decoder has the architecture IN-32-32-OUT, where IN stands for input layer. [Table]
B A DDITIONAL S AMPLES B. R UMOR D ETECTION T ASK
Additional results for the rumor detection task are shown in Table 6.
D explain provides reasonable explanation in most rumors.
Here we also provide two examples to demonstrate the rumor detection power of LEX-GAN compared to baselines. Two examples that are correctly detected by LEX-GAN but incorrectly detected by other baselines is shown in Table [Table] For the ﬁrst rumor, baselines CNN, LSTM, VAE-CNN
[Table] and VAE-LSTM provide scores 0 . 9802 , 0 . 9863 , 0 . [Table] and 0 . 5138 , respectively.
LEX-GAN provides a very low score for a rumor, while twin hostage situations erupt in paris two victims have been killed our updated story url pilots of crashed germanwings ﬂight declared emergency at 10 47 a m as plane fell rapidly url doomed germanwings co pilot ’suffered burnout or depression’ years before crash url url sky news australia a sixth hostage has escaped from the lindt cafe in sydney sydneysiege approximately 50 hostages may be held captive at lindt caf´e – local reports url sydneysiege url [Table] other baselines all generated relatively high scores, and even detect it as non-rumor. This is a very difﬁcult example since from the sentence itself, we as human rumor detection agents even cannot pick the suspicious parts conﬁdently.
However, LEX-GAN gives a reasonable prediction and shows that it has the ability to understand and analyze complicated rumors. For the second non-rumor, baselines CNN, LSTM, VAE-CNN, and VAE-LSTM provide scores 0 . 0029 , 0 . 6150 , and 0 . 4768 , respectively.
In this case, a non-rumor sentence gains a high score from LEX-GAN, but several relatively low scores from the baselines.
This example again conﬁrms that our proposed
LEX-GAN indeed captures the complicated nature of rumors and non-rumors.
We evaluate LEX-GAN on a molecular biology splice-junction gene sequences dataset (GENE) (Dua & Graff, 2017). GENE dataset contains 3109 splice junction gene sequences, and each sequence has 60 characters.
Splice junctions are points on a DNA sequence at which superﬂuous
DNA is removed during the process of protein creation in higher organisms (Dua & Graff, 2017).
They are labeled as exon/intron boundaries ( EI sites), intron/exon boundaries ( IE sites), or neither ( N ).
For the gene classiﬁcation and mutation detection task, LEX-GAN generates a dataset GENE’ by replacing ﬁve characters in each sequence.
We compare LEX-GAN with ﬁve models: RNN with
LSTM cells, CNN, VAE-LSTM, VAE-CNN, and a DNA classiﬁer (DNAC) from (Deshpande &
Karypis, 2002).
The ﬁrst four baselines are trained under GENE+GENE’, and tested on both
GENE+GENE’ and clean data GENE.
We import DNAC’s results from (Deshpande & Karypis, 2002).
To evaluate LEX-GAN’s generalization ability, we label the generated sequences by the following rule: if the input sequence x has label Y , then the output sequence x replace is labeled as
Y (cid:48) , indicating that x replace is from class Y but with modiﬁcation.
The ﬁnal classiﬁcation output of LEX-GAN is three-fold: EI , IE , or N .
We merge the generated classes EI (cid:48) , IE (cid:48) , N (cid:48) with original classes to evaluate the generalization ability of LEX-GAN.
Given a sequence, LEX-GAN can classify it into one of the three known classes, although the sequence could be either clean or modiﬁed.
In this experiment, all models are trained under GENE+GENE’ to ensure fairness.
When test with
GENE+GENE’, there are 6 classes in total: EI , IE , N from GENE and EI (cid:48) , IE (cid:48) , N (cid:48) from GENE’.
If solely clean data from GENE are accessible during training, then LEX-GAN is the only model that can recognize if a given sequence is modiﬁed or unmodiﬁed.
LEX-GAN can endue the baselines with this ability by generating GENE’.
Comparison between LEX-GAN’s D classify and baselines is shown in Table 8.
Baselines perform signiﬁcantly worse than LEX-GAN in 6-class classiﬁcation.
This implies that the baselines can only roughly classify a modiﬁed sequence into a known class as shown in 3-class experiment, but their ﬁne-grained classiﬁcation ability is signiﬁcantly lower than
LEX-GAN.
On GENE’, D classify and D explain achieve 91 .
80% and 89 .
49% macro-f1, respectively.
An example of D explain ’s prediction is shown in Table 9.
This suggests that LEX-GAN can not only identify whether a gene-sequence is modiﬁed from which known class, but also provide an accurate prediction that explains which part of the sequence is modiﬁed.
[Table]
Original
GGGCCCTGGCCCTGACCCAGACCTGGGCGCGTGAGTGCAGGGTCTGCAGGGAAATGGTCG Modiﬁed
GGGCCCTGGCCCTGACCCAGACCTGGGCGCGTGAGTGCAGGGTCTGCAGGGAAATGG TAS Prediction GGGCCCTGGCCCTGACCCAGACCTGGGCGCGTGAGTGCAGGGTCTGCAGGGAAATGG TAS
Original
CCCAGGAGGGGTGGACCCACAGCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC Modiﬁed
AC CAGGAGGGGTGGACCCAC N GCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC Prediction AC CAGGAGGGGTGGACCCAC N GCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC
Original
TAATCGTTGATTCCCTTCCCTCCCTCACAGAAAGCATCCCTGGAGAACAGCCTGGAGGAG Modiﬁed
TAATCGT G G SGDT CCCTTCCCTCCCTCACAGAAAGCATCCCTGGAGAACAGCCTGGAGGAG Predicted
TAATCGTGG SGDT CCCTTCCCTCCCTCACAGAAAGCATCCCTGGAGAACAGCCTGGAGGAG Original
CCCAGGAGGGGTGGACCCACAGCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC Modiﬁed
AC CAGGAGGGGTGGACCCAC G GCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC Prediction AC CAGGAGGGGTGGACCCAC G GCCCAGGGAGGCCGAAAGCGCGGGCGGGCAGGCAGAGGC