Knowledge graphs store a large number of factual triples while they are still incomplete, inevitably. The previous knowledge graph completion (KGC) models predict missing links between entities merely relying on fact-view data, ignoring the valuable commonsense knowledge. The previous knowledge graph embedding (KGE) techniques suffer from invalid negative sampling and the uncertainty of fact-view link prediction, limiting KGC's performance. To address the above challenges, we propose a novel and scalable Commonsense-Aware Knowledge Embedding ( CAKE ) framework to automatically extract commonsense from factual triples with entity concepts. The generated commonsense augments effective self-supervision to facilitate both high-quality negative sampling (NS) and joint commonsense and fact-view link prediction. Experimental results 1 on the KGC task demonstrate that assembling our framework could enhance the performance of the original KGE models, and the proposed commonsense-aware NS module is superior to other NS techniques. Besides, our proposed framework could be easily adaptive to various KGE models and explain the predicted results. In recent years, knowledge graphs (KGs) such as Freebase (Bollacker et al., 2008), DBpedia (Lehmann et al., 2015) and NELL (Mitchell et al., 2018) have been widely used in many knowledge-intensive applications, including question answering (Sun et al., 2020; Saxena et al., 2020), dialogue systems (Yang et al., 2020; Zhou et al., 2018) and recommender systems (Wang et al., 2021, 2019a). However, the KGs constructed manually or automatically are inevitably incomplete, requiring KGC to infer new facts. The previous KGC models can be classified into three main streams: (1) Rule learning-based models mine logic rules for induction reasoning, such as AMIE+ (Galrraga et al., 2015), DRUM (Sadeghian et al., 2019) and AnyBurl (Meil-icke et al., 2019). (2) Path-based models (Liu et al., 2020; Xiong et al., 2017; Lin et al., 2018) search paths for multi-hop reasoning. (3) KGE models such as TransE (Bordes et al., 2013) and its variants (Sun et al., 2019; Zhang et al., 2019a, 2020) learn the embeddings of entities and relations to score the plausibility of triples for link prediction. Among all the existing KGC models, KGE approaches achieve higher efficiency and better performance. Specifically, the KGE-based KGC pipeline can be divided into two stages: learning knowledge graph (KG) embeddings at the training and link prediction at the inference. Learning KG embeddings relies on a basic procedure of negative sampling (Li et al., 2021). Link prediction aims to 2867 infer the missing entity or relation in a triple via ranking the candidate triples' scores in virtue of the learned KG embeddings. However, the two separate stages both have drawbacks: (1) Invalid negative sampling : all the previous NS (Wang et al., 2014; Cai and Wang, 2018; Sun et al., 2019; Zhang et al., 2019b; Denis et al., 2015) cannot avoid sampling the false-negative triples and low-quality negative triples, simultaneously. For instance, given the positive triple ( Los Angeles, LocatedIn, California ) as shown in Figure 1, the existing NS strategies might sample the corrupted triples such as ( San F rancisco, LocatedIn, California ) , which is actually a missing correct triple namely false-negative triple. On the other hand, the quality of some generated negative triples such as ( San F rancisco, LocatedIn, Apple P ie ) is too poor to make little sense for training the KGE models. (2) Uncertainty of fact-view link prediction : performing link prediction solely based on facts in a data-driven fashion suffers from uncertainty due to the deviation of KG embeddings compared to the symbolic representations, limiting the accuracy of KGC. Take the tail entity prediction ( David, Nationality, ?) in Figure 1 as an instance. The correct tail entity should belong to the concept Country in the view of commonsense. Whereas the entity California that is inconsistent with commonsense even ranks highest via scoring the candidate triples with KG embeddings. Last but not least, although some KGE approaches exploit external information, including entity types (Xie et al., 2016b), textual descriptions (Xie et al., 2016a) and images of entities (Xie et al., 2017). Such auxiliary information is hard to access and enhances the single representation of entities rather than providing the semantics of commonsense. However, the valuable commonsense is always acquired by the expensive hand annotation (Rajani et al., 2019), so its high cost leads to relatively low coverage. Besides, the existing large-scale commonsense KGs such as ConceptNet (Speer et al., 2017) only contain the concepts without the links to the corresponding entities, causing them unavailable to the KGC task. To address the above challenges, we propose a novel and scalable C ommonsenseA ware K nowledge E mbedding ( CAKE ) framework to improve the NS in the training of KGE and boost the performance of KGC benefited from the self-supervision of commonsense . commonsense via an instance abstraction technique from KGs. Then, contrary to random sampling, we purposefully generate the high-quality negative triples by taking advantage of the commonsense together with the characteristics of complex relations. Furthermore, a multi-view link prediction is conducted to determine the entity candidates that belong to the correct concepts in the commonsense view and predict the answer entities with the learned KG embeddings from the perspective of fact. In summary, the contributions of our work are three-fold:  We propose a scalable KGC framework with an automatic commonsense generation mechanism to extract valuable commonsense from factual triples and entity concepts. We develop a commonsense-aware negative sampling strategy for generating valid and high-quality negative triples. Meanwhile, a multi-view link prediction mechanism is proposed to improve the accuracy of KGC. Extensive experiments on four benchmark datasets illustrate the effectiveness and the scalability of our whole framework and each module. We promise to release all the codes and datasets when this paper is published. The existing KGC models can be classified into three main categories: (1) Rule learning-based algorithms such as AMIE+ (Galrraga et al., 2015), DRUM (Sadeghian et al., 2019) and AnyBurl (Meil-icke et al., 2019) automatically mine logic rules from KGs and apply these rules for inductive link prediction. However, these models are inefficient due to the time-consuming rule searching and evaluation. (2) Path-based models search paths linking head and tail entities, including path ranking approaches (Lao et al., 2011; Liu et al., 2020) and reinforcement learning-based models (Xiong et al., 2017; Lin et al., 2018). Whereas, multi-hop path-based models also spend much time in path searching. (3) KG embedding (KGE) models such as TransE (Bordes et al., 2013), RESCAL (Nickel et al., 2011), ComplEx (Trouillon et al., 2016), RotatE (Sun et al., 2019) and HAKE (Zhang et al., 2868 2020) learn the embeddings of entities and relations to score the plausibility of triples for predicting the missing triples efficiently. KGE approaches achieve higher efficiency and better performance on KGC compared with the others. However, the natural uncertainty of embeddings limits the precision of KGC relying solely on facts. More specifically, the KGE models generally need a primary negative sampling (NS) procedure to randomly or purposely sample some triples that are not observed in the KG as negative triples for training (Li et al., 2021). Following the local closed-world assumption (Dong et al., 2014), the existing NS techniques for KGE can be classified into five categories: (1) Randomly and uniformly sampling: the majority of the KGE models generate negative triples via randomly replacing an entity or relation in a positive triple from a uniform distribution (Wang et al., 2014). (2) Adversarial-based sampling: KBGAN (Cai and Wang, 2018) integrates the KGE model with soft-max probabilities to select the high-quality negative triples in an adversarial training framework. Self-adversarial sampling (Sun et al., 2019) performs similar to KBGAN, but it utilizes a self-scoring function without a generator. (3) Domain-based sampling: domain-based NS (Wang et al., 2019b) and type-constrained NS (Denis et al., 2015) both leverage domain or type constraints on sampling the corrupted entities that belong to the correct domain. (4) Efficient sampling: NSCaching (Zhang et al., 2019b) employs cache containing candidates of negative triples to improve the efficiency of sampling. (5) None-sampling: NS-KGE (Li et al., 2021) eliminates the NS procedure by converting loss functions of KGE into a unified square loss. However, all the previous NS algorithms cannot address the issue of false-negative triples since these NS techniques, except for none sampling, would attempt to sample the corrupted triples with higher probability while they might be correct and just missing in the KG. Domain-based NS relies heavily on the constraint of the single type rather than the commonsense, limiting the diversity of negative triples. KBGAN introduces generative adversarial networks (GAN) in the NS framework, making the original model more complex and hard to train. None sampling has to convert each original KGE model into square loss, which weakens the performance of KGE models. These drawbacks of the NS strategies degrade the training of KGE and further limit the performance of KGC. Different from the factual triples, commonsense could inject rich abstract knowledge into KGs. However, the valuable commonsense is hard to access due to the costly hand annotation. In recent years, many researches attempt to construct general commonsense graphs such as ConceptNet (Speer et al., 2017), Microsoft Concept Graph (Ji et al., 2019) and ATOMIC (Sap et al., 2019). However, these commonsense graphs only contain the concepts without the links to the corresponding entities, causing them inapplicable to the KGC task. On the other hand, although some KGE models such as JOIE (Hao et al., 2019) employ the ontology built-in most of the KGs, i.e., NELL (Mitchell et al., 2018) and DBpedia (Lehmann et al., 2015), the relations in ontology such as isA , partOf and relatedT o mainly represent the type hierarchy but not the explicit commonsense. Such relations are useless for KGC because there are few overlaps between the ontological and the factual relations. In this section, we introduce our novel and scalable CAKE framework. As shown in Figure 2, the entire pipeline consists of three developed modules: the automatic commonsense generation (ACG) module, the commonsense-aware negative sampling (CANS) module and the multi-view link prediction (MVLP) module. Firstly, the ACG module extracts the commonsense from the factual triples with the entity concepts via an instance abstraction mechanism ( 3.2). Then, the CANS module employs the generated commonsense to produce the high-quality negative triples, which takes the characteristics of complex relations into account ( 3.3). Afterwards, our approach feeds the positive and the weighted negative triples into the KGE model for learning entity and relation embeddings ( 3.4). Finally, the MVLP module conducts link prediction in a coarse-to-fine fashion by filtering the candidates in the view of commonsense and predicting the answer entities with KG embeddings from the candidates in the view of fact ( 3.5). understanding high-level semantics, which is generally represented as the concepts with their ontological relations in some well-known commonsense graphs such as ConceptNet (Speer et al., 2017) and Microsoft Concept Graph (Ji et al., 2019). Notably, we extend the commonsense in two forms: the individual form C 1 and the set form C 2 . Both C 1 and C 2 are the sets of triples while each triple in C 1 is constituted of a head entity's concept c h and a tail entity's concept c t associated with their instance-level relation r , which can be written as follows: C 1 = { ( c h , r, c t ) } (1) On the contrary, each triple in C 2 consists of a relation r linking the corresponding head concept set C h and tail concept set C t , which is shown as: C 2 = { ( C h , r, C t ) } (2) The detailed description of commonsense generation is introduced in section 3.2. KGE Score Function. We could leverage any KGE model to learn the entity and relation embeddings owing to our scalable framework indepen-dent of the KGE model. Thus, we define a uniform symbol E ( h, r, t ) to represent the score function of any KEG model for evaluating the plausibility of a triple ( h, r, t ) . More specifically, the three most typical score function patterns are given as follows: (1) The translation -based score function, such as TransE (Bordes et al., 2013): E ( h, r, t ) =  h + r  t  (3) where h , r and t denote the embeddings of head entity h , relation r and tail entity t , respectively. where  indicates the hardmard product. (3) The tensor decomposition -based score function, such as DistMult (Yang et al., 2015): E ( h, r, t ) = h  diag ( M r ) t (5) where diag ( M r ) represents the diagonal matrix of the relation r . Link Prediction. Following most of the previous KGC models, we regard link prediction as an entity prediction task. Given a triple query with an entity missing ( h, r, ?) or (? , r, t ) , link prediction takes every entity as a candidate. It calculates the score of each candidate triple by employing the learned KG embeddings and the score function. Then, we rank the candidate entities in light of their scores and output the top n entities as results. In terms of the representation of commonsense defined in section 3.1, our approach could theoretically generate commonsense from any KG automatically as long as there exist some concepts linked to the entities in the KG. Specifically, we develop an entity-to-concept converter to replace the entities in each factual triple with corresponding concepts. Meanwhile, the relations in commonsense entail the instance-level relations in factual KGs. Take an instance in Figure 2, the factual triple ( David, Nationality, U.S.A. ) can be transformed to a concept-level triple ( P erson, Nationality, Country ) . Particularly, the commonsense in the individual form C 1 is achieved by wiping out the reduplicated concept-level triples. Afterwards, we merge the concept-level triples that contain the same relation into a set to construct the commonsense in the set form C 2 . Intuitively, the negative triples satisfying commonsense are more challenging to distinguish from positive triples, contributing to more effective training signals. Therefore, we try to sample the negative triples that conform to the commonsense. To reduce the false-negative triples, we exploit the characteristics of complex relations, namely 1-1, 1-N, N-1, and N-N defined in TransH (Wang et al., 2014) for negative sampling, where 1 implies that the entity is unique when given the relation and another entity, on the contrary, N denotes that there might be multiple entities in this case (non-unique entity). Based on this observation, two specific sampling strategies are proposed: (1) uniqueness sampling : in terms of corrupting a unique entity such as the tail entity of the N-1 relation, the corrupted triples except for the original positive one are definitely actual negative triples. Furthermore, the corrupted entities that share at least one concept with the correct entity are regarded as high-quality negative triples, contributing to a more consistent training signal. (2) None-unique sampling : for corrupting a non-unique entity such as a head entity linked by the N-1 relation, the entities belonging to the same concept(s) with the correct entity are more likely to be false-negative due to the nonuniqueness of the head entity. Thus, the weights of these negative triples being false-negative should be as low as possible in training. Meanwhile, we try to sample the triples conforming to the commonsense C 2 for high quality. For a better understanding, an example of generating high-quality negative triples with an N-1 relation is shown in Figure 3. The whole NS procedure can be divided into two steps. Step 1 : selecting the candidate concepts with commonsense C 2 . The candidate head concepts city , county and island are determined according to commonsense C 2 and nonunique sampling. Besides, based on the uniqueness sampling strategy, the candidate tail concept is selected as the same concept stateprovince as that of Georgia . Step 2 : attentive concept-to-entity converting. To reduce false-negative while ensuring the high quality of the negative triples, the corrupted entities belonging to the candidate concepts are sampled from the following distribution: w ( h  j , r, t ) = 1  p (( h  j , r, t ) |{ ( h i , r i , t i ) } ) = 1  exp E ( h  j , r, t ) (cid:80) i exp E ( h  i , r, t ) (6) w ( h, r, t  j ) = p (( h, r, t  j ) |{ ( h i , r i , t i ) } ) = exp E ( h, r, t  j ) (cid:80) i exp E ( h, r, t  i ) (7) where h  i and t  i are the corrupted head and tail entities obtained by non-unique sampling and uniqueness sampling. w and p denote the weight and the probability of the negative triple, respectively. is the temperature of sampling motivated by the self-adversarial sampling (Sun et al., 2019). Remarkably, considering that a triple with a higher probability is more likely to be a positive one, the weight of a negative triple containing the corrupted head entity such is defined as Eq. 6 to prevent the issue of false-negative. Besides, the negative triples containing the corrupted tail entities with higher probability are endowed with higher-quality weight since there is no false-negative issue. Thus, both the corrupted head entity greenland and the corrupted tail entity tennessee with the high weights are selected to generate high-quality negative triples. Similarly, we can generate the high-quality negative triples with an 1-N relation via uniqueness sampling for head entity and none-uniqueness sampling for tail entity. Besides, the negative triples with a 1-1 relation can be obtained by only conducting the uniqueness sampling for both head and tail entities. On the contrary, only none-uniqueness sampling is required for generating negative triples with an N-N relation. Based on the negative triples obtained by CANS, we train the KGE model to learn the entity and relation embeddings for enlarging the gap between the scores of the positive and high-quality negative triples. In this work, we employ the following loss function as our optimization objective: L =  log  (   E ( h, r, t ))  n (cid:88) i =1 0 . 5  [ w ( h  i , r, t ) log  ( E ( h  i , r, t )   ) + w ( h, r, t  i ) log  ( E ( h, r, t  i )   )] (8) in which  is the margin. Benefiting from the same relations among commonsense and facts, commonsense could directly provide a definite range for link prediction results. Hence we develop a novel multi-view link prediction (MVLK) mechanism in a coarse-to-fine paradigm to facilitate more likely predicted results. Firstly, at the coarse prediction stage, we pick out the candidate entities in the view of commonsense. Specifically, take a query ( h, r, ?) for an example, commonsense C 1 is employed for filtering the reasonable concepts of the tail entity. The candidate concept set of tail entity is defined as C 1 t = { c ti | ( c hi , r, c ti )  C 1 } (9) where c hi is the i-th concept of h , and c ti denotes the tail concept in the commonsense ( c hi , r, c ti ) . Then, the entities belonging to the concept set C 1 t can be determined as the candidate entities since they satisfy commonsense and are more likely to be the correct tail entities from the perspective of commonsense compared with other entities. Then, at the fine prediction stage, we score each candidate entity e i derived from the coarse prediction stage in the view of fact as following score ( e i ) = E ( h, r, e i ) (10) where E ( h, r, e i ) denotes the score function employed for training the KGE model. Subsequently, the prediction results will rank the scores of candidate entities in ascending order and output the entities with higher ranks. In this section, we perform extensive experiments of KGC on four widely-used KG datasets containing concepts. We firstly describe datasets, baseline models, implementation details and evaluation Dataset #Rel #Ent #Con #Train #Valid #Test FB15K 1,345 14,951 89 483,142 50,000 59,071 FB15K237 237 14,505 89 272,115 17,535 20,466 NELL-995 200 75,492 270 123,370 15,000 15,838 DBpedia-242 298 99,744 242 592,654 35,851 30,000 Table 1: Statistics of the experimental datasets. protocol. Then, the effectiveness of our proposed framework CAKE and each module is demonstrated by compared with several baselines. Furthermore, we conduct extensive experiments, including the ablation study and the case study. Datasets. Four real-world datasets containing ontological concepts are utilized for experiments, including FB15K (Bordes et al., 2013), FB15K237 (Toutanova and Chen, 2015), NELL-995 (Xiong et al., 2017) and DBpedia-242. Particularly, DBpedia-242 is extracted from DBpedia (Lehmann et al., 2015) which contains totally 242 concepts. The statistics of the datasets are summarized in Table 1. Notably, the entities in FB15K and FB15K237 always belong to more than one concept while each entity in NELL-995 and DBpedia-242 has only one concept. Baselines. We compare our CAKE model with three state-of-the-art KGE models, including TransE (Bordes et al., 2013), RotatE (Sun et al., 2019) and HAKE (Zhang et al., 2020). Meanwhile, these baselines are also the basic models integrated with our framework. It is unnecessary to use many baselines since the focus of this work is to observe the impact of applying our CAKE framework to original KGE models instead of defeating all the SOTA models. We provide the results of baselines by running their source codes 2 with the suggested parameters. Note that all the existing type-based and ontology-based models are not chosen as baselines since they are specific to a few KGs and cannot work on most of the datasets in our experiment. Implementation Details. Each complex relation is labelled in the same way as in TransH (Wang et al., 2014). We use Adam optimizer for the training and tune the hyper-parameters of our model by grid search on the validation sets. Specifically, the 2 The codes of TransE and RotatE: https://github.com/ DeepGraphLearning/KnowledgeGraphEmbedding. embedding size and the batch size are the same as those of each basic model for a fair comparison. The negative sampling size is set as 16 for all the models considering the memory limitation and efficiency. The learning rate is chosen from 0.0001 to 0.01. The margin is tuned in {9, 12, 18, 24, 30}. The sampling temperature is adjusted in {0.5, 1.0}. The entity and relation embeddings are initialized randomly. All the experiments are conducted in Pytorch and on GeForce GTX 2080Ti GPUs. Evaluation Protocol. Following the procedure of MVLP in Section 3.5, we can obtain the rank of the correct entity for each test example. Then, the performance of link prediction is evaluated by three commonly-used metrics: mean rank (MR), mean reciprocal rank (MRR), and proportion of the correct entities ranked in the top n (Hits@N). All the metrics are in the filtered setting by wiping out the candidate triples already exist in the datasets. Table 2 exhibits the evaluation results of link prediction on the four datasets. We can observe that both CANS and MVLP modules effectively im-(rockets, teamplaysinleague, ?) (rockets, teamplaysinleague, ?) Query: Commonsense: (sportsteam, teamplaysinleague, sportsleague ) (sportsteam, teamplaysinleague, sportsleague ) Top 5 Answers: nbanba ncaancaa wnbawnba cbacba accacc Entity Concept: sportsleague Figure 4: A case study of explainable link prediction with commonsense and entity concept on NELL-995. prove the performance of each basic model on each dataset. Moreover, the entire CAKE framework further facilitates more performance gains than each separate module and outperforms all the baselines consistently and significantly. Compared with the performance average of the three baseline models, our CAKE model improves MRR by 7.2 %, 11.5 %, 16.2 % and 16.7 % on FB15K, FB15K237, DBpedia-242 and NELL-995. These results demonstrate the superiority and effectiveness of integrating commonsense with the original KGE models. We compare our CANS module with various types of NS techniques, including uniform sampling (Bordes et al., 2013), none sampling (Li et al., 2021), NSCaching (Zhang et al., 2019b), domain-based sampling (Wang et al., 2019b) and 2873 Models FB15K FB15K237 MR MRR Hits@10 Hits@3 Hits@1 MR MRR Hits@10 Hits@3 Hits@1 TransE+Unifo 178 0.301 0.505 0.339 0.201 361 0.171 0.323 0.182 0.097 TransE+NoSamp 144 0.350 0.578 0.415 0.227 343 0.261 0.446 0.297 0.168 TransE+NSCach 209 0.292 0.560 0.375 0.144 556 0.205 0.353 0.226 0.131 TransE+Domain 35 0.619 0.839 0.715 0.489 186 0.283 0.467 0.314 0.190 TransE+SAdv 35 0.626 0.838 0.723 0.496 195 0.268 0.454 0.298 0.176 TransE+CANS (Ours) 34 0.671 0.864 0.761 0.552 175 0.298 0.490 0.333 0.203 Models DBpedia-242 NELL-995 MR MRR Hits@10 Hits@3 Hits@1 MR MRR Hits@10 Hits@3 Hits@1 TransE+Unifo 5750 0.124 0.262 0.183 0.033 8650 0.167 0.354 0.219 0.068 TransE+None 2292 0.202 0.395 0.247 0.101 9172 0.176 0.297 0.210 0.106 TransE+NSCach 5465 0.156 0.340 0.212 0.050 13967 0.107 0.205 0.122 0.107 TransE+Domain 3415 0.203 0.510 0.346 0.009 1319 0.381 0.549 0.468 0.271 TransE+SAdv 2733 0.242 0.468 0.344 0.100 1081 0.429 0.557 0.477 0.354 TransE+CANS (Ours) 1889 0.287 0.575 0.427 0.103 1022 0.433 0.591 0.495 0.336 Table 3: Comparison results of various NS techniques. self-adversarial sampling (Sun et al., 2019). The comparison results are obtained by combining these NS techniques 3 with the most classical KGE model TransE(Bordes et al., 2013). From the results shown in Table 3, our CANS module significantly outperforms all the other NS techniques on all the datasets. Specifically, domain-based NS, self-adversarial sampling and our CANS module consistently outperform the others due to the consideration of the quality of negative triples. Furthermore, our CANS module performs better than domain-based NS and self-adversarial sampling since CANS could reduce false-negative. These results illustrate the superior ability of our CANS module to generate more high-quality negative triples for enhancing the performance of any KGE model. We verify the effectiveness of each contribution via integrating the whole framework CAKE and the following ablated models into the basic model HAKE: (1) neglecting the characteristics of complex relations in CANS (-CRNS), (2) removing the commonsense in CANS while retaining the characteristics of complex relations (-CSNS), and (3) omitting the commonsense-view prediction from MVLP (-MVLP). The results in Table 4 demonstrate that our whole model CAKE performs better 3 The codes of these NS techniques are obtained from: uniform sampling: https://github.com/thunlp/KB2E, none sampling: https://github.com/rutgerswiselab/NS-KGE, NSCaching: https://github.com/yzhangee/NSCaching, selfadversarial sampling: https://github.com/DeepGraphLearning/ KnowledgeGraphEmbedding. than all the ablated models on each dataset. It illustrates that introducing commonsense and the characteristics of complex relations both make sense in the NS process for generating more effective negative triples. Besides, MVLP facilitates link prediction performance benefited from determining the reasonable candidate entities by prior commonsense. In general, each contribution plays a pivotal role in our approach. We provide the case study of explainable link prediction with commonsense as shown in Figure 4. Given a query with the tail entity missing ( rockets, teamplaysinleague, ?) on NELL-995, our model could output the answer entities and provide the corresponding entity concepts together with the commonsense specific to the query. We can observe that all the top-2874 5 entities including the correct entity nba belong to the concept sportsleague which satisfies the commonsense ( rockets, teamplaysinleague, sportsleague ) . More interestingly, the commonsense and the entity concepts could explain the rationality of the predicted answer entities to enhance the users' credibility of the answers. In this paper, we propose a novel and scalable commonsense-aware knowledge embedding framework, which could automatically generate commonsense from KGs with entity concepts for the KGC task. We exploit the generated commonsense to produce effective and high-quality negative triples. On the other hand, we design a multi-view link prediction technique in a coarse-to-fine paradigm to filter the candidate entities in the view of commonsense and output the predicted results from the perspective of fact. The experiments on four datasets demonstrate the effectiveness and the scalability of our proposed framework and each module compared with the state-of-the-art baselines. Furthermore, our framework could explain link prediction results and potentially assemble new KGE models to improve their performance. This work was partially supported by Zhe-jiang Science and Technology Plan Project (No. 2022C01082), the National Natural Science Foundation of China (No. 62072022, 61772054) and the Fundamental Research Funds for the Central Universities.
abstain abstain abstain objective abstain objective objective other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain objective abstain method abstain abstain abstain abstain abstain abstain other other other other other other other other other other other other other other other other other other other other other other other other other abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain method abstain abstain abstain abstain method abstain abstain abstain method abstain abstain abstain abstain method abstain method method abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result result abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain result abstain abstain result abstain result abstain abstain result result abstain result abstain other abstain abstain abstain abstain result abstain result abstain objective method result objective objective other