Many Knowledge Graphs (KGs), such as Freebase (Bollacker et al., 2008) and YAGO (Suchanek et al., 2007), have been built in recent years and led to a broad range of applications, including question answering (Cui et al., 2017), relation extraction (Wang et al., 2018), and recommender system (Zhang et al., 2016). KGs store facts as triples in the form of (subject entity, relation, object entity), abridged as . Some KGs also have an ontology with class and property expression axioms which place constraints on classes and types of relationships.
Knowledge graph reasoning (KGR) can infer new knowledge based on existing ones and check knowledge consistency. It is attracting research interest and is important for completing and cleaning up KGs. Two of the most common learning methods for KGR are embedding-based reasoning and rule-based reasoning (Nickel et al., 2016a).
One of the crucial tasks for embedding-based and rule-based reasoning is to learn embeddings and rules respectively. Embedding learning methods such as TransE (Bordes et al., 2013), HolE (Nickel et al., 2016b) and ComplEx (Trouillon et al., 2016)
learn latent representations of entities and relations in continuous vector spaces, calledembeddings, so as to preserve the information and semantics in KGs. Embedding-based reasoning is more efficient when there are a large number of relations or triples to reason over. Rule learning methods such as AMIE(Galárraga et al., 2013) aim to learn deductive and interpretable inference rules. Rule-based reasoning is precise and can provide insights for inference results.
With different advantages, both embedding and rule learning are important for KGR, while they still have their own difficulties and weaknesses.
Sparsity Problem for Embedding Learning. One of the main difficulties for embedding learning is the poor capability of encoding sparse entities. For example, Figure 1 shows correlation between entity frequency and entity link prediction results measured in mean reciprocal rank (MRR), where higher values means better results. In Figure 1, the blue line shows there are a large portion of entities having only a few triples, revealing the common existence of sparse entity. The yellow line shows that the prediction results of entities are highly related to their frequency, and the results of sparse entities are much worse than those of frequent ones.
Efficiency Problem for Rule Learning. The main difficulty in rule learning is the huge search space when determining rule structures and searching for support triples. For example, with a small KG containing relations and entities, the number of possible structures for a rule with relations is and the maximum number of supports for these rules is . Since the search space is exponential to the number of relations, it will be much larger for real KGs than this example.
With different advantages and difficulties, we argue that embedding learning and rule learning can benefit and complement each other. On the one hand, deductive rules can infer additional triples for sparse entities and help embedding learning methods encode them better. On the other hand, embeddings encoded with rich semantics can turn rule learning from discrete graph search into vector space calculation, so that reduce the search space significantly. Thus we raise the research question: whether it is possible to learn embeddings and rules at the same time and make their advantages complement to each other’s difficulties.
In this paper, we propose a novel framework IterE that iteratively learns embeddings and rules, which can combine many embedding methods and different kinds of rules. Especially, we consider linear map assumption (Section 2.1) for embedding learning because it is inherently friendly for rule learning as there are special rule conclusions for relation embeddings in rules (Table 2). We also consider a particular collection of object property axioms defined in OWL2 (Table 1) for rule learning considering that semantics included in web ontology language are important for the development of knowledge graph.
IterE mainly includes three parts: (1) embedding learning, (2) axiom induction, and (3) axiom injection. Embedding learning learns embeddings for entities and relations, with input including triples existing in KG and those inferred by rules. Axiom induction first generates a pool of possible axioms with an effective pruning strategy proposed in this paper and then assigns a score to each axiom in the pool based on calculation between relation embeddings according to rule conclusions from linear map assumption. Axiom injection utilizes axioms’ deductive capability to infer new triples about sparse entities according to axiom groundings and injects these new triples into KG to improve sparse entity embeddings. These three parts are conducted iteratively during training.
We evaluate IterE from three perspectives, 1) whether axiom improves sparse embeddings’ quality and their predictions, 2) whether embedding helps improve rule learning efficiency and quality, and 3) how iterative training improves both embedding and rule learning during training. The experiment results show that IterE achieves both better link prediction performance and high quality rule learning results. These support our goal of making IterE complement the strengths of embedding and rule learning.
Contributions of our work are as follows:
We propose an iterative framework that combines embedding learning and rule learning to explore the mutual benefits between them. Experiments show that it leads to better link prediction results using rules and embeddings together.
We present a new method for embedding learning with rules based on axiom injection through t-norm based fuzzy logics. Experiments show that IterE can significantly improve embedding quality for the sparse part of a knowledge graph.
We further identify a portfolio of ontology axioms for rule learning with embedding based on linear map assumption. Experiments show that IterE learns more high quality rules more efficiently than conventional rule learning systems.
|Object Property Axiom||Condition||Rule Form|
|implies (x,x)||111 the translated rule form of only contain a head.|
|for each and each|
|and … and|
2.1. Knowledge graph embedding
A KG contains a set of entities , a set of relations and a set of triples . In a triple , the symbols and denote subject entity, relation, and object entity respectively. An example of such triple is .
Knowledge graph embedding (KGE) aims to embed all entities and relations in a continuous vector space, usually as vectors or matrices called
. Embeddings can be used to estimate the likelihood of a triple to be true via a score function. Concrete score functions are defined based on different vector space assumptions. We now describe two vector space assumptions commonly used in KGEs and their corresponding score functions.
(a) Translation-based assumption embeds entities and relations as vectors and assumes , in which and are vector embeddings for and respectively. For a true triple, the relation-specific translation of subject embedding () is close to the object embedding in embeddings’ vector space.
(b) Linear map assumption embeds entities as vectors and relations as matrices. It assumes that the subject entity embedding can be linearly mapped to object entity embedding via relation embedding . In this case, for a true triple, the linear mapping of the subject embedding by the relation matrix () is close to the object embedding in embeddings’ vector space.
Thus the score function of two assumptions can be written as:
where calculates the similarity between vector and .
From the assumption point of view, (or
) should exactly hold for true triples in the linear-map assumption (or translation-based assumption). From the modeling point of view, this is the optimization goal during learning, namely to be as close as possible to the equation in assumption. The learning process is done through either maximizing the objective or minimizing the error induced from assumptions given by their respective loss functions. Hence, the assumption equation usually does not exactly hold with learned embeddings, but their loss functions are designed to approach the assumption as much as possible.
In this paper, we adopt linear map assumption for embedding learning because many reasonable rule conclusions can be derived with relation embeddings based on this assumption (Table 2).
2.2. Rules Learning
Suppose is a countable set of variables and a countable set of constants. A rule is of the form , where is an atom over and body is a conjunction of positive or negative atoms over . An example of such rule can be:
When replacing all variables in a rule with concrete entities in KG, we get a of the rule. For example, one grounding of Rule (2) can be:
The results of rule learning is of the following form:
in which is a confidence score assigned to the rule by the learning method.
Incorporating logical rules into other learning system such as embedding learning is called rule injection. One way for rule injection is adding regularizer or other constraints to entity and relation representations by propositionalizing the rules. Another way is adding constraints to the constituent relations’ representation in rules without direct effect on entity representations. As we want to get new information of sparse entities through rules, we chose propositionalization in this paper for rule injection.
2.3. OWL 2 Web Ontology Language Axioms
In this paper, instead of learning general Horn rules or closed-path rules as previous works(Galárraga et al., 2015)(Yang et al., 2017), we are more interested in ontology axioms, the main components of knowledge graph ontologies, because they are important for enriching semantics in KGs.
OWL2 Web Ontology Language, informally OWL2222https://www.w3.org/TR/owl2-primer/, is an ontology language for Semantic Web with formally defined meaning and is a W3C recommendation. It defines multiple types of axioms, from which we select some of them as a guidance of rule structures. The selection is based on following principles: (i) the axioms are related with binary relations, the main components of rules in KG and (ii) they can infer new triples because rules are used to help add new information about sparse entities in this paper. Thus, we focus on object property expression axioms in OWL2 which are composed of binary relations in the context of KG. Finally, types of object property expression axioms out of are selected. The unselected axioms are mainly applied to help check the consistency in knowledge graph.
In OWL2, each axiom has its own condition revealing its semantics. The axiom is satisfied if its condition hold. We introduce the selected types of object property expression axioms and their conditions in Table 1. We also translate the conditions of axioms into rule-form including a head and a body as introduced in the previous subsection. The translated rule forms are used to guide the structures of rules to be learned in this paper.
|Object Property Axioms||Rule Form||According to Linear Map Assumption||Rule Conclusion|
is identity matrix.
Given a knowledge graph , our goal is to learn embeddings and rules at the same time and make their advantages complement each other’s difficulties. As discussed in Section 1, embedding learning methods suffer from the problem of data sparsity and rule learning methods have a very large search space.
In this paper, we propose a general framework IterE which learns embeddings and rules in an iterative manner and can be applied to many KGEs that are based on linear map assumption. It includes three main parts:(i) embedding learning, (ii) axiom induction and (iii) axiom injection. Figure 2 shows the key idea of IterE with these three iterative parts.
Embedding learning learns entity embeddings and relation embeddings with a loss function to be minimized, calculated with input triples , each with a label related with its truth value. The inputs are of two types: triples existing in and triples that do not exist in but are inferred by axioms.
Axiom Induction inducts a set of axioms based on relation embeddings R from the embedding learning step, and assigns each axiom with a score .
Axiom Injection injects new triples about sparse entities in to help improve their poor embeddings caused by insufficient training. The new triples are inferred from groundings of quality axioms with high scores in from axiom induction. After axiom injection, with updated, the process goes back to embedding learning again.
IterE is proposed based on the observation that embeddings learned with linear map assumption can fully support the axiom selected in this paper, while other assumptions such as translation-based assumption can’t as pointed out in (Zhang, 2017). Inherently, for each type of axioms, a meaningful conclusion can be drawn with relation embeddings according to linear map assumption. For example, considering axiom , if exists in knowledge graph, according to the condition and rule form of inverse axiom in Table 1, another triple can be inferred. Suppose embeddings of , , and are , , and respectively. According to the linear assumption for individual triples, we can get following two equations: and . With these two equations, another equation can be deduced: . Note that this conclusion equation is only related with two corresponding relation embeddings and is unrelated with concrete entities, thus it can be regarded as a general conclusion for axiom . For other types of axioms, a general conclusion can be drawn in the same way. We list details of the conclusion for each type of axioms in Table 2. These conclusions about relation embeddings help guide axiom induction in this paper.
3.1. Embedding Learning
The input of embedding learning is a set of triples with labels. Unlike previous KGEs, which only learn embeddings but not rules, positive input triple in IterE contains two parts: triples existing in original knowledge graph and triples , where is a set of triples inferred by axioms learned from embeddings. Negative input triples are generated by randomly replacing or with or replacing with for . Thus the input set in IterE is as follows:
where is the label for triple to evaluate its truth value. for and for . For triples we assign , where is triple truth value predicted by axiom injection (Section 3.3).
With input , the loss function of embedding learning is calculated by mean of cross entropy loss among all input triples and the training goal is to minimize the following loss function:
As we adopt linear map assumption, the score function for each triple is defined as:
in which are vector embeddings for subject and object entity. is matrix embedding for relation and
denotes the sigmoid function.is the embedding dimension. The similarity between two vectors is evaluated via dot product.
Our approach can be combined with many KGEs based on linear map assumption, such as DistMult(Yang et al., 2015) and ANALOGY(Liu et al., 2017). In this paper, we adopt ANALOGY as it achieves state-of-the-art results on link prediction. ANALOGY is proposed to deal with an important kind of reasoning, analogy reasoning, in embedding learning. It imposes analogical structures among embeddings and requires linear maps associated with relations to form a commuting family of normal matrices. Specifically, the relation matrix embeddings are constrained as block-diagonal matrices with each diagonal block is either a real scalar, or a 2-dimensional real matrix in the form of , where both and are real scalars.
After embedding learning, a collection of entity embeddings E and relation embeddings R are learned and R will be used in axiom induction.
3.2. Axiom Induction
Given relation embedding R, axiom induction aims to induce a set of axioms and assign a confidence score to each axiom in . To achieve this, IterE firstly generates a pool of possible axioms with an effective pruning strategy. Then it predicts a score of each axiom based on calculation with R.
3.2.1. Axiom pool generation
Before calculating axiom scores with relation embedding R, relation variables , and in Table 2 should be replaced with concrete relations. Axiom pool generation generates a pool of possible axioms by searching for possible axioms with the number of support greater than .
One intuitive way of searching for possible axioms is generating axioms by replacing all relation variable in each type of axioms with each relation and then check the number of support for them, but this suffers from a huge search space. Another way is to generate axioms via random walk on knowledge graph while this method can’t ensure coverage of axioms. Therefore axiom pool generation is not an easy task because it has to achieve a good balance between search space and coverage of highly possible axioms.
In this paper, we propose a pruning strategy combining traversing and random selection. There are two steps for generating possible axioms for each relation in IterE.
step 1: generate axioms or partial axioms: , , , , , and , , in which are relation variables to be replaced with relations in KG and participants in the head of their rule forms.
step 2: complete partial axioms via randomly selecting triples related with . Replacing or in partial axioms with relations that directly link to or .
step 3: search for support of each axiom, and add those axioms with number of support larger than into axiom pool .
The key point of whole process is choosing , which is not trivial because a large will lead to dramatic increase of search space while a small will decrease coverage of axioms immediately. Thus a good choice of
should achieve followings: 1) the probability forcovering all highly possible axioms higher than , named including probability. 2) is as small as possible. We defined the highly possible axioms as axioms with existing probability larger than in this paper and we name as minimum axiom probability. We estimate the probability that replaces the relation variable in head of axiom as:
where is the number of triples and is the number of support for axiom in . Thus choosing triples to satisfy two requirements mentioned above can be formulated as follows:
From above inequality in (8), following inequality can be reached:
Thus with fixed , the best choice of should be the upper bound of equation . Fortunately, with , this equation is monotone increasing and has small upper bound . For example, when , is .
As the input of axiom pool generation is a fixed during learning, axiom pool only need to be generated once.
3.2.2. Axiom Predicting
Given current relation embedding R and axiom pool , axiom predicting predicts a score for each axiom based on the rule conclusion for each type of axioms (column 4 in Table 2), in the form that , where and are matrices either from a single matrix or a product of two matrices. As rule conclusions are derived from ideal linear map assumption, and usually are not equal but similar during training. Thus, instead of matching and , we estimate the truth of axiom by similarity between and which is supposed to be related with Frobenius norm of their difference matrix:
is then normalized as follows because the value of for different type of axioms vary dramatically:
in which is the type of axiom that belongs to. and is the maximum and minimum Frobenius norm score among all type axioms in . is the final score for axiom and the higher is the more confident that axiom is.
3.3. Axiom Injection
Given knowledge graph and possible axiom set , axiom injection utilizes axiom’ deductive capability to infer a set of new triples for sparse entities and predict their labels. will be injected into embedding learning to reduce the sparsity of entities.
3.3.1. Sparse entities
We evaluate the sparsity of entities as follows:
where is the frequency of entity participating in a triple, as subject or object entity. and are the minimum and maximum frequency among all entities. . means is the most sparse entity and means the most frequent one. With , we regard entity as a sparse entity, where is a sparse threshold. We use to denote the set of sparse entity in .
During axiom injection, triples related with sparse entities are injected into the input of embedding learning. In other words, in new inferred triples , either or or . Thus after inferring all possible new triples, we filter those unrelated to sparse entities.
3.3.2. Predicting new triples and their labels
We utilize groundings to infer new triples, and the grounding for axioms considered in this paper can be generalized as the following form:
where the right side triples with are generated from the body of axiom rule form and is new inferred triples to be added into knowledge graph.
To predict label for , we first translate the grounding form in (13) in propositional logical expression:
then we model groundings through t-norm based fuzzy logics(Hájek, 1998). It regards the truth value of a propositional logical expression as a composition of constituent triples’ truth value, through specific logical connectives (e.g. and ). For example, the truth value of a propositional logical expression is determined by the true value of two component triples and , via a composition defined by logical implication . We follow the definition of composition associated with logical conjunction (), disconjunction () and negation () as (Guo et al., 2018):
in which are logical expressions and is the truth value of . Given these compositions, the truth value of any propositional logical expression can be calculated recursively through Equation (15)-(18). For example, applying to propositional logical expression of grounding :
To predict the truth value for triples , inferred by axiom according to grounding , based on t-norm fuzzy logics, can be calculated according to and , . In former example,
For the truth value of axiom ’s grounding , we evaluate it as the score of generated by axiom induction, namely . For the truth value of triples existing in knowledge graph, we evaluate them with their training labels, thus , because existing triples are absolutely true. With these two types of truth value assignment, we can easily get the following result for triples inferred by any type of axioms :
After axiom injection, a set of new triples are inferred via quality axioms and each new triple is labeled with . Thus the input of embedding learning was updated, . Then the process goes back to embedding learning.
During experiments, we want to explore following questions: 1) whether axioms really help sparse entity embedding learning? To do this, we evaluate the quality of embeddings on link prediction task which is widely applied in previous knowledge graph embedding works; 2) whether embeddings really help rule learning overcome the huge search space and improve the quality of learned rules? To do this, we evaluate the efficiency of axiom learning with learning time and the quality with number and percentage of high quality axioms the method generate; 3) how does the iterative manner affect embedding learning and rule learning process? To this end, we show the changes of link prediction results, rule qualities and the number of triples injected along with different number of iterations.
Four datasets are used in experiment, including WN18-sparse, WN18RR-sparse, FB15k-sparse, and FB15k-237-sparse. They are generated from WN18(Bordes et al., 2013), WN18RR(Dettmers, 2018), FB15k(Bordes et al., 2013) and FB15-237(Toutanova and Chen, 2015), four datasets that are commonly used in previous knowledge graph embedding work. WN18 and WN18RR are subsets of WordNet, a lexical knowledge graph for English. FB15k and FB15k-237 are subsets of a large collaborative knowledge base Freebase. The statistics of datasets are listed in Table 3.
We generate the sparse version of these datasets via changing the valid and test datasets which will be used for link prediction evaluation. In link prediction experiments, we want to explore whether axioms really contribute to sparse entity embeddings. Therefore, we only keep triples in test and valid dataset which involve at least one sparsity entity. In other words, for a test or valid triple , if either or is or both are sparse entity (Equation (12)), the triple will be kept in sparse dataset, otherwise, it will be filtered.
When deciding sparse entity hyperparameter, intuitively a principle is considered: the percentage of left triples in valid and test set should not be larger than or less than of original valid and test set for all datasets. Thus we choose and regard entities with as sparse entity in this paper. Table 3 also shows the percent of triples left.
4.2. Training Details
For embedding learning, the number of negative samples is set to and the number of scalars on the diagonal of each relation matrix is set to where
is embedding dimension. We initialize embeddings with uniform distribution.
For axiom induction, we set the minimum axiom probability and the including probability for axiom pool generation. Based on these settings, the number of related triples selected for each relation is set as according to Equation( 9). Details of axiom pools generated for all datasets are shown in Table 4, where we can see that the number of possible axioms in FB15k and FB15k-237 are much larger than WN18 and WN18RR because the number of axioms is highly related to the diversity of relations.
For axiom injection, considering that axioms with high scores are more reliable and less possible to introduce noise, we set a threshold for each dataset and regard axioms with scores as high quality axioms. We also set a maximum inferred triples for axioms in each dataset, if one axiom will infer a lot of triples we ignore it because a huge number of triples inferred by one axiom will change the data distribution significantly and make the embedding training unstable.
During one iteration learning, we first train embedding learning for 10 epochs, and then conduct axiom induction and injection once. The maximum training iteration is set tofor WN18RR-sparse and FB15k-237-sparse and for WN18-sparse and FB15k-sparse. We use Adam algorithm (Kingma and Ba, 2014) during optimization with learning rate . We apply grid search for the best hyperparameters based on the filter MRR on the validation dataset, with combinations from embedding dimension and regularizer weigh .
The final parameters are for WN18-sparse, for WN18RR-sparse, are for FB15k-sparse, and are for FB15k-237-sparse.
4.3. Embedding Evaluation
|TransE(Bordes et al., 2013)||41.8||33.5||10.2||71.1||84.7||39.8||25.5||25.8||48.6||64.5|
|DistMult(Yang et al., 2015)||73.8||55.8||59.3||87.5||93.1||60.0||32.4||61.8||65.1||75.9|
|ComplEx(Trouillon et al., 2016)||91.1||67.7||89.0||93.3||94.4||61.6||32.7||54.0||65.7||76.1|
|ANALOGY(Liu et al., 2017)||91.3||67.5||89.0||93.4||94.4||62.0||33.1||54.3||66.1||76.3|
|IterE(ANALOGY) + axioms||91.3||78.9||89.1||93.5||94.8||62.8||38.8||55.1||67.3||77.1|
|TransE(Bordes et al., 2013)||14.6||12.4||3.4||24.7||28.8||23.8||15.6||16.4||26.1||38.5|
|DistMult(Yang et al., 2015)||25.5||20.8||23.8||26.0||22.5||20.4||12.9||12.8||22.6||36.2|
|ComplEx(Trouillon et al., 2016)||25.9||21.4||24.6||26.2||28.6||19.7||13.3||12.0||21.7||35.4|
|ANALOGY(Liu et al., 2017)||19.8||13.3||24.6||27.5||28.7||19.8||13.9||12.3||21.4||34.9|
|IterE(ANALOGY) + axioms||27.4||25.7||25.4||28.1||31.4||24.7||18.6||17.9||26.2||39.2|
We evaluate the quality of embeddings on link prediction tasks. Link prediction aims to predict the missing entity when given the other entity and relation in a triple, including subject entity prediction and object entity prediction .
4.3.1. Evaluation metrics
Given subject entity prediction task with right answer , we first fit subject entity position with each entity and thus get a set of triples . Then we calculate the score for each triple in according to Equation (6) and rank their scores in descending order. Thus the entity in with a higher rank is a more possible prediction. To evaluate how good the prediction is, we use the rank of among all triples in as subject entity prediction evaluation result for , namely subject entity prediction rank . The object entity prediction task is done in the same way and will get objection entity rank . The final prediction rank for is the average of subject and object prediction rank:
Aggregating prediction rank for all test triples, we applied mean reciprocal predicting rank (MRR) and the percentage of predicting ranks within (Hit@n) to evaluate the whole prediction result. These two metrics are widely used in previous work (Trouillon et al., 2016)(Liu et al., 2017). Generally, a higher MRR or Hit@n indicates a better prediction result.
We also apply and setting. As mentioned in (Wang et al., 2014b), when fitting subject or object entity position with other entities, we may generate triples existing in knowledge graph which are known to be true. It is not wrong if these triples are ranked higher than current test triple. With setting, we filter the generated triples that exist in both train/valid/test dataset before ranking but not current test triple. means the setting of NO filtering.
For baselines, one method from translation-based assumption TransE 333the code for TransE is from https://github.com/thunlp/OpenKE. We train all dataset with learning rate , margin and dimension for maximum 3500 iterations. and three methods based on linear map assumption, DistMult, ComplEx, and ANALOGY 444The code for DistMult, ComplEx and ANALOGY is from https://github.com/quark0/ANALOGY. We train them with the same parameter setting as (Liu et al., 2017) for maximum 500 iterations. For WN18-sparse, the parameters are dimension , regularizer weigh , negative weight for DistMult and for both ComplEx and ANALOGY. For WN18RR-sparse, the parameters are for DistMult, Complex and ANALOGY. For FB15k-sparse, the parameters are for DistMult, Complex and ANALOGY. For FB15k-237-sparse, the parameters are dimension for ANALOGY and Complex and for DistMult. are considered.
4.3.3. Results and analysis
To show how axiom helps sparse entity embeddings, we adopt two strategies: (1) Firstly, we evaluate how axioms directly improve entity embedding quality and compare link prediction results from our method, denoted as IterE in Table 5, with other baselines directly. (2) Secondly, we evaluate how axioms can help improve sparse entity link prediction utilizing its deductive ability. Thus we compare prediction results with embeddings and axioms, denoted as IterE+axioms in Table 5 with IterE and other methods. In IterE+axioms, if the test triple are inferred by axioms during axiom injection, which means , we regard it as correct and mark its prediction rank as .
The link prediction results are shown in Table 5. We analyze the results as follows: Firstly, the link prediction results of IterE competitive to ANALOGY, which means most of the triples injected into embedding learning are not noise, indicating that learning axioms from embeddings works well. Secondly, IterE outperforms baselines on WN18RR-sparse and FB15k-237-sparse, while are slightly improved on WN18-sparse and FB15k-sparse. These indicate that IterE helps sparse entities much more in WN18RR-sparse and FB15k-237-sparse than in WN18RR-sparse and FB15k-sparse. This is quite reasonable in our opinion, because among these four datasets, WN18RR-sparse and FB15k-237-sparse are more challenging and more sparse. They are created from WN18-sparse and FB15k-sparse via removing one relation of all inverse relation pair in the dataset and also their related triples because inverse relation pair is a significant pattern in these two datasets as first noted in (Toutanova and Chen, 2015). Thirdly, the results of IterE+axioms are improved compared with IterE in all datasets, especially on the most complex and sparse dataset FB15k-237-sparse. It indicates that the deductive capability of axioms can help the prediction of sparse entities further.
From the evaluation of link prediction, we can conclude that: (1) by injecting new triples for sparse entities, axioms help improve the quality of sparse entity embeddings and are more helpful in sparse KGs. (2) Combining axioms and embeddings together to predict missing links works better than using embeddings only. Both the deductive capability of axioms and the inductive capability of embeddings contribute to prediction and complement each other.
4.4. Rule Evaluation
We evaluate the learned rules/axioms from two perspectives: efficiency and quality. We compare our method with AMIE+(Galárraga et al., 2015)555we run AMIE+ code from https://www.mpi-inf.mpg.de/departments/databases-and-information-systems/research/yago-naga/amie/ which is an improved rule mining system of widely used AMIE(Galárraga et al., 2013).
4.4.1. Evaluation metrics
The efficiency of rule learning is evaluated by learning time. The quality of rule learning is evaluated with the number of high quality rule (HQr) and their percentage. The quality of rules are evaluated by head coverage(HC) which is commonly used in pervious work, such as (Galárraga et al., 2013) and (Omran et al., 2018). Head coverage for rule is defined as follows:
in which if the head atom of is . And is the supports for . We regard high quality rules as the rules with during test.
4.4.2. Results and analysis
Rule evaluation results are shown in Table 6. According to the time used to generate rules among all datasets, we can see that IterE learns rules more efficiently. For example, with FB15k-sparse and FB15k-237-sparse datasets, IterE costs 10 times less than AMIE+. This shows our pruning strategy works well. Among 4.72 seconds IterE cost for FB15k-237-sparse dataset, there is 4.55 seconds used for axiom pool generation and 0.17 seconds for axiom score calculation, namely axiom score calculation only cost of the time. This means calculating axiom scores via embeddings is super efficient. We didn’t include the time of embedding learning during this evaluation, as embedding learning is not devised mainly for rule learning, but for link prediction. The number of high quality rules shows that IterE generates more high quality rules than AMIE+ for each dataset and also achieves a higher percentage. This indicates that our axiom pool generation can filter meaningless axioms(rules) and achieve a good balance between small search space and coverage of highly possible axioms.
Further more, Figure 4 shows the changes of high quality axioms coverage and axiom percentage with different axiom score thresholds from IterE. For example, in 4, with axiom threshold , which means we select axioms with from IterE for axiom injection, there are axioms selected among all axioms and high quality axioms included. And in 4, with axiom threshold , there are axioms selected and high quality axioms included. It illustrates that axiom scores calculated from embeddings are reliable because it is consistent with rule evaluation results. The results in 4 and 4 for WN18-sparse and WN18RR-sparse are not obvious because a few relations are contained in these two datasets and the number of learned rules is limited.
From rule evaluation results, we can conclude that (1) embeddings together with axiom pool generation help rule learning overcome large search space problem and improve rule learning efficiency, and (2) they also improve rule learning qualities and rules’ reliable scores generated based on calculation with embeddings.
4.5. Iterative learning
To explore how iterative training improves embedding and rule learning during training, we show link prediction results on FB15k-237-sparse and number of injected triples at different iterations in Figure 5.
|triple||(Groundhog_Day), , United_States_Dollar)|
|predicted by axiom||(X, , Z) (X, , Y), (Y, , Z)|
|rank change(ANALOGY IterE)||subject prediction rank:||1409 356 (+1053)||object prediction rank:||1 1(+0)|
|rank change(IterE IterE+axiom)||subject prediction rank:||356 1 (+355)||object prediction rank:||1 1(+0)|
|triple||(USA), , Champaign_County)|
|predicted by axiom||(X, , Z) (Y, , X), (Z, , Y)|
|rank change(ANALOGY IterE)||subject prediction rank:||1 1 (+0)||object prediction rank:||416 214(+202)|
|rank change(IterE IterE+axiom)||subject prediction rank:||1 1 (+0)||object prediction rank:||214 1(+213)|
|triple||(Jenny_McCarthy), , Marriage)|
|predicted by axiom||(X, , Z) (X,|