TIE: A Framework for Embedding-based Incremental Temporal Knowledge Graph Completion

Jiapeng Wu^† McGill University, MILAMontrealCanada [email protected] , Yishi Xu^† University of Montreal, MILAMontrealCanada [email protected] , Yingxue Zhang Montreal Research Center, Huawei Noah’s Ark LabMontrealCanada [email protected] , Chen Ma^† McGill UniversityMontrealCanada [email protected] , Mark Coates McGill UniversityMontrealCanada [email protected] and Jackie Chi Kit Cheung McGill University, MILAMontrealCanada [email protected]

(2021)

Abstract.

Reasoning in a temporal knowledge graph (TKG) is a critical task for information retrieval and semantic search. It is particularly challenging when the TKG is updated frequently. The model has to adapt to changes in the TKG for efficient training and inference while preserving its performance on historical knowledge. Recent work approaches TKG completion (TKGC) by augmenting the encoder-decoder framework with a time-aware encoding function. However, naively fine-tuning the model at every time step using these methods does not address the problems of 1) catastrophic forgetting, 2) the model’s inability to identify the change of facts (e.g., the change of the political affiliation and end of a marriage), and 3) the lack of training efficiency. To address these challenges, we present the Time-aware Incremental Embedding (TIE) framework, which combines TKG representation learning, experience replay, and temporal regularization. We introduce a set of metrics that characterizes the intransigence of the model and propose a constraint that associates the deleted facts with negative labels.

Experimental¹ results on Wikidata12k and YAGO11k datasets demonstrate that the proposed TIE framework reduces training time by about ten times and improves on the proposed metrics compared to vanilla full-batch training. It comes without a significant loss in performance for any traditional measures. Extensive ablation studies reveal performance trade-offs among different evaluation metrics, which is essential for decision-making around real-world TKG applications.

^†^†footnotetext: ^†Work done as an intern at Huawei Noah’s Ark Lab Montreal Research Center.^†^†footnotetext: ¹Code and data are available at: https://github.com/JiapengWu/Time-Aware-Incremental-Embedding

Temporal Knowledge Graph; Incremental Learning

^†^†journalyear: 2021^†^†copyright: acmcopyright^†^†conference: Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval; July 11–15, 2021; Virtual Event, Canada.^†^†booktitle: Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR ’21), July 11–15, 2021, Virtual Event, Canada^†^†price: 15.00^†^†isbn: 978-1-4503-8037-9/21/07^†^†doi: 10.1145/3404835.3462961^†^†ccs: Computing methodologies Temporal reasoning

1. Introduction

Knowledge graphs (KGs), consisting of triples in the form of (head entity, relationship, tail entity), are effective data structures for representing factual knowledge and lie at the core of many downstream tasks; e.g.,, question answering (Zhang et al., 2018; Lukovnikov et al., 2017; Huang et al., 2019) and web search (Paulheim, 2017). Although KGs enable powerful relational reasoning, they are usually incomplete. As such, inferring new facts based on existing ones in the KG, known as KG completion, is one of the most important tasks in KG research.

Typical KGs represent knowledge facts without incorporating temporal information, which is sufficient under some circumstances (Bordes et al., 2013; Yang et al., 2014; Trouillon et al., 2016). By additionally associating each triple with a timestamp, such as (Obama, visit, China, 2014), temporal knowledge graphs (TKGs) are able to consider the temporal dynamics. Usually, TKGs are assumed to consist of discrete timestamps (Jiang et al., 2016a). They can be represented as a sequence of static KG snapshots. The task of inferring missing facts across these snapshots is referred to as temporal knowledge graph completion (TKGC).

To tackle the TKGC task, two avenues of work have been explored. The first line of models induces time-dependent representation with time-agnostic decoding functions to extend static KGC methods for capturing the temporal dynamics (Dasgupta et al., 2018; Goel et al., 2020). The second category of methods adopts spatial-temporal models, which leverage graph neural networks (GNNs) to capture the intra-graph structural information and inter-graph temporal dependencies (Wu et al., 2020). We argue that there are still several areas for improvement.

First, previous methods do not explicitly formulate the incremental learning problem, where the change (addition and deletion) of historical information is incrementally available, and the model is expected to adapt to the changes while maintaining its knowledge about the historical facts. Naively, one might fine-tune the TKGC model with all available data at each new time step using gradient descent optimization. This, however, causes the model performance on the historical task to degrade quickly, a phenomenon known as catastrophic forgetting (McCloskey and Cohen, 1989; Xu et al., 2020), which usually occurs because the model loses track of the key static features derived from earlier data. Second, previous methods usually only assess overall link prediction metrics such as Hits@10 and Mean Reciprocal Rank (MRR) while omitting the dynamic aspects of the TKG performance. There is an absence of metrics that can evaluate how well a model forgets deleted facts. For example, the quadruple (Trump, presidentOf, US, 2020) is no longer true in 2021. Hence we would like the model to rank Biden higher than Trump given the query (?, presidentOf, US, 2021). We argue that this is an essential measure of a model’s effectiveness in modeling the temporal dynamics of TKGs. Third, as discussed in Section LABEL:sec:problem_formulation, previous TKGC methods (Dasgupta et al., 2018; Goel et al., 2020) conduct training and evaluation once across all the time steps. This does not satisfy the scalability and training efficiency requirements in real-world KG applications, where millions of entities and relations frequently update (Vashishth et al., 2020; Ahrabian et al., 2020).

Present Work

We introduce a new task, incremental TKGC, and propose TIE, a training and evaluation framework that integrates incremental learning with TKGC. TIE combines TKG representation learning, experience replay, temporal regularization to improve model performance and alleviate catastrophic forgetting.

To measure TKGC models’ ability to discern facts that were true in the past but false at present, we propose new evaluation metrics dubbed Deleted Facts Hits@10 (DF) and Reciprocal Rank Difference Measure (RRD). To this end, we explicitly associate deleted quadruples with negative labels and integrate them into the training process, which shows improvement upon the two metrics compared to baseline methods.

Finally, we show that training using added facts significantly improves the training speed and reduces dataset size by around ten times while maintaining a similar ranking performance level compared to vanilla fine-tuning methods.

We adapt HyTE (Dasgupta et al., 2018) and DE (Goel et al., 2020), two existing TKGC models, to the incremental learning task on wikidata12k and YAGO11k datasets. Experiments results demonstrate that the proposed TIE framework reduces training time by about ten times and improves some of the proposed metrics compared to the full-batch training. It comes without a significant loss in any traditional measures. Extensive ablation studies reveal the performance trade-offs among different evaluation metrics, providing insights for choosing among model variations.

2. Related Work

2.1. Temporal KG Completion

Existing TKGC methods can be broadly categorized into two lines of work. The first line uses shallow encoders with time-sensitive decoding functions to extend static KGC methods (Jiang et al., 2016b; Dasgupta et al., 2018; Goel et al., 2020; Xu et al., 2019). For example, (Dasgupta et al., 2018) constrains entity and relation embeddings. The decoded scores of triples lie in different hyperplanes for each timestamp. The second line of methods uses spatiotemporal models, which leverage graph neural networks (GNNs) to capture intra-graph neighborhood information and temporal recurrence or attention mechanisms to capture temporal information (Wu et al., 2020; Jin et al., 2020; Sankar et al., 2020). The third line of methods leverages temporal point processes to deal with continuous prediction in TKGs (Trivedi et al., 2017, 2019; Han et al., 2020). However, this line of work is orthogonal to ours as their focus is the extrapolation task in the TKG, which aims at predicting the future interactions among entities and relations.

In our work, we aim to provide an efficient incremental learning framework for TKGC. Hence we focus on the shallow embedding methods.

2.2. Incremental Learning

As knowledge graphs evolve, more graph snapshots become available. However, deep learning models suffer from catastrophic forgetting when existing models are incrementally fine-tuned according to the newly available data (Kirkpatrick et al., 2017; Castro et al., 2018). Various incremental learning techniques have been introduced to combat this issue for deep learning models. Our work is closely related to the experience replay and regularization-based methods. Experience replay, also referred to as reservoir sampling, retains an additional set of the most representative historical data. Rehearsal methods (Rebuffi et al., 2017; Chaudhry et al., 2019b; Isele and Cosgun, 2018; Prabhu et al., 2020) explicitly maintain a pool of historical data when training the model on new tasks. One of the earliest methods, iCarLR (Rebuffi et al., 2017), sets the fixed number of samples for each task and selects samples that best approximate the feature mean of each class. Constrained optimization methods also belong to this category. Previous work (Lopez-Paz and Ranzato, 2017; Chaudhry et al., 2019a) exploits the stored samples to project the gradient of the current task’s loss to a desired region. The objective is to ensure that the loss on the historical samples will decrease after training on the current task. This is equivalent to projecting the gradients of the current data to a direction that aligns with the gradients of the previous data. Regularization-based approaches consolidate previous knowledge by introducing regularization terms in the loss when learning on new data (Kirkpatrick et al., 2017; Castro et al., 2018; Yang et al., 2019; Zenke et al., 2017).

More recent work has explored applying incremental learning techniques for training deep graph neural networks. GraphSAIL (Xu et al., 2020) tackles the GNN-based recommendation system’s forgetting issue using knowledge distillation at both node and graph levels. ER-GNN (Zhou et al., 2020) proposes node importance metrics and selects the most influential nodes in the graph as reservoir data. The model is fine tuned on the new data as well as the selected nodes during the training. A more relevant work (Song and Park, 2018) applies the regularization-based method to enrich embeddings in knowledge graphs. However, the method in (Song and Park, 2018) focuses on data synthesized by subdividing a static knowledge graph into multiple snapshots.

In our work, we propose an end-to-end framework combining experience replay and regularization-based methods that are specifically tailored for incrementally training TKGC tasks.

3. Problem Setup and Formulation

In this section, we introduce notations, specify assumptions, and describe the encoder-decoder framework for the standard TKGC (Wu et al., 2020). This is the foundation of our TIE framework for incremental TKGC.

4. Metrics

We start by introducing commonly used evaluation metrics in standard TKGC, followed by the notions of current, historical average, and intransigence measures in the context of TKGC to quantify the different aspects of model capacity.

4.1. Standard TKGC Metrics

For each quadruple $(s,r,o,t)\in D^{t}_{test}$ , we evaluate an object query $(s,r,?,t)$ and a subject query $(?,r,o,t)$ . Regarding the object query, we calculate the scores for all known entities, i.e., $\phi(s,r,o^{\prime},t),\forall o^{\prime}\in E^{t}$ . The ranks are obtained by sorting the scores in descending order. Thereafter this is used to compute commonly used metrics such as Mean Reciprocal Rank (MRR) and Hits@k (k is usually 1, 3, and 10). The Hits@k is the percentage of test facts for which the correct entity’s rank is at most $k$ . For $k=10$ , we have the Hits@10 metrics, defined for object queries as:

(1)

\frac{1}{|D^{t}_{test}|}\sum_{(s,r,o,t)\in D^{t}_{test}}I(\text{rank}(o|s,r,t)\leq 10)\,,

where $I$ is the indicator function.

4.2. Incremental TKGC Metrics

Since the objective of incremental TKGC is to incorporate facts from new time steps while preserving knowledge derived from the previous ones, an incremental learning approach should be evaluated based on its performance on both the current and historical quadruples. Additionally, we would like them to measure a model’s ability to discern changes in the validity of facts at a different point in time, e.g., change of political affiliation or end of a marriage.

Current and Historical Average Measure

Let $\alpha_{t,j}$ be the Hits@10 value specified in Equation (1) evaluated on $D^{j}_{test}$ , ( $j\leq t$ ), using the model incrementally trained after time step $t$ . The current performance measure ( $C$ ) is written as $C_{t}=\alpha_{t,t}$ .

We adapt the Average Accuracy Measure proposed in (Chaudhry et al., 2018) to the TKGC setting, replacing the accuracy with the Hits@10 measure. The Average Hits@10 ( $A$ ) at time step $t$ is defined as $A_{t}=\frac{1}{t}\sum_{i=1}^{t}\alpha_{t,i}$ . The higher the value of $A_{t}$ , the better the model in terms of historical average performance, which is an important aspect for TKGC evaluation. This, to some degree, also measures whether a model is prone to catastrophic forgetting. A model that cannot retain past knowledge would yield a much lower $A_{t}$ than a model trained using all the historical data.

Intransigence Measure

In the context of TKGC, we define intransigence as the inability of an algorithm to identify knowledge that was true in the past but false at present. For example, after graduating from a college, a student is no longer associated with the college.

We categorize the measure into the model’s ability to 1) assign a low rank to the deleted facts and 2) rank the currently valid facts above the deleted facts. We propose Deleted Facts Hits@10 (DF) and Reciprocal Rank Difference (RRD) to measure the two aspects. The DF is analogous to the false positive rate in the classification setting, measuring the rank of the deleted triples’ current time step as their time attributes. A lower DF value suggests that a model has a better capability to exclude deleted facts from the top 10 results.

The RRD is defined as the pairwise difference of reciprocal ranks between each positive quadruple in the test set and each deleted fact in the previous data. RRD implicitly focuses on the cases where the rank value of either the positive object $o$ or the negative object $o^{\prime}$ is low, e.g., $\frac{1}{1}-\frac{1}{10}=0.9$ , while discounting the cases where both rank values are high, e.g. $\frac{1}{1000}-\frac{1}{1010}\approx 9.9\times 10^{-6}$ .

We define a time window ranging from $t-\tau_{d}$ to $t{-}1$ to limit the scope of evaluation. For every quadruple $(s,r,o,t)$ , we aim to find and then evaluate the related deleted facts from this time window. We define the DF and RRD metrics for object queries at time step $t$ :

(2)

\text{DF}_{t}\triangleq\frac{1}{Z_{t}}\sum_{(s,r,o,t)\in D_{test}^{t}}\sum_{o^{\prime}\in O^{\prime}_{s,r,t}}I(\text{rank}(o^{\prime}|s,r,t)\leq k),

(3)

\text{RRD}_{t}\triangleq\frac{100}{Z_{t}}\sum_{(s,r,o,t)\in D_{test}^{t}}\sum_{o^{\prime}\in O^{\prime}_{s,r,t}}\Big{(}\frac{1}{\text{rank}(o|s,r,t)}-\frac{1}{\text{rank}(o^{\prime}|s,r,t)}\Big{)},

where $O^{\prime}_{s,r,t}$ is the collection of negative objects and $Z_{t}$ is the normalizing constant:

O^{\prime}_{s,r,t}=\{o^{\prime}|\exists t^{\prime}\in\{t{-}\tau_{d}...t{-}1\},\exists o^{\prime}\in E^{t^{\prime}}_{known},(s,r,o^{\prime},t^{\prime})\in D^{t^{\prime}}\},

Z_{t}=\sum_{(s,r,o,t)\in D_{test}^{t}}|O^{\prime}_{s,r,t}|.

In practice, the RRD values are very close to zero. Hence we multiply the RRD by a factor of 100 for better presentation. The intransigence metrics for subject queries can be defined analogously.

5. Proposed Framework: TIE

We provide an overview of TIE before describing the proposed methods in detail in the following sections.

Refer to caption — Figure 1. A high-level illustration of the full TIE model. The four types of arrows represent the process of producing different loss terms.

5.1. Overview

We establish the TIE framework that augments the TKGC encoder-decoder framework (Section LABEL:sec:encoder_decoder) with incremental learning techniques, a method to overcome intransigence, and an efficient training strategy. The overall architecture of TIE model is depicted in Figure 1. Algorithm LABEL:algorithm_core outlines the representation learning procedure of TIE.

A key insight of our framework is that we adapt experience replay and temporal regularization techniques (Sections LABEL:sec:experience_replay and LABEL:sec:regularization) to address the catastrophic forgetting issues of fine-tuning methods using TKG representation learning models. Additionally, we propose to use the deleted facts from the recent time steps as a subset of negative training examples to address the intransigence issue of the state-of-the-art TKGC methods. Finally, we propose to use newly added facts only for fine-tuning at each time step. This is based on the finding that the particular type of TKGs of most interest is composed primarily of persistent facts, i.e., the average duration of facts is typically long enough that no drastic changes occur between adjacent time steps.

6. Experiments

We evaluate the performance of our models on two standard TKGC benchmark datasets using our proposed evaluation protocol. We also conduct various ablation studies investigating the effectiveness of individual and combined components of the proposed methods.

7. Conclusion

We present a novel incremental learning framework named TIE for TKGC tasks. TIE combines TKG representation learning, frequency-based experience replay, and temporal regularization to improve the model’s performance on both current and past time steps. TIE leverages pattern frequencies to select among reservoir samples and uses only the deleted and added facts at the current time step for training, which significantly reduces training time and the size of training data. Moreover, we propose DF and RRD metrics to measure the intransigence of the model. Extensive ablation studies shows each proposed component’s effectiveness. They also provide insights for deciding among model variations by revealing performance trade-offs among various evaluation metrics.

This work serves as a first attempt and exploration to apply incremental learning to TKGC tasks. Future work might involve exploring other incremental learning techniques, such as constrained optimization, to achieve more robust performance across datasets and metrics.

Acknowledgement

This research was supported in part by Noah’s Ark Lab (Montreal Research Centre), CIFAR Canada AI Chair program, FRQNT ^†^†The Fonds de Nature et technologies of Quebec and Samsung Electronics. The authors would like to thank Noah’s Ark Lab for providing the computational resources.

References

(1)
Ahrabian et al. (2020) Kian Ahrabian, Daniel Tarlow, Hehuimin Cheng, and Jin LC Guo. 2020. Software Engineering Event Modeling using Relative Time in Temporal Knowledge Graphs. arXiv preprint arXiv:2007.01231 (2020).
Bordes et al. (2013) Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. 2013. Translating embeddings for modeling multi-relational data. In Advances in neural information processing systems. 2787–2795.
Castro et al. (2018) Francisco M Castro, Manuel J Marín-Jiménez, Nicolás Guil, Cordelia Schmid, and Karteek Alahari. 2018. End-to-end incremental learning. In Proceedings of the European conference on computer vision (ECCV). 233–248.
Chaudhry et al. (2018) Arslan Chaudhry, Puneet K Dokania, Thalaiyasingam Ajanthan, and Philip HS Torr. 2018. Riemannian walk for incremental learning: Understanding forgetting and intransigence. In Proceedings of the European Conference on Computer Vision (ECCV). 532–547.
Chaudhry et al. (2019a) Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. 2019a. Efficient Lifelong Learning with A-GEM. In International Conference on Learning Representations. https://openreview.net/forum?id=Hkf2_sC5FX
Chaudhry et al. (2019b) Arslan Chaudhry, Marcus Rohrbach, Mohamed Elhoseiny, Thalaiyasingam Ajanthan, Puneet K Dokania, Philip HS Torr, and M Ranzato. 2019b. Continual learning with tiny episodic memories. (2019).
Dasgupta et al. (2018) Shib Sankar Dasgupta, Swayambhu Nath Ray, and Partha Talukdar. 2018. Hyte: Hyperplane-based temporally aware knowledge graph embedding. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. 2001–2011.
Erxleben et al. (2014) Fredo Erxleben, Michael Günther, Markus Krötzsch, Julian Mendez, and Denny Vrandečić. 2014. Introducing Wikidata to the linked data web. In International semantic web conference. Springer, 50–65.
Falcon et al. (2019) WEA Falcon et al. 2019. Pytorch lightning. GitHub. Note: https://github. com/williamFalcon/pytorch-lightning Cited by 3 (2019).
Glorot and Bengio (2010) Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics. JMLR Workshop and Conference Proceedings, 249–256.
Goel et al. (2020) Rishab Goel, Seyed Mehran Kazemi, Marcus Brubaker, and Pascal Poupart. 2020. Diachronic embedding for temporal knowledge graph completion. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 34. 3988–3995.
Han et al. (2020) Zhen Han, Yuyi Wang, Yunpu Ma, Stephan Guünnemann, and Volker Tresp. 2020. The Graph Hawkes Network for Reasoning on Temporal Knowledge Graphs. arXiv preprint arXiv:2003.13432 (2020).
Hinton et al. (2015) Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. 2015. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531 (2015).
Huang et al. (2019) Xiao Huang, Jingyuan Zhang, Dingcheng Li, and Ping Li. 2019. Knowledge graph embedding based question answering. In Proceedings of the Twelfth ACM International Conference on Web Search and Data Mining. 105–113.
Isele and Cosgun (2018) David Isele and Akansel Cosgun. 2018. Selective experience replay for lifelong learning. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 32.
Jiang et al. (2016a) Tingsong Jiang, Tianyu Liu, Tao Ge, Lei Sha, Baobao Chang, Sujian Li, and Zhifang Sui. 2016a. Towards time-aware knowledge graph completion. In Proceedings of COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers. 1715–1724.
Jiang et al. (2016b) Tingsong Jiang, Tianyu Liu, Tao Ge, Lei Sha, Baobao Chang, Sujian Li, and Zhifang Sui. 2016b. Towards Time-Aware Knowledge Graph Completion. In Proceedings of COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers. The COLING 2016 Organizing Committee, 1715–1724.
Jin et al. (2020) Woojeong Jin, Meng Qu, Xisen Jin, and Xiang Ren. 2020. Recurrent Event Network: Autoregressive Structure Inference over Temporal Knowledge Graphs. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). 6669–6683.
Kirkpatrick et al. (2017) James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. 2017. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences (2017).
Leblay and Chekol (2018) Julien Leblay and Melisachew Wudage Chekol. 2018. Deriving validity time in knowledge graph. In Companion Proceedings of the The Web Conference 2018. International World Wide Web Conferences Steering Committee, 1771–1776.
Lopez-Paz and Ranzato (2017) David Lopez-Paz and Marc’Aurelio Ranzato. 2017. Gradient episodic memory for continual learning. In Advances in neural information processing systems. 6467–6476.
Lukovnikov et al. (2017) Denis Lukovnikov, Asja Fischer, Jens Lehmann, and Sören Auer. 2017. Neural network-based question answering over knowledge graphs on word and character level. In Proceedings of the 26th international conference on World Wide Web. 1211–1220.
Mahdisoltani et al. (2013) Farzaneh Mahdisoltani, Joanna Biega, and Fabian M Suchanek. 2013. Yago3: A knowledge base from multilingual wikipedias.
McCloskey and Cohen (1989) Michael McCloskey and Neal J Cohen. 1989. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation. Vol. 24. Elsevier, 109–165.
Paulheim (2017) Heiko Paulheim. 2017. Knowledge graph refinement: A survey of approaches and evaluation methods. Semantic web 8, 3 (2017), 489–508.
Prabhu et al. (2020) Ameya Prabhu, Philip HS Torr, and Puneet K Dokania. 2020. GDumb: A simple approach that questions our progress in continual learning. In European Conference on Computer Vision. Springer, 524–540.
Rebuffi et al. (2017) Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. 2017. icarl: Incremental classifier and representation learning. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition.
Sankar et al. (2020) Aravind Sankar, Yanhong Wu, Liang Gou, Wei Zhang, and Hao Yang. 2020. DySAT: Deep Neural Representation Learning on Dynamic Graphs via Self-Attention Networks. In Proceedings of the 13th International Conference on Web Search and Data Mining. 519–527.
Song and Park (2018) Hyun-Je Song and Seong-Bae Park. 2018. Enriching Translation-Based Knowledge Graph Embeddings Through Continual Learning. IEEE Access 6 (2018), 60489–60497.
Trivedi et al. (2017) Rakshit Trivedi, Hanjun Dai, Yichen Wang, and Le Song. 2017. Know-evolve: Deep temporal reasoning for dynamic knowledge graphs. In Proceedings of the 34th International Conference on Machine Learning-Volume 70. JMLR. org, 3462–3471.
Trivedi et al. (2019) Rakshit Trivedi, Mehrdad Farajtabar, Prasenjeet Biswal, and Hongyuan Zha. 2019. DyRep: Learning Representations over Dynamic Graphs. In International Conference on Learning Representations. https://openreview.net/forum?id=HyePrhR5KX
Trouillon et al. (2016) Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. 2016. Complex embeddings for simple link prediction. In International Conference on Machine Learning. 2071–2080.
Vashishth et al. (2020) Shikhar Vashishth, Soumya Sanyal, Vikram Nitin, and Partha Talukdar. 2020. Composition-based Multi-Relational Graph Convolutional Networks. In International Conference on Learning Representations. https://openreview.net/forum?id=BylA_C4tPr
Wu et al. (2020) Jiapeng Wu, Meng Cao, Jackie Chi Kit Cheung, and William L Hamilton. 2020. TeMP: Temporal Message Passing for Temporal Knowledge Graph Completion. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). 5730–5746.
Xu et al. (2019) Chengjin Xu, Mojtaba Nayyeri, Fouad Alkhoury, Jens Lehmann, and Hamed Shariat Yazdi. 2019. Temporal Knowledge Graph Embedding Model based on Additive Time Series Decomposition. arXiv preprint arXiv:1911.07893 (2019).
Xu et al. (2020) Yishi Xu, Yingxue Zhang, Wei Guo, Huifeng Guo, Ruiming Tang, and Mark Coates. 2020. GraphSAIL: Graph Structure Aware Incremental Learning for Recommender Systems. In Proceedings of the 29th ACM International Conference on Information & Knowledge Management. 2861–2868.
Yang et al. (2014) Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. 2014. Embedding entities and relations for learning and inference in knowledge bases. arXiv preprint arXiv:1412.6575 (2014).
Yang et al. (2019) Yang Yang, Da-Wei Zhou, De-Chuan Zhan, Hui Xiong, and Yuan Jiang. 2019. Adaptive Deep Models for Incremental Learning: Considering Capacity Scalability and Sustainability. In Proc. ACM Conf. Knowledge Discovery and Data Mining.
Zenke et al. (2017) Friedemann Zenke, Ben Poole, and Surya Ganguli. 2017. Continual Learning Through Synaptic Intelligence. Proceedings of machine learning research 70 (2017), 3987–3995.
Zhang et al. (2018) Yuyu Zhang, Hanjun Dai, Zornitsa Kozareva, Alexander Smola, and Le Song. 2018. Variational reasoning for question answering with knowledge graph. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 32.
Zhou et al. (2020) Fan Zhou, Chengtai Cao, Ting Zhong, Kunpeng Zhang, Goce Trajcevski, and Ji Geng. 2020. Continual Graph Learning. arXiv:2003.09908 (2020).