Modern weakly supervised methods for event detection (ED) avoid time-consuming human annotation and achieve promising results by learning from auto-labeled data. However, these methods typically rely on sophisticated pre-defined rules as well as existing instances in knowledge bases for automatic annotation and thus suffer from low coverage, topic bias, and data noise. To address these issues, we build a large event-related candidate set with good coverage and then apply an adversarial training mechanism to iteratively identify those informative instances from the candidate set and filter out those noisy ones. The experiments on two real-world datasets show that our candidate selection and adversarial training can cooperate together to obtain more diverse and accurate training data for ED, and significantly outperform the state-of-the-art methods in various weakly supervised scenarios. The datasets and source code can be obtained from https://github.com/ thunlp/Adv-ED . Event detection (ED) aims at detecting event triggers, which are often words or phrases evoking events in instances, and then identifying their specific event types. For example, we can extract the trigger  married  of the event  Marry  from the text Mark Twain and Olivia Langdon married in 1870. Detecting and identifying events is an important subtask of event extraction and also beneficial for various downstream NLP applications, such as question answering (Yang et al., 2003), information retrieval (Basile et al., 2014), and reading comprehension (Cheng and Erk, 2018). Hence, many efforts have been devoted to detecting event triggers and types. Most prior methods for ED are based on feature engineering, such as the token-level features (Ahn, 2006; Ji and Grishman, 2008) and the structured features (Li et al., 2013; Araki and Mitamura, 2015). As the rapid development of neural networks, various neural models have been proposed to directly embed textual semantic information into a low-dimensional space and then detect event triggers based on those feature vectors (Chen et al., 2015; Nguyen and Grishman, 2015; Nguyen et al., 2016; Ghaeini et al., 2016; Feng et al., 2016). These methods follow a supervised learning approach to train models on human-annotated data, and their requirement of human-annotated data is a bottleneck in practice. Considering weak supervision is widely adopted to take full advantages of large-scale raw data, especially some specific work for information extraction (Mintz et al., 2009; Riedel et al., 2010; Zeng et al., 2015; Cao et al., 2018), weak supervision has been explored to automatically label training data for ED (Chen et al., 2017; Zeng et al., 2018; Yang et al., 2018; Araki and Mitamura, 2018). Compared with those supervised ED methods, the weakly supervised methods can be generalized to real-world ED applications efficiently without intensive labor. Although promising results have been achieved by these weakly supervised methods, there are still some severe problems for these weakly supervised ED models: (1) Weakly supervised methods naturally suffer from the inevitable noise in data. (2) Current weakly supervised ED models adopt sophisticated pre-defined rules and incomplete knowledge bases to automatically obtain data, which results in the auto-labeled data with low coverage and topic bias. In order to construct a large-scale dataset with better coverage and reduce topic bias, we avoid adopting sophisticated pre-defined rules and heavy toolkits for semantic component analysis. Instead, D Bob [contacted] Lily by post. Figure 1 : The overall architecture of adversarial training method for ED. The event type is Contact . we propose a simple trigger-based latent instance discovery strategy, by applying an assumption that if a given word 1 serves as the trigger in a known event instance, all instances mentioning this word may also express an event. As compared with the sophisticated rules, this strategy is less restrictive in the correlation among words, triggers and event types. Hence, our strategy can obtain a candidate set covering more topics and instances without any manual design. We further propose an adversarial training mechanism like Goodfellow et al. (2014); Radford et al. (2016), which can not only distill those informative instances from the candidate set but also improve the performance of ED model on a noisy scenario such as distant supervision. As shown in Figure 1, we split the dataset into a reliable set and an unreliable set respectively, and design a discriminator and a generator. The discriminator is applied to judge whether a given instance is informative and annotated correctly, and the generator is used to select the most confusing instances from raw data to fool the discriminator. The discriminator is trained with the reliable data as positive instances and the data selected by the generator as negative ones. Meanwhile, the generator is trained to select data to fool the discriminator. During the training process, the generator can provide large amounts of latent noisy data to enhance the discriminator, and the discriminator can influ-ence the generator to select those more informative data. Since noisy data makes no effect on optimizing both the generator and the discriminator, 1 We treat phrases as words in this paper. when the generator and the discriminator reach a balance, the discriminator can boost resistance to noise and better categorize events, and the generator can effectively select informative instances to the discriminator. We conduct experiments on both semi-supervised and distantly supervised scenarios. The experimental results demonstrate that our trigger-based latent instance discovery strategy and adversarial training method can cooperate to obtain more diverse and accurate training data as well as reduce the side effect of the noise problem, and thus significantly outperform the state-of-the-art ED models. ED has attracted wide attention recently. Traditional feature-based methods (Ahn, 2006; Ji and Grishman, 2008; Gupta and Ji, 2009; Riedel et al., 2010; Hong et al., 2011; McClosky et al., 2011; Huang and Riloff, 2012a,b; Araki and Mitamura, 2015; Li et al., 2013; Yang and Mitchell, 2016; Liu et al., 2016b) rely on manually designed features to detect the event triggers and event types. With the development of neural networks, various neural methods have also been proposed (Chen et al., 2015; Nguyen and Grishman, 2015; Nguyen et al., 2016; Duan et al., 2017; Nguyen et al., 2016; Ghaeini et al., 2016; Lin et al., 2018). Furthermore, some efforts have been made to improve the performance of ED systems with external knowledge (Liu et al., 2016a, 2017), contextual information (Liu et al., 2018b), document-level information (Duan et al., 2017; Zhao et al., 2018) and multimodal integration (Zhang et al., 2017). Some advanced architectures have also been applied, such as attention mechanism (Liu et al., 2017, 2018a), graph convolutional networks (Nguyen and Grishman, 2018) and generative adversarial networks (Hong et al., 2018). All the supervised methods above rely on human-annotated data, and the data is often restricted to a small scale due to the expensive human annotation. Hence, unsupervised methods (Huang et al., 2016; Yuan et al., 2018) and various weakly supervised methods on ED are proposed. Muis et al. (2018) adopt distant supervision to create training instances for low-resource language. Araki and Mitamura (2018) adopt Word-Net (Miller et al., 1990) and rule-based methods to generate open-domain data without event-type labels. Chen et al. (2017) and Zeng et al. (2018) use distant supervision to generate large-scale data from existing structured event knowledge in knowledge bases. Liao and Grishman (2010a), Huang and Riloff (2012a) and Ferguson et al. (2018) conduct semi-supervised ED with bootstrapping. Nevertheless, due to the low coverage of existing knowledge bases as well as lack of advanced denoising mechanism, those weakly supervised methods still suffer from the problem of low coverage and noisy data. Inspired by Szegedy et al. (2013) and Goodfellow et al. (2014), adversarial training has been explored for several NLP applications recently to resist noise, such as text classification (Miyato et al., 2016) and text generation (Xie et al., 2017; Chen et al., 2018). Adversarial training has also been adopted for information extraction (Wu et al., 2017; Hong et al., 2018; Qin et al., 2018; Wang et al., 2018; Han et al., 2018). These adversarial information extraction methods either generate adversarial instances by adding simple noise perturbation to embeddings (Wu et al., 2017; Hong et al., 2018), or mainly adopt models to denoise data and neglect to discover more training instances from raw data (Qin et al., 2018; Han et al., 2018). Compared with these methods, our adversarial method samples adversarial examples from the real-world data rather than generating pseudo noisy perturbations. Furthermore, our method not only de-noises auto-labeled data but also labels unlabeled instances to extend datasets for higher coverage. Hence, our method can effectively alleviate low coverage, topic bias, and noise problem in ED. In this section, we introduce the overall framework of our proposed models for weakly supervised ED. As shown in Figure 1, the overall framework consists of three modules, including instance encoder, adversarial training strategy, and their adaption for various weakly supervised ED scenarios. The instance encoder is applied to encode the instances into its corresponding embeddings to provide semantic features for the other modules of our models. Given an instance x = { w 1 , . . . , t, . . . , w n } consisting of n words and its candidate trigger t , we adopt several effective neural models to represent the semantic features of the instance x with the embedding x . Details of the instance encoder are shown in Section 3.2. After representing instances into their embeddings by the instance encoder, an adversarial training strategy is applied, which aims at highlighting those informative instances and filtering out those noisy instances from a large-scale unreliable dataset U under the guidance of another reliable dataset R . The adversarial training strategy is the core module of our framework, and we will introduce its details in Section 3.3. Each instance x in U and R will be labeled with a trigger word t and an event type e  E . If an instance does not have a trigger and cannot express any definite events, it will be labeled with a special event NA , which indicates that the event of this instance is not available. Before applying adversarial training, U and R are automatically labeled. The details of splitting and automatically labeling U and R for various weakly supervised ED scenarios, as well as utilizing adversarial training strategy to extend datasets, will be introduced in Section 3.4. CNN After representing all words in the instance x into their input embeddings, including both word embeddings and position embeddings which encode the relative position to candidate triggers, CNN slides a convolution kernel over the input embeddings to get hidden embeddings as follows, { h 1 , . . . , h n } = CNN (cid:0) w 1 , . . . , t, . . . , w n (cid:1) . BERT Similar to CNN, after summing word piece (Wu et al., 2016), segment and position embeddings of all words in the instance x as input embeddings, BERT adopt a multi-layer bidirectional transformer encoder (Vaswani et al., 2017) to get hidden embeddings as follows, Because the candidate trigger t splits the instance x into two parts, we follow Chen et al. (2015) to adopt a dynamic multi-pooling operation over the hidden embeddings to achieve the instance embedding x , [  x ] j = max { [ h 1 ] j , . . . , [ h i ] j } , [  x ] j = max { [ h i +1 ] j , . . . , [ h n ] j } , x = [  x ;  x ] , (3) where [  ] j is the j -th value of a vector and i is the position of the trigger t . As CNN and BERT adopt a dynamic multi-pooling operation, we name them  DMCNN  and  DMBERT  in this paper. As shown in Figure 1, the overall framework of our adversarial strategy consists of a discriminator and a generator. The discriminator is adopted to detect event triggers and identify event types for each instance in datasets. When given a noisy instance, the discriminator is also expected to resist noise and explicitly point out that there are no triggers and events. The generator is used to select instances from the unreliable dataset U to confuse the discriminator as much as possible. Each instance x  R is assumed to explicitly express its labeled trigger t and event type e . In contrast, each instance x  U is assumed to be untrustworthy during the adversarial training, i.e., there is a certain probability that it is labeled incorrectly. Hence, we design the discriminator to judge whether a given instance can expose its labeled event type, which aims at maximizing the conditional probability P ( e | x, t ) , x  R and 1  P ( e | x, t ) , x  U . The generator is trained to select the most confusing instances from U to fool the discriminator, i.e., selecting the instances by P ( e | x, t ) , x  U . The training process is an adversarial min-max game as follows,  D = max (cid:0) E x  PR (cid:2) log (cid:0) P ( e | x, t ) (cid:1)(cid:3) + E x  PU (cid:2) log (cid:0) 1  P ( e | x, t ) (cid:1)(cid:3)(cid:1) ,  G = max E x  PU (cid:2) log (cid:0) P ( e | x, t ) (cid:1)(cid:3) , (4) where PR is the reliable data distribution, and the generator samples adversarial examples from the unreliable data according to the probability distribution PU . Although  D and  G are conflicting, noisy data in U has the side effect for both  D and  G . Hence, when the generator and the discriminator reaching a balance after sufficient training, the generator tends to select those informative instances with a higher probability compared with those noisy ones, and the discriminator boosts resistance to noise and can better categorize events. Given an instance x and its labeled trigger t and event type e , the discriminator is responsible for judging whether the given instance exposes its labeled trigger and event type. After representing the instance x with its embedding x , we implement the discriminator as follows, D ( e | x, t ) = e  x , P ( e | x, t ) = exp (cid:0) D ( e | x, t ) (cid:1) (cid:80)  e E exp (cid:0) D ( e | x, t ) (cid:1) , (5) where e is the embedding of the event type e  E . An optimized discriminator will assign high scores to those instances in R , and meanwhile distrust those instances and their labels in U . Hence, in practice, we formalize the loss function to optimize the discriminator as follows, LD =  (cid:88) x R 1 |R| log (cid:0) P ( e | x, t ) (cid:1)  (cid:88) x U PU ( x ) log (cid:0) 1  P ( e | x, t ) (cid:1) . (6) When optimizing the discriminator, we regard the component of the encoder and D ( e | x, t ) as parameters for updating. This loss function LD is corresponding to  D in Eq. (4). The generator aims at selecting the most confusing instances from U to cheat the discriminator. We design the generator to optimize the probability distribution PU to select instances. The generator computes confusing scores for all instances in U to evaluate their perplexity and further computes the confusing probability PU as follows, f ( x ) = W  x + b , PU ( x ) = exp (cid:0) f ( x ) (cid:1) (cid:80)  x U exp (cid:0) f ( x ) (cid:1) . (7) where x is the embedding of the instance x computed by the encoder. W and b are parameters for a separating hyperplane. We regard that the higher scores computed by the discriminator the instances have, the more confusing the instances are, because they are more likely to fool the discriminator to make a wrong decision. We expect that an optimized generator pays more attention to those most confusing instances. Hence, given an instance x  U and its unreliable-labeled trigger t and event type e , we formalize the loss function to optimize the generator as follows, LG =  (cid:88) x U PU ( x ) log (cid:0) P ( e | x, t ) (cid:1) , (8) where P ( e | x, t ) is computed by the discriminator. When optimizing the generator, we regard the component to compute PU ( x ) as parameters for updating. This loss function LG is corresponding to  G in Eq. (4). There may be some instances in U labeled NA and these instances are always wrongly predicted into some other events. Thus we specifically use the average scores over all feasible events to replace their P ( e | x, t ) in Eq. (8) as follows, P ( NA | x, t ) = 1 |E|  1 (cid:88) e E ,e (cid:54) = NAP ( e | x, t ) , (9) where E indicates the set of event types. Because there may be large amounts of instances in R and U , directly computing LD and LG is time-consuming, and frequently traversing the whole dataset of R and U also accordingly becomes difficult. For improving training efficiency, we sample subsets of R and U to approximate the essential probability distribution, and formalize a new loss function for optimization,  LD =  (cid:88) x   R 1 |  R| log (cid:0) P ( e | x, t ) (cid:1)  (cid:88) x   UP  U ( x ) log (cid:0) 1  P ( e | x, t ) (cid:1) ,  LG =  (cid:88) x   UP  U ( x ) log (cid:0) P ( e | x, t ) (cid:1) , (10) where  R and  U are the subsets sampled from R and U , and P  U is the approximation to Eq. is a hyperparameter that controls the sharpness of the probability distribution to avoid the weights concentrating on some specific instances. Finally, the overall optimization function is, L =  LD +   LG , (12) where  is a harmonic factor. In practice,  LD and  LG in adversarial training are optimized alternately, and  is also integrated into the learning rate of  LG to avoid adjusting  additionally. In this section, we introduce the adaption of adversarial training strategy for various weakly supervised ED scenarios (semi-supervised scenarios and distantly supervised scenarios), as well as the method to automatically label and split the reliable set and unreliable set used for adversarial training. To utilize unlabeled data, we propose a simple trigger-based latent instance discovery strategy, which can automatically label trigger words and event types for raw data. The trigger-based strategy is based on a heuristic assumption that if a given word serves as the trigger in a known instance, all other instances mentioning this word in raw data are latent instances and may also express an event. For example, the word  married  serves as the trigger in the instance Mark Twain and Olivia Langdon married in 1870 to expose the event  Marry , and then all instances in unlabeled data containing the word  married  will be picked up and added into a latent instance candidate set. As compared with the sophisticated rules used in existing weakly supervised ED models, our trigger-based latent instance discovery is simple, without the need of considering the correlation among words, triggers, and event types. Because our strategy is less restrictive, it is effective and efficient to obtain a large-scale candidate set without any special manual design. Meanwhile, the candidate set can cover much more instances and topics than the existing strategies. When adapting our adversarial training strategy for semi-supervised scenarios, we first use the small-scale labeled data to pretrain the encoder and discriminator to let them gain the ability to detect event triggers and identify event types to a certain extent. Then, we construct a large-scale latent candidate set based on our instance discovery strategy with the trigger words in the labeled data as heuristic seeds. We use the pretrained encoder and discriminator to automatically label triggers and event types for all instances in the candidate set to build noisy large-scale data. With the small-scale labeled data as the reliable set R and the large-scale auto-labeled data as the unreliable set U , we can optimize the encoder, discriminator, and generator together to carry out adversarial training. During the adversarial training, when the discriminator and generator reach a balance after certain training epochs, all instances from the unreliable set U recommended by the generator and regarded as being labeled correctly by the discriminator will be adjusted from U to R . Conducting adversarial training iteratively can identify informative instances and filter out noisy instances in U , and accomplish utilizing large-scale unlabeled data to enrich small-scale labeled data. The adaption for distantly supervised scenarios is similar to the adaption for semi-supervised scenarios. We first use the whole auto-labeled data to pretrain the encoder and discriminator. Then, the encoder and discriminator are used to compute confident scores for all instances in the auto-labeled set. By setting a particular threshold, we can split the whole auto-labeled set into two parts. The instances with scores higher than the threshold will be added into the reliable set R , and the other instances with lower scores will be added into the unreliable set U . After the whole auto-labeled set being split into R and U , we can conduct adversarial training to reduce the side effect of those noise in U and enhance the discriminator for better identifying events. Intuitively, the reliable set R isolated from the auto-labeled set can be used as seeds to utilize more raw data in a similar way applied in semi-supervised scenarios. We evaluate our models on both semi-supervised and distantly supervised scenarios. Before introducing the detailed experimental settings and results, we list the hyperparameters first. For DMCNN, following the settings of previous work, we use the pre-trained word embeddings learned by Skip-Gram (Mikolov et al., 2013) as the initial word embeddings. We implement DMCNN by ourselves and follow the same hyperparameters used in Chen et al. (2015) for fair comparisons. For DMBERT, we follow the same hyperparameters used for BERTBASE in Devlin et al. (2018) and apply the pre-trained model 2 to initialize the parameters. We list the essential hyperparameters of the discriminator and the generator for adversarial training in Table 1. Dropout Probability p 5  10  1 Learning Rate  gc for the generators (DMCNN) 5  10  3 Learning Rate  dc for the discriminators (DMCNN) 2  10  2 Learning Rate  gb for the generators (DMBERT) 2  10  5 Learning Rate  db for the discriminators (DMBERT) 1  10  4 Table 1: Hyperparameter settings. For distantly supervised scenarios, we utilize the distantly supervised dataset developed by Chen et al. (2017) with FreeBase (Bollacker et al., 2008). The dataset contains 142 , 611 labeled instances and 21 event types. Following previous work (Mintz et al., 2009; Chen et al., 2017), we evaluate our adversarial training mechanism by held-out evaluation. We report the precision-recall curves of recall under 0 . 7 since we mainly focus on the performance of those top-ranked results. To give a complete view of the overall performance, we also report the area under the curve (AUC). Figure 2 : The aggregated precision-recall curves of DMCNN models. Figure 3 : The aggregated precision-recall curves of DMBERT models. To evaluate the effectiveness of our proposed models, we compare our adversarial training models ( DMCNN+ADV , DMBERT+ADV ) with various neural baselines, including: (1) DMCNN and DMBERT proposed in Chen et al. (2015) and this paper respectively, which are the basic models without any adaption to the noisy distant supervision. (2) +MIL models, which improve the basic models with multi-instance learning proposed in Chen et al. (2017) to alleviate the noise problem. (3) +NA models, which simply treat the instances in the unreliable set as negative instances with the label NA . This method could be regarded as a simplified version of our adversarial training to conduct ablation study. In this experiment, we separate the reliable and unreliable set by the con-fidence of the basic models following Section 3.4. The precision-recall curves of DMCNN models and DMBERT models are shown in Figure 2 and Figure 3, and the results of AUC are shown in Table 2. From the results, we can observe that: (1) Method AUC Micro Macro DMCNN 67.6 38.7 DMCNN+MIL 75.7 43.3 DMCNN+NA 70.6 25.8 DMCNN+ADV 85.5 50.7 DMBERT 70.6 42.2 DMBERT+MIL 79.4 47.3 DMBERT+NA 74.0 38.6 DMBERT+ADV 91.5 67.6 Table 2: The AUC results (%) of various models. BERT-based models significantly outperform the CNN-based models, which is due to the ability to capture contextual information as well as large-scale pre-training of BERT. And benefiting from the effective pre-trained parameters, the BERT-based models all have high precision when the recall is under 0.3. (2) The +NA models achieve similar performance with +MIL and even outperform them in low-recall range, but +NA models have the worst macro AUC. It indicates that the separation of reliable and unreliable set is effective but also have severe side effects, and our adversarial training method works well to overcome the side effect. (3) Our adversarial training method significantly outperforms all the baselines in every metric. This demonstrates the strong ability of our method to alleviate the noise problem on distantly supervised scenarios. For semi-supervised scenarios, we conduct experiments on a widely-used benchmark dataset ACE-2005 (Walker et al., 2006) containing 599 documents annotated with 8 types and 33 subtypes of events. Following the previous work (Liao and Grishman, 2010b; Li et al., 2013; Chen et al., 2015), we use the same test set containing 40 newswire documents, development set with 30 randomly selected documents and training set with the remaining 529 documents. As described in Section 3.4, using existing triggers in ACE-2005 training set as heuristic seeds and our trigger-based latent instance discovery strategy, we construct a large-scale candidate set from the New York Times corpus (Sandhaus, 2008) and use our adversarial training strategy to filter out the noisy instances to build a new ACE-style dataset. We extend the ACE-2005 training set with the new dataset, and then test the models trained on the extended training set on the original test set. Our models trained on the original training set are named DMCNN and DMBERT , and our bootstrapped models trained on the extended dataset are named DMCNN+Boot and DMBERT+Boot . We compare our bootstrapped models with various state-of-the-art methods on the ACE-2005 dataset, including: (1) The feature-based models. We select Li's joint (Li et al., 2013) as the representative, which achieves the best performance among feature-based models. (2) The vanilla neural network models, including the DMCNN (Chen et al., 2015) and JRNN (Nguyen et al., 2016). (3) The neural network models with external information, including ANN-FN (Liu et al., 2016a) leveraging the information of FrameNet (Baker et al., 1998), DLRNN (Duan et al., 2017) using document-level information, GMLATT (Liu et al., 2018a) utilizing multilingual attentions, and the bootstrapped model DMCNN+Chen's DS (Chen et al., 2017) trained with additional data distantly supervised by FreeBase (Bollacker et al., 2008). (4) The neural network models with advanced architecture, including: Bi-LSTM+GAN (Hong et al., 2018) utilizing GAN to conduct self-regulation, GCN-ED (Nguyen and Grishman, 2018) utilizing graph convolutional network to model dependency trees. The results are shown in Table 3. From the results, we have the following observations: (1) As compared with the basic DMCNN and DMBERT , the bootstrapped models achieve signifi-cant improvement ( +1 . 7% and +0 . 5% ). Furthermore, our DMCNN+Boot model achieves similar performance with the ANN-FN and DLRNN which design complex architectures to utilize the additional information. These results indicate that our methods can construct high-quality dataset without sophisticated rules and large-scale knowledge bases, and can effectively collect diverse instances which will benefit training models. (2) DMBERT and DMBERT+Boot achieve the best performance among all the models. This is benefiting from the effective architecture and the large-scale pre-training information of BERT, as well as the dynamic multi-pooling mechanism for ED. Our methods augment the training data to further enhance BERT, which achieve better performance and demonstrate the effectiveness of our models. To perform a fine-grained evaluation for the quality of the dataset constructed with our trigger-based instance discovery strategy and adversarial training strategy, we manually evaluate the precision of the constructed dataset. To be specific, we randomly select 150 instances from the newly constructed dataset and recruit four well-trained annotators to annotate the instances independently. We ask the annotators to label an instance as correct if and only if the trigger and event-type are both correct. We use the Fleiss' kappa (Fleiss, 1971) to measure the annotation consistency among these annotators. The results of the data distilled in different iterations during adversarial training are shown in Table 4. From the results, we can observe that the precision of the dataset constructed with our models is comparable to existing distant supervision methods (Chen et al., 2017; Zeng et al., 2018) using sophisticated human-designed rules and knowledge bases, and even outperforms them in the first iteration. It indicates that our models can distill informative instances with high precision. To further show the effectiveness of our models to improve the coverage of the dataset, we give an example in Table 5. The instance in the In ACE-2005 row is a typical instance of the Sue Event-Type: Justice Subtype: Sue In ACE-2005 Dell sued for bait and switch and false promises. events, and the two instances in the Discovered row are sampled from the dataset constructed with our methods. In the Discovered row, the first instance is with an existing trigger in ACE-2005 but different in syntax, and the second instance is with a newly discovered trigger which is not contained in ACE-2005. In our extended dataset, there are 1 . 2% of the triggers are newly discovered. This demonstrates that our methods can not only find new instances from the unlabeled data which is similar to those instances in the labeled data, but also discover new triggers and extend the coverage of datasets substantially. In this paper, we take advantages of adversarial training and propose an effective method for weakly supervised ED. To be specific, our method is able to denoise and enhance distantly supervised ED models, as well as automatically construct more diverse and accurate training data for semi-supervised ED models. The experiments on two real-world datasets show that our method achieves the state-of-the-art results on the settings of both distant supervision and semi-supervision. In the future, we plan to explore the following directions: (1) We will extend our method to further extract event arguments and perform event extraction. (2) We will develop a large-scale and clean dataset for ED based on our method, which will benefit further research in this field. This work is supported by the National Key Research and Development Program of China (No. 2018YFB1004503), the National Natural Science Foundation of China (NSFC No. 61572273) and China Association for Science and Technology (2016QNRC001). Wang is also supported by the Tsinghua University Initiative Scientific Research Program.
abstain abstain method result other abstain method abstain abstain abstain abstain abstain other abstain abstain abstain method abstain abstain abstain objective abstain result abstain result abstain abstain abstain abstain method abstain method objective other other other other other other other other other other other other other other other method objective abstain abstain abstain method method abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain method abstain abstain method abstain abstain abstain method abstain abstain abstain method method abstain method abstain abstain abstain method abstain abstain other abstain abstain abstain method abstain abstain abstain method abstain abstain abstain method method method abstain abstain abstain abstain abstain method abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain method method abstain result abstain abstain abstain abstain result abstain method method abstain abstain method method abstain abstain other abstain abstain result result result abstain abstain abstain method method abstain method abstain abstain abstain abstain abstain method abstain abstain abstain abstain objective method result objective objective other other