We introduce KBGAN , an adversarial learning framework to improve the performances of a wide range of existing knowledge graph embedding models. Because knowledge graphs typically only contain positive facts, sampling useful negative training examples is a nontrivial task. Replacing the head or tail entity of a fact with a uniformly randomly selected entity is a conventional method for generating negative facts, but the majority of the generated negative facts can be easily discriminated from positive facts, and will contribute little towards the training. Inspired by generative adversarial networks ( GAN s), we use one knowledge graph embedding model as a negative sample generator to assist the training of our desired model, which acts as the discriminator in GAN s. This framework is inde-pendent of the concrete form of generator and discriminator, and therefore can utilize a wide variety of knowledge graph embedding models as its building blocks. In experiments, we adversarially train two translation-based models, TRANSE and TRANSD, each with assistance from one of the two probability-based models, DISTMULT and COMPLEX . We evaluate the performances of KBGAN on the link prediction task, using three knowledge base completion datasets: FB15k-237, WN18 and WN18RR. Experimental results show that adversarial training substantially improves the performances of target embedding models under various settings. Knowledge graph (Dong et al., 2014) is a powerful graph structure that can provide direct access of knowledge to users via various applications such as structured search, question answering, and intelligent virtual assistant. A common representation of knowledge graph beliefs is in the form of a discrete relational triple such as Locate-dIn(NewOrleans,Louisiana) . A main challenge for using discrete representation of knowledge graph is the lack of capability of accessing the similarities among different entities and relations. Knowledge graph embedding (KGE) techniques (e.g., RESCAL (Nickel et al., 2011), TRANSE (Bordes et al., 2013), DISTMULT (Yang et al., 2015), and COMPLEX (Trouil-lon et al., 2016)) have been proposed in recent years to deal with the issue. The main idea is to represent the entities and relations in a vector space, and one can use machine learning technique to learn the continuous representation of the knowledge graph in the latent space. However, even steady progress has been made in developing novel algorithms for knowledge graph embedding, there is still a common challenge in this line of research. For space effi-ciency, common knowledge graphs such as Freebase (Bollacker et al., 2008), Yago (Suchanek et al., 2007), and NELL (Mitchell et al., 2015) by default only stores beliefs, rather than disbeliefs. Therefore, when training the embedding models, there is only the natural presence of the positive examples. To use negative examples, a common method is to remove the correct tail entity, and randomly sample from a uniform distribution (Bordes et al., 2013). Unfortunately, this approach is not ideal, because the sampled entity could be completely unrelated to the head and the target relation, and thus the quality of randomly generated negative examples is often poor (e.g, Locate-dIn(NewOrleans,BarackObama) ). Other approach might leverage external ontological constraints such as entity types (Krompa et al., 2015) to generate negative examples, but such resource does not always exist or accessible. Table 1 : Some selected knowledge graph embedding models. The four models above the double line are considered in this paper. Except for COMPLEX , all boldface lower case letters represent vectors in R k , and boldface upper case letters represent matrices in R k  k . I is the identity matrix. edge graph embedding models. Inspired by the recent advances of generative adversarial deep models (Goodfellow et al., 2014), we propose a novel adversarial learning framework, namely, KBGAN , for generating better negative examples to train knowledge graph embedding models. More specifically, we consider probability-based, log-loss embedding models as the generator to supply better quality negative examples, and use distance-based, margin-loss embedding models as the discriminator to generate the final knowledge graph embeddings. Since the generator has a discrete generation step, we cannot directly use the gradient-based approach to back-propagate the errors. We then consider a one-step reinforcement learning setting, and use a variance-reduction REINFORCE method to achieve this goal. Empirically, we perform experiments on three common KGE datasets (FB15K-237, WN18 and WN18RR), and verify the adversarial learning approach with a set of KGE models. Our experiments show that across various settings, this adversarial learning mechanism can significantly improve the performance of some of the most commonly used translation based KGE methods. Our contributions are three-fold:  We are the first to consider adversarial learning to generate useful negative training examples to improve knowledge graph embedding. This adversarial learning framework applies to a wide range of KGE models, without the need of external ontologies constraints. Our method shows consistent performance gains on three commonly used KGE datasets. A large number of knowledge graph embedding models, which represent entities and relations in a knowledge graph with vectors or matrices, have been proposed in recent years. RESCAL (Nickel et al., 2011) is one of the earliest studies on matrix factorization based knowledge graph embedding models, using a bilinear form as score function. TRANSE (Bordes et al., 2013) is the first model to introduce translation-based embedding. Later variants, such as TRANSH (Wang et al., 2014), TRANSR (Lin et al., 2015) and TRANSD (Ji et al., 2015), extend TRANSE by projecting the embedding vectors of entities into various spaces. DISTMULT (Yang et al., 2015) simplifies RESCAL by only using a diagonal matrix, and COMPLEX (Trouillon et al., 2016) extends DISTMULT into the complex number field. (Nickel et al., 2015) is a comprehensive survey on these models. Some of the more recent models achieve strong performances. MANIFOLDE (Xiao et al., 2016) embeds a triple as a manifold rather than a point. HOLE (Nickel et al., 2016) employs circular correlation to combine the two entities in a triple. CONVE (Dettmers et al., 2017) uses a convolutional neural network as the score function. However, most of these studies use uniform sampling to generate negative training examples (Bordes et al., 2013). Because our framework is indepen-dent of the concrete form of models, all these models can be potentially incorporated into our framework, regardless of the complexity. As a proof of principle, our work focuses on simpler models. Table 1 summarizes the score functions and dimensions of all models mentioned above. Generative Adversarial Networks ( GAN s) (Good-fellow et al., 2014) was originally proposed for generating samples in a continuous space such as images. AGAN consists of two parts, the generator and the discriminator . The generator accepts a noise input and outputs an image. The discriminator is a classifier which classifies images as true (from the ground truth set) or fake (generated by the generator). When training a GAN , the generator and the discriminator play a minimax game, in which the generator tries to generate real images to deceive the discriminator, and the discriminator tries to tell them apart from ground truth images. GAN s are also capable of generating samples satisfying certain requirements, such as conditional GAN (Mirza and Osindero, 2014). It is not possible to use GAN s in its original form for generating discrete samples like natural language sentences or knowledge graph triples, because the discrete sampling step prevents gradients from propagating back to the generator. SEQGAN (Yu et al., 2017) is one of the first successful solutions to this problem by using reinforcement learningIt trains the generator using policy gradient and other tricks. IRGAN (Wang et al., 2017) is a recent work which combines two categories of information retrieval models into a discrete GAN framework. Likewise, our framework relies on policy gradient to train the generator which provides discrete negative triples. The discriminator in a GAN is not necessarily a classifier. Wasserstein GAN or WGAN (Arjovsky et al., 2017) uses a regressor with clipped parameters as its discriminator, based on solid analysis about the mathematical nature of GAN s. GOGAN (Juefei-Xu et al., 2017) further replaces the loss function in WGAN with marginal loss. Although originating from very different fields, the form of loss function in our framework turns out to be more closely related to the one in GOGAN . In this section, we first define two types of training objectives in knowledge graph embedding models to show how KBGAN can be applied. Then, we demonstrate a long overlooked problem about negative sampling which motivates us to propose KBGAN to address the problem. Finally, we dive into the mathematical, and algorithmic details of KBGAN . For a given knowledge graph, let E be the set of entities, R be the set of relations, and T be the set of ground truth triples. In general, a knowledge graph embedding (KGE) model can be formulated as a score function f ( h, r, t ) , h, t  E , r  R which assigns a score to every possible triple in the knowledge graph. The estimated likelihood of a triple to be true depends only on its score given by the score function. Different models formulate their score function based on different designs, and therefore interpret scores differently, which further lead to various training objectives. Two common forms of training objectives are particularly of our interest: Marginal loss function is commonly used by a large group of models called translation-based models, whose score function models distance between points or vectors, such as TRANSE, TRANSH, TRANSR, TRANSD and so on. In these models, smaller distance indicates a higher likelihood of truth, but only qualitatively. The marginal loss function takes the following form: L m = X ( h,r,t ) T [ f ( h, r, t )  f ( h 0 , r, t 0 ) +  ] + (1) where  is the margin, [  ] + = max(0 ,  ) is the hinge function, and ( h 0 , r, t 0 ) is a negative triple. The negative triple is generated by replacing the head entity or the tail entity of a positive triple with a random entity in the knowledge graph, or formally ( h 0 , r, t 0 )  { ( h 0 , r, t ) | h 0  E}  { ( h, r, t 0 ) | t 0  E} . Log-softmax loss function is commonly used by models whose score function has probabilistic interpretation. Some notable examples are RESCAL , DISTMULT , COMPLEX . Applying the softmax function on scores of a given set of triples gives the probability of a triple to be the best one among them: p ( h, r, t ) = exp f ( h,r,t ) P ( h 0 ,r,t 0 ) exp f ( h 0 ,r,t 0 ) . The loss function is the negative log-likelihood of this probabilistic model: L l = X ( h,r,t ) T  log exp f ( h, r, t ) P exp f ( h 0 , r, t 0 ) ( h 0 , r, t 0 )  { ( h, r, t ) }  Neg ( h, r, t ) (2) where Neg ( h, r, t )  { ( h 0 , r, t ) | h 0  E}  { ( h, r, t 0 ) | t 0  E} is a set of sampled corrupted triples. Figure 1 : An overview of the KBGAN framework. The generator (G) calculates a probability distribution over a set of candidate negative triples, then sample one triples from the distribution as the output. The discriminator (D) receives the generated negative triple as well as the ground truth triple (in the hexagonal box), and calculates their scores. G minimizes the score of the generated negative triple by policy gradient, and D minimizes the marginal loss between positive and negative triples by gradient descent. Other forms of loss functions exist, for example CONVE uses a triple-wise logistic function to model how likely the triple is true, but by far the two described above are the most common. Also, softmax function gives an probabilistic distribution over a set of triples, which is necessary for a generator to sample from them. Most previous KGE models use uniform negative sampling for generating negative triples, that is, replacing the head or tail entity of a positive triple with any of the entities in E , all with equal probability. Most of the negative triples generated in this way contribute little to learning an effective embedding, because they are too obviously false. To demonstrate this issue, let us consider the following example. Suppose we have a ground truth triple LocatedIn(NewOrleans,Louisiana) , and corrupt it by replacing its tail entity. First, we remove the tail entity, leaving Lo-catedIn(NewOrleans,?) . Because the relation Lo-catedIn constraints types of its entities, ? must be a geographical region. If we fill ? with a random entity e  E , the probability of e having a wrong type is very high, resulting in ridiculous triples like Lo-catedIn(NewOrleans,BarackObama) or Locate-dIn(NewOrleans,StarTrek) . Such triples are considered too easy, because they can be eliminated solely by types. In contrast, Locate-dIn(NewOrleans,Florida) is a very useful negative triple, because it satisfies type constraints, but it cannot be proved wrong without detailed knowledge of American geography. If a KGE model is fed with mostly too easy negative examples, it would probably only learn to represent types, not the underlying semantics. The problem is less severe to models using log-softmax loss function, because they typically samples tens or hundreds of negative triples for one positive triple in each iteration, and it is likely to have a few useful negatives among them. For instance, (Trouillon et al., 2016) found that a 100:1 negative-to-positive ratio results in the best performance for COMPLEX . However, for marginal loss function, whose negative-to-positive ratio is always 1:1, the low quality of uniformly sampled negatives can seriously damage their performance. Inspired by GANs, we propose an adversarial training framework named KBGAN which uses a KGE model with softmax probabilities to provide high-quality negative samples for the training of a KGE model whose training objective is marginal loss function . This framework is inde-pendent of the score functions of these two models, and therefore possesses some extent of universality. Figure 1 illustrates the overall structure of KBGAN . In parallel to terminologies used in GAN literature, we will simply call these two models generator and discriminator respectively in the rest of this paper. We use softmax probabilistic models as the generator because they can adequately model the sampling from a probability distribu-1473 Algorithm 1: The KBGAN algorithm Data: training set of positive fact triples T = { ( h, r, t ) } Input: Pre-trained generator G with parameters  G and score function f G ( h, r, t ) , and pre-trained discriminator D with parameters  D and score function f D ( h, r, t ) Output: Adversarially trained discriminator 1 b  0 ; // baseline for policy gradient 2 repeat 3 Sample a mini-batch of data T batch from T ; 4 GG  0 , GD  0 ; // gradients of parameters of G and D 5 r sum  0 ; // for calculating the baseline 6 for ( h, r, t )  T batch do 7 Uniformly randomly sample N s negative triples Neg ( h, r, t ) = { ( h 0 i , r, t 0 i ) } i =1 ...N s ; 8 Obtain their probability of being generated: p i = exp f G ( h 0 i ,r,t 0 i ) P Nsj =1 exp f G ( h 0 j ,r,t 0 j ) ; 9 Sample one negative triple ( h 0 s , r, t 0 s ) from Neg ( h, r, t ) according to { p i } i =1 ...N s . Assume its probability to be p s ; 10 GD  GD +   D [ f D ( h, r, t )  f D ( h 0 s , r, t 0 s ) +  ] + ; // accumulate gradients for D 11 r   f D ( h 0 s , r, t 0 s ) , r sum  r sum + r ; // r is the reward 12 GG  GG + ( r  b )   G log p s ; // accumulate gradients for G 13 end 14  G   G +  GGG ,  D   D   DGD ; // update parameters 15 b  r sum / |T batch | ; // update baseline 16 until convergence ; tion process of discrete GAN s, and we aim at improving discriminators based on marginal loss because they can benefit more from high-quality negative samples. Note that a major difference between GAN and our work is that, the ultimate goal of our framework is to produce a good discriminator, whereas GANS are aimed at training a good generator. In addition, the discriminator here is not a classifier as it would be in most GAN s. Intuitively, the discriminator should assign a relatively small distance to a high-quality negative sample. In order to encourage the generator to generate useful negative samples, the objective of the generator is to minimize the distance given by discriminator for its generated triples. And just like the ordinary training process, the objective of the discriminator is to minimize the marginal loss between the positive triple and the generated negative triple. In an adversarial training setting, the generator and the discriminator are alternatively trained towards their respective objectives. Suppose that the generator produces a probability distribution on negative triples p G ( h 0 , r, t 0 | h, r, t ) given a positive triple ( h, r, t ) , and generates negative triples ( h 0 , r, t 0 ) by sampling from this distribution. Let f D ( h, r, t ) be the score function of the discriminator. The objective of the discriminator can be formulated as minimizing the following marginal loss function: LD = X ( h,r,t ) T [ f D ( h, r, t )  f D ( h 0 , r, t 0 ) +  ] + ( h 0 , r, t 0 )  p G ( h 0 , r, t 0 | h, r, t ) (3) The only difference between this loss function and Equation 1 is that it uses negative samples from the generator. The objective of the generator can be formulated as maximizing the following expectation of negative distances: RG = X ( h,r,t ) T E [  f D ( h 0 , r, t 0 )] ( h 0 , r, t 0 )  p G ( h 0 , r, t 0 | h, r, t ) (4) RG involves a discrete sampling step, so we cannot find its gradient with simple differentiation. We use a simple special case of Policy Gradient Theorem 1 (Sutton et al., 2000) to obtain the gradient of RG with respect to parameters of the generator:  GRG = X ( h,r,t ) T E ( h 0 ,r,t 0 )  p G ( h 0 ,r,t 0 | h,r,t ) [  f D ( h 0 , r, t 0 )  G log p G ( h 0 , r, t 0 | h, r, t )] ' X ( h,r,t ) T 1 NX ( h 0 i ,r,t 0 i )  p G ( h 0 ,r,t 0 | h,r,t ) ,i =1 ...N [  f D ( h 0 , r, t 0 )  G log p G ( h 0 , r, t 0 | h, r, t )] (5) 1 A proof can be found in the supplementary material 1474 Model Hyperparameters Constraints or Regularizations TRANSE L 1 distance, k = 50 ,  = 3 || e || 2  1 , || r || 2  1 TRANSD L 1 distance, k = 50 ,  = 3 || e || 2  1 , || r || 2  1 , || e p || 2  1 , || r p || 2  1 DISTMULT k = 50 ,  = 1 / 0 . Table 2 : Hyperparameter settings of the 4 models we used. For DISTMULT and COMPLEX ,  = 1 is used for FB15k-237 and  = 0 . 1 is used for WN18 and WN18RR. All other hyperparameters are shared among all datasets. L is the global loss defined in Equation (2). represents all parameters in the model. where the second approximate equality means we approximate the expectation with sampling in practice. Now we can calculate the gradient of RG and optimize it with gradient-based algorithms. Policy Gradient Theorem arises from reinforcement learning (RL), so we would like to draw an analogy between our model and an RL model. The generator can be viewed as an agent which interacts with the environment by performing actions and improves itself by maximizing the reward returned from the environment in response of its actions. Correspondingly, the discriminator can be viewed as the environment. Using RL terminologies, ( h, r, t ) is the state (which determines what actions the actor can take), p G ( h 0 , r, t 0 | h, r, t ) is the policy (how the actor choose actions), ( h 0 , r, t 0 ) is the action , and  f D ( h 0 , r, t 0 ) is the reward . The method of optimizing RG described above is called REINFORCE (Williams, 1992) algorithm in RL. Our model is a simple special case of RL, called one-step RL. In a typical RL setting, each action performed by the agent will change its state, and the agent will perform a series of actions (called an epoch ) until it reaches certain states or the number of actions reaches a certain limit. However, in the analogy above, actions does not affect the state, and after each action we restart with another unrelated state, so each epoch consists of only one action. To reduce the variance of REINFORCE algorithm, it is common to subtract a baseline from the reward, which is an arbitrary number that only depends on the state, without affecting the expectation of gradients. 2 In our case, we replace  f D ( h 0 , r, t 0 ) with  f D ( h 0 , r, t 0 )  b ( h, r, t ) in the equation above to introduce the baseline. To avoid introducing new parameters, we simply let b be a constant, the average reward of the whole training set: b = P ( h,r,t ) T E ( h 0 ,r,t 0 )  p G ( h 0 ,r,t 0 | h,r,t ) [  f D ( h 0 , r, t 0 )] . In practice, b is approximated by the mean of rewards of recently generated negative triples. Let the generator's score function to be f G ( h, r, t ) , given a set of candidate negative triples Neg ( h, r, t )  { ( h 0 , r, t ) | h 0  E}{ ( h, r, t 0 ) | t 0  E} , the probability distribution p G is modeled as: p G ( h 0 , r, t 0 | h, r, t ) = exp f G ( h 0 , r, t 0 ) P exp f G ( h  , r, t  ) ( h  , r, t  )  Neg ( h, r, t ) (6) Ideally, Neg ( h, r, t ) should contain all possible negatives. However, knowledge graphs are usually highly incomplete, so the hardest negative triples are very likely to be false negatives (true facts). To address this issue, we instead generate Neg ( h, r, t ) by uniformly sampling of N s entities (a small number compared to the number of all possible negatives) from E to replace h or t . Because in real-world knowledge graphs, true negatives are usually far more than false negatives, such set would be unlikely to contain any false negative, and the negative selected by the generator would likely be a true negative. Using a small Neg ( h, r, t ) can also significantly reduce computational complexity. Besides, we adopt the bern sampling technique (Wang et al., 2014) which replaces the 1 side in 1-to-N and N-to-1 relations with higher probability to further reduce false negatives. Algorithm 1 summarizes the whole adversarial training process. Both the generator and the dis-2 A proof of such fact can also be found in the supplementary material 1475 criminator require pre-training, which is the same as conventionally training a single KBE model with uniform negative sampling. Formally speaking, one can pre-train the generator by minimizing the loss function defined in Equation (1), and pre-train the discriminator by minimizing the loss function defined in Equation (2). Line 14 in the algorithm assumes that we are using the vanilla gradient descent as the optimization method, but obviously one can substitute it with any gradient-based optimization algorithm. To evaluate our proposed framework, we test its performance for the link prediction task with different generators and discriminators. For the generator, we choose two classical probability-based KGE model, DISTMULT and COMPLEX , and for the discriminator, we also choose two classical translation-based KGE model, TRANSE and TRANSD, resulting in four possible combinations of generator and discriminator in total. See Table 1 for a brief summary of these models. We use three common knowledge base completion datasets for our experiment: FB15k-237, WN18 and WN18RR. FB15k-237 is a subset of FB15k introduced by (Toutanova and Chen, 2015), which removed redundant relations in FB15k and greatly reduced the number of relations. Likewise, WN18RR is a subset of WN18 introduced by (Dettmers et al., 2017) which removes reversing relations and dramatically increases the difficulty of reasoning. Both FB15k and WN18 are first introduced by (Bordes et al., 2013) and have been commonly used in knowledge graph researches. Statistics of datasets we used are shown in Table 3. Following previous works like (Yang et al., 2015) and (Trouillon et al., 2016), for each run, we report two common metrics, mean reciprocal ranking (MRR) and hits at 10 (H@10). We only report scores under the filtered setting (Bordes et al., 2013), which removes all triples appeared in training, validating, and testing sets from candidate triples before obtaining the rank of the ground truth triple. 3 In the pre-training stage, we train every model to convergence for 1000 epochs, and divide every epoch into 100 mini-batches. To avoid overfit-ting, we adopt early stopping by evaluating MRR on the validation set every 50 epochs. We tried  = 0 . 5 , 1 , 2 , 3 , 4 , 5 and L 1 , L 2 distances for TRANSE and TRANSD, and  = 0 . 01 , 0 . 1 , 1 , 10 for DISTMULT and COMPLEX , and determined the best hyperparameters listed on table 2, based on their performances on the validation set after pre-training. Due to limited computation resources, we deliberately limit the dimensions of embeddings to k = 50 , similar to the one used in earlier works, to save time. We also apply certain constraints or regularizations to these models, which are mostly the same as those described in their original publications, and also listed on table 2. In the adversarial training stage, we keep all the hyperparamters determined in the pre-training stage unchanged. The number of candidate negative triples, N s , is set to 20 in all cases, which is proven to be optimal among the candidate set of { 5 , 10 , 20 , 30 , 50 } . We train for 5000 epochs, with 100 mini-batches for each epoch. We also use early stopping in adversarial training by evaluating MRR on the validation set every 100 epochs. We use the self-adaptive optimization method Adam (Kingma and Ba, 2015) for all trainings, and always use the recommended default setting  = 0 . 001 ,  1 = 0 . 9 ,  2 = 0 . 999 , (cid:15) = 10  8 . Results of our experiments as well as baselines are shown in Table 4. All settings of adversarial training bring a pronounced improvement to the model, which indicates that our method is consistently effective in various cases. TRANSE performs slightly worse than TRANSD on FB15k-237 and WN18, but better on WN18RR. Using DISTMULT or COMPLEX as the generator does not affect performance greatly. TRANSE and TRANSD enhanced by KBGAN can significantly beat their corresponding baseline implementations, and outperform stronger baselines in some cases. As a prototypical and proof-of-principle experiment, we have never expected state-of-the-art results. Being simple models pro-3 The KBGAN source code is available at https:// github.com/cai-lw/KBGAN 1476 FB15k-237 WN18 WN18RR Method MRR H@10 MRR H@10 MRR H@10 TRANSE -42.8  -89.2 -43.2  TRANSD -45.3  -92.2 -42.8  DISTMULT 24.1  41.9  82.2 93.6 42.5  49.1  COMPLEX 24.0  41.9  94.1 94.7 44.4  50.7  TRANSE (pre-trained) 24.2 42.2 43.3 91.5 18.6 45.9 KBGAN (TRANSE + DISTMULT ) 27.4 45.0 71.0 94.9 21.3 48.1 KBGAN (TRANSE + COMPLEX ) 27.8 45.3 70.5 94.9 21.0 47.9 TRANSD (pre-trained) 24.5 42.7 49.4 92.8 19.2 46.5 KBGAN (TRANSD + DISTMULT ) 27.8 45.8 77.2 94.8 21.4 47.2 KBGAN (TRANSD + COMPLEX ) 27.7 45.8 77.9 94.8 21.5 46.9 Table 4 : Experimental results. Results of KBGAN are results of its discriminator (on the left of the + sign). Underlined results are the best ones among our implementations. Results marked with  are produced by running Fast-TransX (Lin et al., 2015) with its default parameters. Results marked with  are copied from (Dettmers et al., 2017). All other baseline results are copied from their original papers. Figure 2 : Learning curves of KBGAN . All metrics improve steadily as training proceeds. posed several years ago, TRANSE and TRANSD has their limitations in expressiveness that are unlikely to be fully compensated by better training technique. In future researches, people may try employing more advanced models into KBGAN , and we believe it has the potential to become state-of-the-art. To illustrate our training progress, we plot performances of the discriminator on validation set over epochs, which are displayed in Figure 2. As all these graphs show, our performances are always in increasing trends, converging to its maximum as training proceeds, which indicates that KBGAN is a robust GAN that can converge to good results in various settings, although GAN s are wellknown for difficulty in convergence. Fluctuations in these graphs may seem more prominent than other KGE models, but is considered normal for an adversially trained model. Note that in some cases the curve still tends to rise after 5000 epochs. We do not have sufficient computation resource to train for more epochs, but we believe that they will also eventually converge. Table 5 : Examples of negative samples in WN18 dataset. The first column is the positive fact, and the term in bold is the one to be replaced by an entity in the next two columns. The second column consists of random entities drawn from the whole dataset. The third column contains negative samples generated by the generator in the last 5 epochs of training. Entities in italic are considered to have semantic relation to the positive one 4.3 Case study To demonstrate that our approach does generate better negative samples, we list some examples of them in Table 5, using the KBGAN (TRANSE + DISTMULT ) model and the WN18 dataset. All hyperparameters are the same as those described in Section 4.1.3. Compared to uniform random negatives which are almost always totally unrelated, the generator generates more semantically related negative samples, which is different from type relatedness we used as example in Section 3.2, but also helps training. In the first example, two of the five terms are physically related to the process of distilling liquids. In the second example, three of the five entities are geographical objects. In the third example, two of the five entities express the concept of gather. Because we deliberately limited the strength of generated negatives by using a small N s as described in Section 3.3, the semantic relation is pretty weak, and there are still many unrelated entities. However, empirical results (when selecting the optimal N s ) shows that such situation is more beneficial for training the discriminator than generating even stronger negatives. We propose a novel adversarial learning method for improving a wide range of knowledge graph embedding modelsWe designed a generator-discriminator framework with dual KGE components. Unlike random uniform sampling, the generator model generates higher quality negative examples, which allow the discriminator model to learn better. To enable backpropagation of error, we introduced a one-step REINFORCE method to seamlessly integrate the two modules. Experimentally, we tested the proposed ideas with four commonly used KGE models on three datasets, and the results showed that the adversarial learning framework brought consistent improvements to various KGE models under different settings.
result abstain abstain method abstain method method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method method objective result result objective objective result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method method method abstain abstain abstain abstain method abstain other abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain method method method abstain method abstain abstain abstain abstain abstain abstain method abstain abstain method method method abstain abstain abstain abstain abstain abstain abstain other method method method abstain abstain abstain abstain abstain method method method abstain abstain other abstain method abstain method abstain method method abstain other abstain method abstain abstain method abstain abstain abstain method abstain result abstain abstain abstain abstain abstain result abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain result other abstain result abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain abstain objective