We propose a distance supervised relation extraction approach for long-tailed, imbalanced data which is prevalent in real-world settings. Here, the challenge is to learn accurate few-shot models for classes existing at the tail of the class distribution, for which little data is available. Inspired by the rich semantic correlations between classes at the long tail and those at the head, we take advantage of the knowledge from data-rich classes at the head of the distribution to boost the performance of the data-poor classes at the tail. First, we propose to leverage implicit relational knowledge among class labels from knowledge graph embeddings and learn explicit relational knowledge using graph convolution networks. Second, we integrate that relational knowledge into relation extraction model by coarse-to-fine knowledge-aware attention mechanism. We demonstrate our results for a large-scale benchmark dataset which show that our approach significantly outperforms other baselines, especially for long-tail relations. Relation extraction (RE) is an important task in information extraction, aiming to extract the relation between two given entities based on their related context. Due to the capability of extracting textual information and benefiting many NLP applications (e.g., information retrieval, dialog generation, and question answering), RE appeals to many researchers. Conventional supervised models have been widely explored in this task (Zelenko et al., 2003; Zeng et al., 2014); however, their performance heavily depends on the scale and quality of training data. To construct large-scale data, (Mintz et al., 2009) proposed a novel distant supervision (DS) mechanism to automatically label training instances by aligning existing knowledge graphs (KGs) with text. DS enables RE models to work on large-scale training corpora and has thus become a primary approach for RE recently (Wu et al., 2017; Feng et al., 2018). Although these DS models achieve promising results on common relations, their performance still degrades dramatically when there are only a few training instances for some relations. Empirically, DS can automatically annotate adequate amounts of training data; however, this data usually only covers a limited part of the relations. Many relations are long-tail and still suffer from data deficiency. Current DS models ignore the problem of long-tail relations, which makes it challenging to extract comprehensive information from plain text. Long-tail relations are important and cannot be ignored. Nearly 70% of the relations are longtail in the widely used New York Times (NYT) dataset 1 (Riedel et al., 2010; Lei et al., 2018) as shown in Figure 1. Therefore, it is crucial for mod-1 http://iesl.cs.umass.edu/riedel/ecml/ els to be able to extract relations with limited num-bers of training instances. Dealing with long tails is very difficult as few training examples are available. Therefore, it is natural to transfer knowledge from data-rich and semantically similar head classes to data-poor tail classes (Wang et al., 2017). For example, the long-tail relation /peo-ple/deceased person/place of burial and head relation /people/deceased person/place of death are in the same branch /people/deceased person/* as shown in Figure 2. They are semantically similar, and it is beneficial to leverage head relational knowledge and transfer it to the long-tail relation, thus enhancing general performance. In other words, long-tail relations of one entity tuple can have class ties with head relations, which can be leveraged to enhance RE for narrowing potential search spaces and reducing uncertainties between relations when predicting unknown relations (Ye et al., 2017). If one pair of entities contains /people/deceased person/place of death, there is a high probability that it will contain /peo-ple/deceased person/place of burial. If we can incorporate the relational knowledge between two relations, extracting head relations will provide evidence for the prediction of long-tail relations. However, there exist two problems: (1) Learning relational knowledge: Semantically similar classes may contain more relational information that will boost transfer, whereas irrelevant classes (e.g., /location/location/contains and /peo-ple/family/country) usually contain less relational information that may result in negative transfer. (2) Leveraging relational knowledge: Integrating relational knowledge to existing RE models is challenging. To address the problem of learning relational knowledge, as shown in (Lin et al., 2016; Ye et al., 2017), we use class embeddings to represent relation classes and utilize KG embeddings and graph convolution networks (GCNs) to extract implicit and explicit relational knowledge. Specifically, previous studies (Yang et al., 2015) have shown that the embeddings of semantically similar relations are located near each other in the latent space. For instance, the relation /people/person/place lived and /peo-ple/person/nationality are more relevant, whereas the relation /people/person/profession has less correlation with the former two relations. Thus, it [ ismail_merchant ], whose filmmaking collaboration with jamesivory created a genre of films with visually sumptuous settings that told literate tales of individuals trying to adapt to shifting societal values , died yesterday in a [ London ] hospital [ darren_mcgavin ] , an actor with hundreds of television , movie and theatrical credits to his name , died on saturdayin [ los_angeles ] . is natural to leverage this knowledge from KGs. However, because there are many one-to-multiple relations in KGs, the relevant information for each class may be scattered. In other words, there may not be enough relational signal between classes. Therefore, we utilize GCNs to learn explicit relational knowledge. To address the problem of leveraging relational knowledge, we first use convolution neural networks (Zeng et al., 2014, 2015) to encode sentences; then introduce coarse-to-fine knowledge-aware attention mechanism for combining relational knowledge with encoded sentences into bag representation vectors. The relational knowledge not only provides more information for relation prediction but also provides a better reference message for the attention module to raise the performance of long-tail classes. Our experimental results on the NYT dataset show that: (1) our model is effective compared to baselines especially for long-tail relations; (2) leveraging relational knowledge enhances RE and our model is efficient in learning relational knowledge via GCNs. Relation Extraction. Supervised RE models (Ze-lenko et al., 2003; GuoDong et al., 2005; Mooney and Bunescu, 2006) require adequate amounts of annotated data for training which is time-consuming. Hence, (Mintz et al., 2009) proposd DS to automatically label data. DS inevitably accompanies with the wrong labeling problem. To alleviate the noise issue, (Riedel et al., 2010; Hoffmann et al., 2011) proposed multi-instance learning (MIL) mechanisms. Recently, neural models have been widely used for RE; those models can accurately capture textual relations without explicit linguistic analysis (Zeng et al., 2015; Lin et al., 2016; Zhang et al., 2018a). To further improve the performance, some studies incorporate external information (Zeng et al., 2017; Ji et al., 2017; Han et al., 2018a) and advanced training strategies (Ye et al., 2017; Liu et al., 2017; Huang and Wang, 2017; Feng et al., 2018; Zeng et al., 2018; Wu et al., 2017; Qin et al., 2018). These works mainly adopt DS to make large-scale datasets and reduce the noise caused by DS, regardless of the effect of long-tail relations. There are only a few studies on long-tail for RE (Gui et al., 2016; Lei et al., 2018; Han et al., 2018b). Of these, (Gui et al., 2016) proposed an explanation-based approach, whereas (Lei et al., 2018) utilized external knowledge (logic rules). These studies treat each relation in isolation, regardless of the rich semantic correlations between the relations. (Han et al., 2018b) proposed a hierarchical attention scheme for RE, especially for long-tail relations. Different from those approaches, we leverage implicit and explicit relational knowledge from KGs and GCNs rather than data-driven learned parameter spaces where similar relations may have distinct parameters, hindering the generalization of long-tail classes. Knowledge Graph Embedding. Recently, several KG embedding models have been proposed. These methods learn low-dimensional vector representations for entities and relations (Bor-des et al., 2013; Wang et al., 2014; Lin et al., 2015). TransE (Bordes et al., 2013) is one of the most widely used models, which views relations as translations from a head entity to a tail entity on the same low-dimensional hyperplane. Inspired by the rich knowledge in KGs, recent works (Han et al., 2018a; Wang et al., 2018; Lei et al., 2018) extend DS models under the guidance of KGs. However, these works neglect rich correlations between relations. Relation structure (re-lational knowledge) has been studied and is quite effective for KG completion (Zhang et al., 2018b). To the best of our knowledge, this is the first effort to consider the relational knowledge of classes (re-lations) using KGs for RE. Graph Convolutional Networks. GCNs generalize CNNs beyond two-dimensional and one-dimensional spaces. (Defferrard et al., 2016) developed spectral methods to perform efficient graph convolutions. (Kipf and Welling, 2016) assumed the graph structure is known over input instances and apply GCNs for semi-supervised learning. GCNs were applied to relational data (e.g., link prediction) by (Schlichtkrull et al., 2018). GCNs have also had success in other NLP tasks such as semantic role labeling (Marcheg-giani and Titov, 2017), dependency parsing (Strubell and McCallum, 2017), and machine translation (Bastings et al., 2017). Two GCNs studies share similarities with our work. (1) (Chen et al., 2017) used GCNs on structured label spaces. However, their experiments do not handle long-tail labels and do not incorporate attention but use an average of word vectors to represent each document. (2) (Rios and Kavu-luru, 2018) proposed a few-shot and zero-shot text classification method by exploiting structured label spaces with GCNs. However, they used GCNs in the label graph whereas we utilize GCNs in the hierarchy graph of labels. In this section, we introduce the overall framework of our approach for RE, starting with the notations. We denote a KG as G = E , R , F , where E , R and F indicate the sets of entities, relations and facts respectively. ( h, r, t )  F indicates that there is a relation r  R between h  E and t  E . We follow the MIL setting and split all instances into multiple entity-pair bags {S h 1 ,t 1 , S h 2 ,t 2 , ... } . Each bag S h i ,t i contains multiple instances { s 1 , s 2 , ... } mentioning both entities h i and t i . Each instance s in these bags is denoted as a word sequence s = { w 1 , w 2 , ... } . Instance Encoder. Given an instance and its mentioned entity pair, we employ neural networks to encode the instance semantics into a vector. In this study, we implement the instance encoder with convolutional neural networks (CNNs) given both model performance and time efficiency. Relational Knowledge Learning. Given pretrained KG embeddings (e.g., TransE (Bordes et al., 2013)) as implicit relational knowledge, we employ GCNs to learn explicit relational knowledge. By assimilating generic message-passing inference algorithms with neural-network counterpart, we can learn better embeddings for Knowl-(cid:6)(cid:4)(cid:11) (cid:10)(cid:25)(cid:24)(cid:20)(cid:2)(cid:28)(cid:14)(cid:21)(cid:22) (cid:7)(cid:18)(cid:14)(cid:17) (cid:12)(cid:14)(cid:26)(cid:18)(cid:24)(cid:28) (cid:4)(cid:3) (cid:2)(cid:15)(cid:9)(cid:14)(cid:15)(cid:12)(cid:9) (cid:2)(cid:15)(cid:9)(cid:14)(cid:15)(cid:12)(cid:9)(cid:2)(cid:15)(cid:9)(cid:16)(cid:17)(cid:14)(cid:13)(cid:2) (cid:2)(cid:15)(cid:9)(cid:14)(cid:15)(cid:12)(cid:9)(cid:2)(cid:15)(cid:9)(cid:16)(cid:17)(cid:14)(cid:13)(cid:2)(cid:9)(cid:18)(cid:10)(cid:13)(cid:11)(cid:7)(cid:11)(cid:18)(cid:20) (cid:2)(cid:15)(cid:9)(cid:14)(cid:15)(cid:12)(cid:9)(cid:2)(cid:15)(cid:9)(cid:16)(cid:17)(cid:14)(cid:13)(cid:2)(cid:13)(cid:6)(cid:18)(cid:11)(cid:14)(cid:13)(cid:6)(cid:12)(cid:11)(cid:18)(cid:20) (cid:13)(cid:18)(cid:22)(cid:14)(cid:28)(cid:21)(cid:25)(cid:24)(cid:14)(cid:22)(cid:1)(cid:9)(cid:24)(cid:25)(cid:29)(cid:22)(cid:18)(cid:17)(cid:20)(cid:18) (cid:9)(cid:24)(cid:25)(cid:29)(cid:22)(cid:18)(cid:17)(cid:20)(cid:18)(cid:2)(cid:14)(cid:29)(cid:14)(cid:26)(cid:18)(cid:1) (cid:28)(cid:28)(cid:18)(cid:24)(cid:28)(cid:21)(cid:25)(cid:24) (cid:1) ! edge Relation. We concatenate the outputs of GCNs and the pretrained KG embeddings to form the final class embeddings. Knowledge-aware Attention. Under the guidance of final class embeddings, knowledge-aware attention is aimed to select the most informative instance exactly matching relevant relation. Given an instance s = { w 1 , ..., w n } mentioning two entities, we encode the raw instance into a continuous low-dimensional vector x , which consists consists of an embedding layer and an encoding layer. Embedding Layer. The embedding layer is used to map discrete words in the instance into continuous input embeddings. Given an instance s , we map each word w i in the instance to a real-valued pretrained Skip-Gram (Mikolov et al., 2013) embedding w i  R d w . We adopt position embeddings following (Zeng et al., 2014). For each word w i , we embed its relative distances to the two entities into two d p -dimensional vectors. We then concatenate the word embeddings and position embeddings to achieve the final input embeddings for each word and gather all the input embeddings in the instance. We thus obtain an embedding sequence ready for the encoding layer. Encoding Layer. The encoding layer aims to compose the input embeddings of a given instance into its corresponding instance embedding. In this study, we choose two convolutional neural architectures, CNN (Zeng et al., 2014) and PCNN (Zeng et al., 2015) to encode input embeddings into instance embeddings. Other neural architectures such as recurrent neural networks (Zhang and Wang, 2015) can also be used as sentence encoders. Because previous works show that both convolutional and recurrent architectures can achieve comparable state-of-the-art performance, we select convolutional architectures in this study. Note that, our model is independent of the encoder choices, and can, therefore, be easily adapted to fit other encoder architectures. Given pretrained KG embeddings and predefined class (relation) hierarchies 2 , we first leverage the implicit relational knowledge from KGs and initialize the hierarchy label graph; then we apply two layer GCNs to learn explicit fine-grained relational knowledge from the label space. Hierarchy Label Graph Construction. Given a relation set R of a KGG (e.g., Freebase), which consists of base-level relations (e.g., /peo-ple/person/ethnicity), we can generate the corresponding higher-level relation set RH . The relations in a high-level set (e.g., people) are more general and common; they usually contain several sub-relations in the base-level set. The relation hierarchies are tree-structured, and the generation process can be done recursively. We use a virtual father node to construct the highest level associa-2 For datasets without predefined relation hierarchies, hierarchy clustering (Johnson, 1967) or K-means can construct relation hierarchies (Zhang et al., 2018b); details can be found in supplementary materials. tions between relations as shown in Figure 3. In practice, we start from R 0 = R which is the set of all relations we focus on for RE, and the generation process is performed L  1 times to get the hierarchical relation sets {R 0 , R 1 , ..., RL } , where RL is the virtual father node. Each node has a specific type t  { 0 , 1 , ..., L } to identify its layer hierarchies. For example, as shown in Figure 3, node /people/person/ethnicity has a specific type 0 to indicate it is in the bottom layer of the graph. The vectors of each node in the bottom layer are initialized through pretrained TransE (Bordes et al., 2013) KG embeddings. Other KG embeddings such as TransR (Lin et al., 2015) can also be adopted. Their parent nodes are initialized by averaging all children vectors. For example, the node vector of /people/person/ is initialized by averaging all the nodes under the branch of /peo-ple/person/* (all child nodes). GCN Output Layer. Due to one-to-multiple relations and incompleteness in KGs, the implicit relevant information obtained by KG embeddings for each label is not enough. Therefore, we apply GCNs to learn explicit relational knowledge among labels. We take advantage of the structured knowledge over our label space using a two-layer GCNs. Starting with the pretrained relation embedding v impliciti  R d from KGs, we combine the label vectors of the children and parents for the i -th label to form, v 1 i = f ( W 1 v i + (cid:88) j N p W 1 p v j |N p | + (cid:88) j N c W 1 c v j |N c | + b 1 g ) (1) where W 1  R q  d , W 1 p  R q  d , W 1 c  R q  d , b 1 g  R q , f is the rectified linear unit (Nair and Hinton, 2010) function, and N c ( N p ) is the index set of the i -th labels children (parents). We use different parameters to distinguish each edge type where parent edges represent all edges from high level labels and child edges represent all edges from low level labels. The second layer follows the same formulation as the first layer and outputs v expliciti . Finally, we concatenate both pretrained v impliciti with GCNs node vector v expliciti to form hierarchy class embeddings, q r = v impliciti || v expliciti (2) where q r  R d + q . Traditionally, the output layer of PCNN/CNN would learn label specific parameters optimized by a cross-entropy loss. However, the label specific parameters spaces are unique to each relation, matrices associated with the long-tails can only be exposed to very few facts during training, resulting in poor generalization. Instead, our method attempts to match sentence vectors to their corresponding class embeddings rather than learning label specific attention parameters. In essence, this becomes a retrieval problem. Relevant information from class embeddings contains useful relational knowledge for long-tails among labels. Practically, given the entity pair ( h, t ) and its bag of instances S h,t = { s 1 , s 2 , ..., s m } , we achieve the instance embeddings { s 1 , s 2 , ..., s m } using the sentence encoder. We group the class embeddings according to their type (i.e., according to their layers in the hierarchy label graph), e.g., q r i , i  { 0 , 1 , ..., L } . We adopt q r i , i (cid:54) = L (layer L is the virtual father node) as layer-wise attention query vector. Then, we apply coarse-to-fine knowledge-aware attention to them to obtain the textual relation representation r h,t . For a relation r , we construct its hierarchical chain of parent relations ( r 0 , ..., r L  1 ) using the hierarchy label graph, where r i  1 is the sub-relation of r i . We propose the following formulas to compute the attention weight (similarity or relatedness) between each instances feature vector s k and q r i , e k = W s ( tanh [ s k ; q r i ]) + b s  ik = exp ( e k ) (cid:80) mj =1 exp ( e j ) (3) where [ x 1 ; x 2 ] denotes the vertical concatenation of x 1 and x 2 , W s is the weight matrix, and b s is the bias. We compute attention operations on each layer of hierarchy label graph to obtain corresponding textual relation representations, r ih,t = AT T ( q r i , { s 1 , s 2 , ..., s m } ) (4) Then we need to combine the relation representations on different layers. Direct concatenation of all the representations is a straightforward choice. However, different layers have different contributions for different tuples. For example, the relation /location/br state/ has only one sub-relation /loca-tion/br state/capital, which indicates that it is more important. In other words, if the sentence has high attention weights on relation /location/br state/, it has a very high probability to have relation /loca-tion/br state/capital. Hence, we use an attention mechanism to emphasize the layers, g i = W g tanh ( r h,t )  i = exp ( g i ) (cid:80) L  1 j =0 exp ( g j ) (5) where W g is a weight matrix, r h,t is referred to as a query-based function that scores how well the input textual relation representations and the predict relation r match. The textual relation representations in each layer are computed as, r ih,t =  i r ih,t (6) We simply concatenate the textual relation representations on different layers as the final representation, r h,r = Concat ( r 0 h,t , .., r L  1 h,t ) (7) The representation r h,t will be finally fed to compute the conditional probability P ( r | h, t, S h,t ) , P ( r | h, t, S h,t ) = exp ( o r ) (cid:80)  r  R exp ( o  r ) (8) where o is the score of all relations defined as, o = Mr h,t (9) where M is the representation matrix to calculate the relation scores. Note that, attention weight q r i is obtained from the outputs of GCNs and pretrained KG embeddings, which can provide more informative parameters than data-driven learned parameters, especially for long-tails. We evaluate our models on the NYT dataset developed by (Riedel et al., 2010), which has been widely used in recent studies (Lin et al., 2016; Liu et al., 2017; Wu et al., 2017; Feng et al., 2018). The dataset has 53 relations including the NA relation, which indicates that the relations of instances are not available. The training set has 522611 sentences, 281270 entity pairs, and 18252 relational facts. In the test set, there are 172448 sentences, 96678 entity pairs, and 1950 relational facts. In both training and test set, we truncate sentences with more than 120 words into 120 words. We evaluate all models in the held-out evaluation. It evaluates models by comparing the relational facts discovered from the test articles with those in Freebase and provides an approximate measure of precision without human evaluation. For evaluation, we draw precision-recall curves for all models. To further verify the effect of our model for long-tails, we follow previous studies (Han et al., 2018b) to report the Precision@N results. The dataset and baseline code can be found on Github 3 . To fairly compare the results of our models with those baselines, we also set most of the experimental parameters by following (Lin et al., 2016). We apply dropout on the output layers of our models to prevent overfitting. We also pretrain the sentence encoder of PCNN before training our model. 3 https://github.com/thunlp/OpenNRE 4 Details of hyper-parameters settings and evaluation of different instances can be found in supplementary materials Training Instances Hits@K (Macro) < 100 < 200 10 15 20 10 15 20 CNN +ATT < 5.0 < 5.0 18.5 < 5.0 16.2 33.3 +HATT 5.6 31.5 57.4 22.7 43.9 65.1 +KATT 9.1 41.3 58.5 23.3 44.1 65.4 PCNN +ATT < 5.0 7.4 40.7 17.2 24.2 51.5 +HATT 29.6 51.9 61.1 41.4 60.6 68.2 +KATT 35.3 62.4 65.1 43.2 61.3 69.2 Table 1: Accuracy (%) of Hits@K on relations with training instances fewer than 100/200. To evaluate the performance of our proposed model, we compare the precision-recall curves of our model with various previous RE models. The evaluation results are shown in Figure 4 and Figure 5. We report the results of neural architectures including CNN and PCNN with various attention based methods: +KATT denotes our approach, +HATT is the hierarchical attention method (Han et al., 2018b), +ATT is the plain selective attention method over instances (Lin et al., 2016), +ATT+ADV is the denoising attention method by adding a small adversarial perturbation to instance embeddings (Wu et al., 2017), and +ATT+SL is the attention-based model using soft-labeling method to mitigate the side effect of the wrong labeling problem at entity-pair level (Liu et al., 2017). We also compare our method with feature-based models, including Mintz (Mintz et al., 2009), MultiR (Hoffmann et al., 2011) and MIML (Surdeanu et al., 2012). As shown in both figures, our approach achieves the best results among all attention-based models. Even when compared with PCNN+HATT, PCNN+ATT+ADV, and PCNN+ATT+SL, which adopt sophisticated denoising schemes and extra information, our model is still more advantageous. This indicates that our method can take advantage of the rich correlations between relations through KGs and GCNs, which improve the performance. We believe the performance of our model can be further improved by adopting additional mechanisms like adversarial training, and reinforcement learning, which will be part of our future work. To further demonstrate the improvements in performance for long-tail relations, following the study by (Han et al., 2018b) we extract a subset of the test dataset in which all the relations have fewer than 100/200 training instances. We employ the Hits@K metric for evaluation. For each entity pair, the evaluation requires its corresponding golden relation in the first K candidate relations recommended by the models. Because it is difficult for the existing models to extract long-tail relations, we select K from { 10,15,20 } . We report the macro average Hits@K accuracies for these subsets because the micro-average score generally overlooks the influences of long-tails. From the results shown in Table 1, we observe that for both CNN and PCNN models, our model outperforms the plain attention model and the HATT model. Although our KATT method has achieved better results for long-tail relations as compared to both plain ATT method and HATT method, the results of all these methods are still far from satisfactory. This indicates that distantly supervised RE models still suffer from the long-tail relation problem, which may require additional schemes and extra information to solve this problem in the future. To analyze the contributions and effects of different technologies in our approach, we perform ablation tests. +KATT is our method; w/o hier is the method without coarse-to-fine attention (only utilizes bottom node embeddings of the hierarchy label graph), which implies no knowledge transfer from its higher level classes; w/o GCN is the method without GCNs, which implies no explicit relational knowledge; Word2vec is the method in which the node is initialized with pretrained Skip-Gram (Mikolov et al., 2013) embeddings; and w/o KG is the method in which the node is initialized with random embeddings, which implies no prior relational knowledge from KGs. From the evaluation results in Table 2, we observe that the performance slightly degraded without coarse-to-fine attention, which proves that knowledge transfer from the higher node is useful. We also noticed that the performance slightly degraded without KG or using word embeddings, and the perfor-(a) HATT mance significantly degraded when we removed GCNs. This is reasonable because GCNs can learn more explicit correlations between relation labels, which boost the performance for long-tail relations. We give some examples to show how our method affects the selection of sentences. In Table 3, we display the sentence's attention score in the lowest level 5 . Both the relation /people/deceased person/place of burial (24 instances) and /location/br state/capital (4 instances) are long-tail relations. On one hand, relation /peo-ple/deceased person/place of burial has semantically similar data-rich relation such as /peo-ple/deceased person/place of death. We observe that HATT erroneously assigns high attention to the incorrect sentence whereas KATT successfully assigns the right attention weights, which demon-5 Both HATT and KATT methods can successfully select the correct sentence at the higher-level; details can be found in supplementary materials. strates the efficacy of knowledge transfer from semantically similar relations (Both HATT and KATT methods can take advantage of knowledge transfer of high-level relations.). On the other hand, the relation /location/br state/capital does not have semantically similar relations. However, we notice that KATT still successfully assigns the right attention weights, which demonstrates the efficacy of knowledge transfer from high-level relations using coarse-to-fine knowledge-aware attention. We visualize the class embeddings via t-SNE (Maaten and Hinton, 2008) to further show how GCNs and KG embeddings can help RE for longtail relations. We observe that (1) Figure 6(a) and 6(d) show that semantically similar class embeddings are closer with GCNs and pretrained KG embeddings, which help select long-tail instances. (2) Figure 6(b) and 6(c) show that KG embeddings and GCNs have different contributions for different relations to learn relational knowledge between classes. For example, /location/location/contain has a sparse hierarchy structure, which leads to inefficient learning for GCNs; therefore, the relative distance changes only slightly, which reveals the necessity of implicit relational knowledge from KGs. (3) Figure 6(d) shows that there are still some semantically similar class embeddings located far away, which may degrade the performance for long-tails. This may be caused by either sparsity in the hierarchy label graph or equal treatment for nodes with the same parent in GCNs, which is not a reasonable hypothesis. We will address this by integrating more information such as relation descriptions or combing logic reasoning as a part of future work. In this paper, we take advantage of the knowledge from data-rich classes at the head of distribution to boost the performance of the data-poor classes at the tail. As compared to previous methods, our approach provides fine-grained relational knowledge among classes using KG and GCNs, which is quite effective and encoder-agnostic. In the future, we plan to explore the following directions: (1) We may combine our method with recent denoising methods to further improve performance. (2) We may combine rule mining and reasoning technologies to learn better class embeddings to boost performance. (3) It will be promising to apply our method to zero-shot RE and further adapt to other NLP scenarios. We want to express gratitude to the anonymous reviewers for their hard work and kind comments, which will further improve our work in the future. This work is funded by NSFC91846204/61473260, national key research program YS2018YFB140004, Alibaba CangJingGe (Knowledge Engine) Research Plan and Natural Science Foundation of Zhejiang Province of China (LQ19F030001).
objective abstain method objective abstain objective abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain method abstain abstain result abstain abstain abstain abstain abstain abstain method abstain abstain result other other other other other other other other other other other other abstain other other other other other other other objective other other other other other other abstain other other other method abstain abstain abstain method abstain abstain abstain method method abstain method abstain abstain method abstain abstain method abstain abstain abstain method method method abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method method method abstain method abstain abstain abstain abstain abstain abstain abstain method abstain method other abstain abstain abstain abstain abstain other method abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain result abstain abstain other abstain abstain result abstain result abstain result result abstain abstain abstain abstain abstain abstain result result abstain abstain other result abstain abstain abstain abstain result abstain abstain abstain result abstain abstain abstain result result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method objective method method other other