ZHANGYUXUAN-zR commited on
Commit
5c9b1c2
·
verified ·
1 Parent(s): 15d24c6

Add files using upload-large-folder tool

Browse files
parse/train/BJg73xHtvr/BJg73xHtvr.md ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/BJg73xHtvr/BJg73xHtvr_content_list.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/BJg73xHtvr/BJg73xHtvr_middle.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/BJg73xHtvr/BJg73xHtvr_model.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/BkVsWbbAW/BkVsWbbAW.md ADDED
@@ -0,0 +1,321 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # DEEP GENERATIVE DUAL MEMORY NETWORK FOR CONTINUAL LEARNING
2
+
3
+ Anonymous authors Paper under double-blind review
4
+
5
+ # ABSTRACT
6
+
7
+ Despite advances in deep learning, artificial neural networks do not learn the same way as humans do. Today, neural networks can learn multiple tasks when trained on them jointly, but cannot maintain performance on learnt tasks when tasks are presented one at a time – this phenomenon called catastrophic forgetting is a fundamental challenge to overcome before neural networks can learn continually from incoming data. In this work, we derive inspiration from human memory to develop an architecture capable of learning continuously from sequentially incoming tasks, while averting catastrophic forgetting. Specifically, our model consists of a dual memory architecture to emulate the complementary learning systems (hippocampus and the neocortex) in the human brain and maintains a consolidated long-term memory via generative replay of past experiences. We (i) substantiate our claim that replay should be generative, (ii) show the benefits of generative replay and dual memory via experiments, and (iii) demonstrate improved performance retention even for small models with low capacity. Our architecture displays many important characteristics of the human memory and provides insights on the connection between sleep and learning in humans.
8
+
9
+ # 1 INTRODUCTION
10
+
11
+ Many machine learning models, when trained sequentially on tasks, forget how to perform the previously learnt tasks. This phenomenon called catastrophic forgetting is prominent in neural networks (McCloskey & Cohen, 1989). Without a way to avert catastrophic forgetting, a learning system needs to store all training data and relearn on it along with new incoming data, when retraining. Hence, it is an important challenge to overcome in order to enable systems to learn continuously.
12
+
13
+ McCloskey & Cohen (1989) first suggested that the underlying cause of forgetting was the distributed shared representation of tasks via network weights. Subsequent works attempted to remedy the issue by reducing representational overlap between input representations via activation sharpening algorithms (Kortge, 1990), orthogonal recoding of inputs (Lewandowsky, 1991) or orthogonal activations at all hidden layers (McRae & Hetherington, 1993; French, 1994). More recent works have explored activations like dropout (Goodfellow et al., 2015) and local winner-takes-all (Srivastava et al., 2013) to create sparse, less correlated feature representations. But such sparse encodings can be task specific at times and in general act as heuristics to mildly pacify the underlying problem.
14
+
15
+ Further, natural cognitive systems are also connectionist in nature and yet they forget gradually but not ‘catastrophically’. For instance, humans demonstrate gradual systematic forgetting. Frequently and recently encountered tasks tend to survive much longer in the human memory, while those rarely encountered are slowly forgotten. Some of the earlier tasks may be seen again, but it is not necessary for them to be retained in memory (French, 1999). Hence only sparsifying representations does not solve the problem. Instead, neuroscientific evidence suggests that humans have evolved mechanisms to separately learn new incoming tasks and consolidate the learning with previous knowledge to avert catastrophic forgetting (McClelland et al., 1995; O’Neill et al., 2010; French, 1999).
16
+
17
+ Complementary learning systems: McClelland et al. (1995) suggested that this separation has been achieved in the human brain via evolution of two separate areas of the brain, the hippocampus and the neocortex. The neocortex is a long term memory which specializes in consolidating new information with previous knowledge and gradually learns the joint structure of all tasks and experiences; whereas the hippocampus acts as a temporary memory to rapidly learn new tasks and then slowly transfer the knowledge to neocortex after acquisition.
18
+
19
+ Experience replay: Another factor deemed essential for sequential learning is experience replay. McClelland et al. (1995); O’Neill et al. (2010) have emphasized the importance of replayed data patterns in the human brain during sleep and waking rest. Robins (1995; 2004) proposed several replay techniques (a.k.a. pseudopattern rehearsal) to achieve replay, but they involved generating replay data without storing input representations and our experiments show that they lack the accuracy required for consolidation.
20
+
21
+ Weight consolidation or freezing: Recent evidence from neuroscience also suggests that mammalian brain protects knowledge in the neocortex via task-specific consolidation of neural synapses over long periods of time (Yang et al., 2014; Benna & Fusi, 2016). Such techniques have recently been employed in progressive neural networks (Rusu et al., 2016) and Pathnets (Fernando et al., 2017) both of which freeze neural network weights after learning tasks. Kirkpatrick et al. (2017) have used the fisher information matrix (FIM) to slow down learning on network weights which correlate with previously acquired knowledge.
22
+
23
+ In this paper, we address the catastrophic forgetting problem by drawing inspiration from the above neuroscientific insights and present a method to overcome catastrophic forgetting. More specifically, we propose a dual-memory architecture for learning tasks sequentially while averting catastrophic forgetting. Our model comprises of two generative models: a short-term memory (STM) to emulate the human hippocampal system and a long term memory (LTM) to emulate the neocortical learning system. The STM learns new tasks without interfering with previously learnt tasks in the LTM. The LTM stores all previously learnt tasks and aids the STM in learning tasks similar to previous tasks. During sleep/down-time, the STM generates and transfers samples of learnt tasks to the LTM. These are gradually consolidated with the LTM’s knowledge base of previous tasks via generative replay.
24
+
25
+ Our approach is inspired from the strengths of deep generative models, experience replay and the complementary learning systems literature. We demonstrate our method’s effectiveness in averting catastrophic forgetting by sequentially learning multiple tasks. Moreover, our experiments shed light on some characteristics of human memory as observed in the psychology and neuroscience literature.
26
+
27
+ # 2 PROBLEM SETTING: SEQUENTIAL MULTITASK LEARNING
28
+
29
+ Formally, our problem setting can be called Sequential Multitask Learning and is characterized by a set of tasks $\mathbb { T }$ , which are to be learnt by a model parameterized by weights $\theta$ (e.g. a neural network). From here on, we will use the the phrase model and neural network interchangeably. In this work we mainly consider supervised learning tasks i.e. task $t \in \mathbb { T }$ has training examples: $\{ x _ { i } ^ { t } , y _ { i } ^ { t } \} _ { i = 1 : N _ { t } }$ for $x _ { i } ^ { t } \in \mathcal X$ and $y _ { i } ^ { t } \in \bar { \mathcal { V } }$ , but our model easily generalizes to unsupervised learning settings. Note that tasks are presented sequentially and the total number of tasks $\lvert \mathbb { T } \rvert$ is not known a priori.
30
+
31
+ Finite memory: We further assume that any training algorithm can store some examples from each task if needed, but the storage $( N _ { m a x } )$ is limited and can be smaller than the total number of examples from all tasks $\left( \sum _ { t = 1 } ^ { | \mathbb { T } | } N _ { t } \right)$ . So, algorithms cannot store all training examples and re-learn on them when new tasks arrive. The same restriction applies to algorithms with generative models i.e. no more than $N _ { m a x }$ examples allowed at any time (generated $^ +$ stored).
32
+
33
+ For testing, the model can be asked to predict the label $y ^ { t } \in \mathcal { V }$ for any example $x ^ { t } \in \mathcal { X }$ from any previously seen task $t \in \mathbb { T }$ . Our goal is to devise an algorithm which learns these tasks sequentially while avoiding catastrophic forgetting and can achieve a test loss close to that of a model which learnt all the tasks jointly.
34
+
35
+ # 3 DEEP GENERATIVE DUAL MEMORY NETWORK
36
+
37
+ The idea of replaying experience to a neural network has been used previously for reinforcement learning (Lin, 1993; Mnih et al., 2015). A study by O’Neill et al. (2010) suggests that experience replay also occurs in the human brain during sleep and waking rest and aids in consolidation of learnt experiences. We propose that experience replay must be generative in nature. This is better than storing all samples in replay memories as is common in reinforcement learning (Mnih et al., 2015), since sampling from a generative model automatically provides the most frequently encountered samples. It is also feasible with limited total memory, whereas explicitly storing samples from previous tasks requires determining which and how many samples to store for each task. Determining this can depend on the total tasks $\left| \mathbb { T } \right|$ , number of examples per task $N _ { t }$ and frequency of occurrence of samples, which are often not available a priori.
38
+
39
+ Previously proposed non-generative approaches to experience replay (Robins, 1995; French, 1997; Robins, 2004) propose to preserve neural networks’ learnt mappings by arbitrarily sampling random inputs and their corresponding outputs from the neural networks and using them along with new task samples while training. These approaches have only been tested in small binary input spaces in previous works, and our experiments in section 4 show that sampling random inputs in highdimensional spaces (e.g. images) does not preserve the mapping learnt by neural networks.
40
+
41
+ # 3.1 GENERATIVE EXPERIENCE REPLAY
42
+
43
+ ![](images/6170b28f0b9ad0e31d7cc1635be8649edabf848daa9d52ed8abbc48ead26cfa6.jpg)
44
+ Figure 1: Deep Generative Replay to train a Deep Generative Memory
45
+
46
+ Deep Generative Memory (DGM): We first introduce a sub-model called the Deep Generative Memory (see figure 1) which has three elements: (i) a generative model (the generator $G$ ), (ii) a feedforward network (the learner $L$ ), and (iii) a dictionary $( D _ { d g m } )$ with task IDs of learnt tasks and the number of times they were encountered. We call this a memory because of its weights and learning capacity, not due to any recurrent connections. We assume availability of unique task IDs for replay and to identify repetition. In practice, a task identification system (e.g., a HMM-based inference model) like in previous works (Kirkpatrick et al., 2017) suffices for this purpose. We choose variational autoencoder (VAE) (Kingma & Welling, 2014) for the generator, since our generative model requires reconstruction capabilities (see section 3.2).
47
+
48
+ Deep Generative Replay (DGR): We update a DGM with samples from (multiple) new tasks using our algorithm Deep Generative Replay (see figure 1 above and algorithm 1 in appendix A). Given new incoming samples $( X , Y )$ , DGR first computes the fraction of total samples that should come from incoming samples $( \eta _ { t a s k s } )$ and the fraction to come from previous task samples $( \eta _ { g e n } )$ proportionate to the number of tasks (counting repetitions). It allots a minimum fraction $\kappa$ of the memory capacity $N _ { m a x }$ per new task. This ensures that as the DGM saturates with tasks over time, new tasks are still learnt at the cost of gradually losing performance on the least recent previous tasks. This saturation is synonymous to how learning slows down in humans as they age but they still continue to learn new tasks while forgetting old things gradually (French, 1999). Next, DGR computes the number of samples to be generated from previous tasks and subsamples the incoming samples (if needed) to obey maximum memory capacity $( N _ { m a x } )$ . It then generates samples of previously learnt tasks $( X _ { g e n } , Y _ { g e n } )$ using the generator and learner, reconstructs the data $\{ X , X _ { g e n } \}$ using the generator (hence we use a VAE) and then trains the DGM on resulting samples $\scriptstyle ( X _ { r e c o n }$ , $\{ Y , Y _ { g e n } \} )$ . Doing this final reconstruction provides robustness to noise and occlusion (section 5).
49
+
50
+ # 3.2 DUAL MEMORY NETWORKS
51
+
52
+ A good continual learning system needs to quickly acquire new tasks and also retain performance on previously learnt tasks. These conflicting requirements are hard to satisfy simultaneously. Hence, inspired by nature’s solution to this problem, we propose a dual memory network to combat forgetting.
53
+
54
+ ![](images/81669f8d5703e75d381c36489d050107cda125a58c6375aa8cb5d5b7d89b3746.jpg)
55
+ Figure 2: Deep Generative Dual Memory Network (DGDMN)
56
+
57
+ Our architecture (DGDMN) shown in figure 2 comprises of a large deep generative memory (DGM) called the long-term memory (LTM) which stores information of all previously learnt tasks like the neocortex, and a short-term memory (STM) which behaves similar to the hippocampus and learns new incoming tasks quickly without interference from previous tasks. The STM is a collection of small, dedicated, task-specific deep generative memories (called short-term task memory – STTM), which can each learn one unique task. If an incoming task comes is already in an STTM, the same STTM is used to retrain on it, otherwise a fresh STTM is allocated to the task. Additionally, if the task has been previously consolidated then the LTM reconstructs the incoming samples for that task using the generator (hence we use a VAE), predicts labels for the reconstructions using its learner and sends these newly generated samples to the STTM allocated to this task. This provides extra samples on tasks which have been learnt previously and helps to learn them better, while also preserving the previous performance on that task to some extent.
58
+
59
+ Once all $\left( n _ { S T M } \right)$ STTMs are exhausted, the architecture sleeps (like humans) to consolidate all tasks into the LTM and free up the STTMs for new tasks. While asleep, the STM generates and sends samples of learnt tasks to the LTM, where these are consolidated via deep generative replay (see figure 2). While testing on task $t$ (even intermittently between tasks), if any STTM currently contains task $t$ , it is used to predict the labels, else the prediction is deferred to the LTM. This allows predicting on all tasks seen uptil now (including the most recent ones) without sleeping.
60
+
61
+ # 4 EXPERIMENTS
62
+
63
+ We perform experiments to demonstrate forgetting on sequential image classification tasks. We briefly describe our datasets here (details in appendix B): (a) Permnist is a catastrophic forgetting (Goodfellow et al., 2015; Kirkpatrick et al., 2017) benchmark and each task contains a fixed permutation of pixels on MNIST images (LeCun et al., 1998), (b) Digits dataset involves classifying a single MNIST digit per task, (c) TDigits is a transformed variant of MNIST similar to Digits but with 40 tasks for long task sequences, (d) Shapes contains several geometric shape classification tasks, and (e) Hindi contains a sequence of 8 tasks with hindi language consonant recognition.
64
+
65
+ Along with our model (DGDMN), we test several baselines for catastrophic forgetting, which are briefly described here (implementation and hyperparameter details in appendix B): (a) Feedforward neural networks (NN): We use these to characterize the forgetting in the absence of any prevention mechanism and as a datum for other approaches, (b) Neural nets with dropout (DropNN): Goodfellow et al. (2015) suggested using dropout as a means to prevent representational overlaps and pacify catastrophic forgetting, (c) Pseudopattern Rehearsal (PPR): A non-generative approach to experience replay (Robins, 2004), (d) Elastic Weight Consolidation (EWC): Kirkpatrick et al. (2017) proposed using the Fisher Information Matrix for task-specific consolidation of weights in a neural network, and (e) Deep Generative Replay (DGR): Using a single DGM to separate the effects of generative replay and dual memory architecture.
66
+
67
+ In our preliminary experiments, we observed that large networks with excessive parameters can more easily adapt to sequentially incoming tasks, thereby masking the severity of catastrophic forgetting. So we have chosen network architectures which have to share all their parameters appropriately amongst the various tasks in a dataset to achieve reasonable joint accuracy on the dataset. This allows us to evaluate an algorithm carefully while ignoring the benefits provided by excessive parameterization.
68
+
69
+ # 4.1 ACCURACY AND FORGETTING CURVES
70
+
71
+ ![](images/f90671a567428e4bdd15231af6701dd7dee23b3dc65ef2700483768a4983043a.jpg)
72
+ Figure 3: Accuracy curves for Permnist (x: tasks seen, y: classification accuracy on task).
73
+
74
+ We trained DGDMN and all above baselines sequentially on the image classification tasks of Permnist, Digits, Shapes and Hindi datasets (separately). We show results on the Shapes and Hindi dataset in appendix A. The classification accuracy on a held out test set for each task, after training on the $t ^ { t h }$ task has been shown in figures 3 and 4. We used the same network architecture for each of NN, PPR, EWC, learner in DGR, and learner in the LTM of DGDMN (for a single dataset). DropNN had two intermediate dropout layers after each hidden layer (see appendix B for details).
75
+
76
+ We observe from figures 3a and 3b, that NN and DropNN forget catastrophically when they learn new tasks. This shows that sparse representation based methods rely on the neural network being of high enough capacity to learn sparse representations (Goodfellow et al., 2015) and may not perform well if the network does not have redundant weights available. EWC forgets less than NN and DropNN, but it rapidly slows down learning on many weights and its learning effectively stagnates after Task 3 (e.g. see Tasks 5 and 6 in figure 3d). The learning slowdown on weights hinders EWC from reusing those weights later on to jointly discover common structures amongst previously learnt and newly incoming tasks. Note that the networks do have the capacity to learn all tasks and our algorithms DGR and DGDMN outperform all baselines by learning all tasks sequentially with this same learner network (figures 3e, 3f).
77
+
78
+ We observed heavy forgetting on Digits (figure 4) for most baselines, which is expected because all samples in the $t ^ { t h }$ task have a single label $\mathbf { \rho } ( t )$ and so the $t ^ { t h }$ task can be learnt on its own by setting the $\hat { t } ^ { t h }$ bias of the softmax layer to be high and the other biases low. Such sequential tasks cause catastrophic forgetting. We observed that NN, DropNN, PPR and EWC learnt only the task being trained on and forgot all previous knowledge immediately. Sometimes, we also observed saturation due to the softmax bias being set very high and then being unable to recover from it. PPR showed severe saturation since its replay prevented it from coming out of the saturation.
79
+
80
+ DGR and DGDMN still retain performance on all tasks of Digits, and our replay strategy prevents saturation by appropriately balancing the ratios of new incoming samples and generated samples from previous tasks. The average forgetting on all tasks $\in \{ 1 , \ldots , t \}$ , after training on the $t ^ { t h }$ task (for both Digits and Permnist) is shown in figure 5. For absolute reference, the accuracy of NN by training it jointly on all tasks uptil the $t ^ { t h }$ task has also been shown for each $t$ . Again DGR and DGDMN outperform baselines in terms of retained average accuracy. In figure 5b, NN, DropNN, PPR and EWC follow nearly overlapping curves $\begin{array} { r } { ( a c c \approx \frac { 1 } { t } } \end{array}$ ) since they are only able to learn one task at a time. Further, though PPR involves experience replay, it does not compare against DGR and
81
+
82
+ ![](images/18714c2ef10b46abede86490f2ee7f34c52a46f8fc88844d5515b77a16b2e69d.jpg)
83
+ Figure 4: Accuracy curves for Digits (x: tasks seen, y: classification accuracy on task).
84
+
85
+ ![](images/c51550482d517a0103f006376cf5c3ec3bae898c93b182b62c7ce37e79a7f42d.jpg)
86
+ Figure 5: Forgetting curves (x: tasks seen, y: avg classification accuracy on tasks seen).
87
+
88
+ DGDMN (figures 3c, 4c). Although, it does preserve its learnt mapping around the points randomly sampled from its domain, these random samples are not close to real images and fail to preserve performance. These observations substantiate our claim that any replay mechanism must model the input domain accurately and hence needs to be generative in nature. We observed similar results for the Shapes and Hindi dataset (appendix A).
89
+
90
+ We point out that datasets like Digits, which contain tasks with highly correlated input (and/or output) samples should be important benchmarks for continual learning for two main reasons: (i) High correlation amongst task samples promotes overfitting to the new incoming task and therefore causes catastrophic forgetting. Being able to retain performance on such task sequences is a strong indicator of the efficacy of a continual learning algorithm. (ii) Humans also learn by seeing many correlated samples together in a short span of time, rather than witnessing nearly IID samples (like in Permnist). For examples, kids learn a single alphabet per day in kindergarten by seeing and writing that alphabet many times that day. Since NN, DropNN and PPR do not fare well on such tasks, we show experiments on EWC, DGR and DGDMN from here on.
91
+
92
+ # 4.2 REPEATED TASKS AND REVISION
93
+
94
+ It is well known in psychology literature that human learning improves via revision (Kahana & Howard, 2005; Cepeda et al., 2006). We show performance of EWC and DGDMN on Permnist, when some tasks are repeated (figure 6). DGR performs very similar to DGDMN, hence we omit it. EWC stagnates and once learning has slowed down on the weights important for Task 1, the weights cannot be changed again, not even for improving Task 1. Further, it did not learn Task 6 the first time and revision does not help either. However, DGDMN learns all tasks uptil Task 6, then benefits by revising Task 1 again (accuracy goes up), and somewhat for Task 6 (it did not forget Task 6 substantially). We reiterate that DGDMN, by its design, benefits significantly from revision because STTMs learning a repeated task gain extra samples from the LTM (or generated samples from themselves, if they had learnt the task before). While many previous works do not investigate revision, it is crucial for learning continuously and should improve performance on tasks. The ability to learn from correlated task samples and revision makes our memory architecture functionally similar to that of humans.
95
+
96
+ ![](images/eae57c9c87ebd7c5affebc56623c475814c7bb1417300a3e17e7091d2aed7d27.jpg)
97
+ Figure 6: Accuracy curves when tasks are revised: (a) EWC, (b) DGDMN.
98
+
99
+ # 4.3 CONNECTIONS TO COMPLEMENTARY LEARNING SYSTEMS AND SLEEP
100
+
101
+ To explore the role of the dual memory architecture and differentiate between DGDMN and DGR, we trained these algorithms on the long sequence of 40 tasks from TDigits dataset. We limited $N _ { m a x }$ to 120, 000 samples for this task to explore the case where the LTM in DGDMN (DGM in DGR) cannot regenerate as many samples as in the full dataset and has to forget some tasks. At least $\kappa = 0 . 0 5$ fraction of memory was ensured per new task and consolidation in DGDMN happened after $n _ { S T M } = 5$ tasks.
102
+
103
+ ![](images/551b6c0ce39a768723325fa8dfec54d2c5ca847b4712a311f8e4fb3e4524d2f4.jpg)
104
+ Figure 7: Accuracy curves for TDigits on: (a) tasks seen so far, (b) last 10 tasks seen.
105
+
106
+ The average forgetting curves vs. tasks encountered are plotted in figure 7a. DGDMN and DGR start around an average accuracy of 1.0, but start dropping after 10 tasks since the LTM (DGM for DGR) begins to saturate. While DGDMN drops slowly and retains $> 4 0 \%$ accuracy on all tasks, DGR drops below $2 0 \%$ accuracy. This is because DGR consolidates its DGM too often and the DGM’s self-generated slightly erroneous samples compound errors quite fast. DGDMN uses small STTMs to learn single tasks with low error and transfers them simultaneously to the LTM. As a consequence, DGDMN consolidates its LTM with more accurate samples and less often, hence its error accumulates much slower. We discuss the effect of the small error in STTM representations in section 5.
107
+
108
+ Even though DGDMN displays inevitable forgetting in figure $\mathrm { 7 a }$ (due to memory constraint), the forgetting is gradual and not catastrophic as seen for NN, DropNN, PPR etc. on Digits dataset. We also measure average accuracy on the most recent few tasks seen (say 10). Figure 7b shows that DGDMN oscillates around $9 0 \%$ average accuracy, whereas DGR’s frequent consolidation propagates errors too fast and its accuracy drops even on this metric.
109
+
110
+ Another advantage of dual memories is revealed by the training time for the algorithms. Figure 9a shows an order of magnitude of difference between DGDMN and DGR in training time. This is because STTMs are smaller and faster to train than the LTM. LTM preserves all the tasks seen so far and hence requires a large number of samples to consolidate, which is costly and should not be done after every task. Learning new tasks quickly in the STM and holding them till sleep provides a speed advantage and allows learning quickly with only periodic consolidation.
111
+
112
+ The dual memory architecture is a critical design choice for scalability and has also emerged naturally in humans, in the form of the complementary learning systems and the need to sleep periodically. Even though sleeping is a dangerous behavior for any organism since it can be harmed or attacked by a predator while asleep, sleep has still survived through eons of evolution and never been lost (Joiner, 2016). Today, most organisms with even a slightly developed nervous system (centralized or diffuse) display either sleep or light-resting behavior (Nath et al., 2017). The experiment demonstrates the importance of sleep, since without the dual memory architecture intertwined with periodic sleep, learning would be very short lived and highly time consuming (as in DGR).
113
+
114
+ # 5 ANALYSIS AND DISCUSSION
115
+
116
+ In this section we show that DGDMN shares some more remarkable characteristics with the human memory and present a discussion of some more related ideas. Due to space constraints, visualizations of the learnt latent structures when training jointly vs. sequentially have been deferred to appendix A. The hyperparameters of DGDMN $\kappa$ and $n _ { S T M }$ ) have intuitive interpretations and we have provided simple heuristics to choose them without any complex searches (in appendix B).
117
+
118
+ Resilience to noise and occlusion: We use a VAE to be able to reconstruct representations of samples. Reconstructed images are less noisy and can recover from partial occlusion, which gives our model human-like abilities to recognize objects in noisy, distorted or occluded images. We test our LTM model and a NN model by jointly training on uncorrupted Digits data and testing on noisy and occluded images. We see that the LTM is more robust to noisy and occluded images and exhibits smoother degradation in classification accuracy because of its denoising reconstructive properties (see figure 8).
119
+
120
+ ![](images/b1a7b1d3587e4b7d8ba4199220da570ab89bff3e6745f2c708d9bca8f8c3211e.jpg)
121
+ Figure 8: (a) LTM reconstruction from noisy and occluded digits, (b) Classification accuracy with increasing gaussian noise, and (c) Classification accuracy with increasing occlusion factor.
122
+
123
+ The choice of underlying generative model: Our consolidation ability and retention performance relies heavily on the generation and reconstruction ability of the underlying generative model. We chose a VAE for its reconstructive capabilities but our architecture is agnostic to the choice of the underlying generative model as long as the generator can generate reliable samples and reconstruct incoming samples accurately. Hence, variants of Generative Adversarial Networks (GAN) Goodfellow et al. (2014) like BiGANs (Donahue et al., 2017), ALI (Dumoulin et al., 2017) and AVB (Mescheder et al., 2017) can also be used for the generative model depending on the modeled domain.
124
+
125
+ ![](images/9158c81af36b3949c6e51f753ee820453a27c854b40008e26b8f5668e9eedb3e.jpg)
126
+ Figure 9: (a) Training time for DGDMN and DGR, (b) Accuracy curves: DGDMN (no STM).
127
+
128
+ Why use short-term memory?: Our LTM always learns from STTMs and never from real data, and the STTMs’ errors slowly propagate into the LTM and contribute to forgetting. An alternative could be to directly store data from new incoming tasks, consolidate it into the LTM after periodic intervals, and then discard the data. We show the accuracy curves on Digits dataset for this approach in figure 9b. This results in higher retention compared to DGDMN in figure 4 because LTM now learns from real data. However, this approach is not truly online since recently learnt tasks cannot be used immediately until after a sleep phase. Since the STM’s error can be made smaller by using high capacity generators and classifiers, we suggest using a STM for true online continual learning.
129
+
130
+ Connections to knowledge distillation: Previous works on (joint) multitask learning have also proposed approaches to learn individual tasks with small networks and then “distilling” them jointly into a larger neural network (Rusu et al., 2015). Such distillation can sometimes improve performance on individual tasks if they share structure and at other times mitigate inter-task interference due to refinement of learnt functions while distilling (Parisotto et al., 2016). Though we do not use temperature-controlled soft-labels while consolidating tasks into the LTM (unlike distillation), we surmise that due to refinement and compression during consolidation phase, DGDMN is also able to learn joint task structure effectively while mitigating interference between tasks.
131
+
132
+ Approaches based on synaptic consolidation: Though our architecture draws inspiration from complementary learning systems and experience replay in the human brain, there is also considerable neuroscientific evidence for synaptic consolidation in the human brain (like in EWC). It might be interesting to explore how synaptic consolidation can be incorporated in our dual memory architecture without causing stagnation and we leave this to future work. We also plan to extend our architecture to learning optimal policies over time via reinforcement learning without explicit replay memories.
133
+
134
+ # 6 CONCLUSION
135
+
136
+ In this work, we have developed a model capable of learning continuously on sequentially incoming tasks, while averting catastrophic forgetting. Our model employs a dual memory architecture to emulate the complementary learning systems (hippocampus and the neocortex) in the human brain and maintains a consolidated long-term memory via generative replay of past experiences. We have shown that generative replay performs the best for long-term performance retention even for neural networks with small capacity, while demonstrating the benefits of using generative replay and a dual memory architecture via our experiments. Our model hyperparameters have simple interpretations and can be set without much tuning. Moreover, our architecture displays remarkable parallels with the human memory system and provides useful insights about the connection between sleep and learning in humans.
137
+
138
+ # REFERENCES
139
+
140
+ Marcus K Benna and Stefano Fusi. Computational principles of synaptic memory consolidation. Nature neuroscience, 2016.
141
+
142
+ Nicholas J Cepeda, Harold Pashler, Edward Vul, John T Wixted, and Doug Rohrer. Distributed practice in verbal recall tasks: A review and quantitative synthesis. Psychological bulletin, 132(3): 354, 2006.
143
+
144
+ Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. In International Conference on Learning Representations (ICLR), 2017.
145
+
146
+ Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. In International Conference on Learning Representations (ICLR), 2017.
147
+
148
+ Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. arXiv preprint arXiv:1701.08734, 2017.
149
+
150
+ Robert M French. Dynamically constraining connectionist networks to produce distributed, orthogonal representations to reduce catastrophic interference. network, 1111:00001, 1994.
151
+
152
+ Robert M French. Pseudo-recurrent connectionist networks: An approach to the’sensitivitystability’dilemma. Connection Science, 9(4):353–380, 1997.
153
+
154
+ Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3 (4):128–135, 1999.
155
+
156
+ Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Neural Information Processing Systems (NIPS), pp. 2672–2680, 2014.
157
+
158
+ Ian J Goodfellow, Mehdi Mirza, Da Xiao, Aaron Courville, and Yoshua Bengio. An empirical investigation of catastrophic forgetting in gradient-based neural networks. arXiv preprint arXiv:1312.6211, 2015.
159
+
160
+ Google. The quick, draw! dataset. URL: https://github.com/googlecreativelab/quickdraw-dataset, 2017.
161
+
162
+ Geoffrey Hinton. Neural networks for machine learning - lecture 6a - overview of mini-batch gradient descent, 2012.
163
+
164
+ William J Joiner. Unraveling the evolutionary determinants of sleep. Current Biology, 26(20): R1073–R1087, 2016.
165
+
166
+ Kaggle. Devanagari character set. URL: https://www.kaggle.com/rishianand/devanagari-character-set, 2017.
167
+
168
+ Michael J Kahana and Marc W Howard. Spacing and lag effects in free recall of pure lists. Psychonomic Bulletin & Review, 12(1):159–164, 2005.
169
+
170
+ D. P. Kingma and M. Welling. Auto-encoding variational bayes. In International Conference on Learning Representations (ICLR), 2014.
171
+
172
+ James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, pp. 201611835, 2017.
173
+
174
+ Chris A Kortge. Episodic memory in connectionist networks. In Proceedings of the 12th Annual Conference of the Cognitive Science Society, volume 764, pp. 771. Erlbaum, 1990.
175
+
176
+ Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
177
+
178
+ Stephan Lewandowsky. Gradual unlearning and catastrophic interference: A comparison of distributed architectures. Relating theory and data: Essays on human memory in honor of Bennet B. Murdock, pp. 445–476, 1991.
179
+
180
+ Long-Ji Lin. Reinforcement learning for robots using neural networks. PhD thesis, Fujitsu Laboratories Ltd, 1993.
181
+
182
+ Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
183
+
184
+ James L McClelland, Bruce L McNaughton, and Randall C O’reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory. Psychological review, 102(3):419, 1995.
185
+
186
+ Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of learning and motivation, 24:109–165, 1989.
187
+
188
+ Ken McRae and Phil A Hetherington. Catastrophic interference is eliminated in pretrained networks. In Proceedings of the 15h Annual Conference of the Cognitive Science Society, pp. 723–728, 1993.
189
+
190
+ Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017.
191
+
192
+ Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
193
+
194
+ Decebal Constantin Mocanu, Maria Torres Vega, Eric Eaton, Peter Stone, and Antonio Liotta. Online contrastive divergence with generative replay: Experience replay without storing data. CoRR, abs/1610.05555, 2016.
195
+
196
+ Ravi D Nath, Claire N Bedbrook, Michael J Abrams, Ty Basinger, Justin S Bois, David A Prober, Paul W Sternberg, Viviana Gradinaru, and Lea Goentoro. The jellyfish cassiopea exhibits a sleep-like state. Current Biology, 27(19):2984–2990, 2017.
197
+
198
+ Joseph O’Neill, Barty Pleydell-Bouverie, David Dupret, and Jozsef Csicsvari. Play it again: reactivation of waking experience and memory. Trends in neurosciences, 33(5):220–229, 2010.
199
+
200
+ Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In International Conference on Learning Representations (ICLR), 2016.
201
+
202
+ Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Connection Science, 7(2): 123–146, 1995.
203
+
204
+ Anthony Robins. Sequential learning in neural networks: A review and a discussion of pseudorehearsal based methods. Intelligent Data Analysis, 8(3):301–322, 2004.
205
+
206
+ Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015.
207
+
208
+ Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.
209
+
210
+ Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Neural Information Processing Systems (NIPS), 2017.
211
+
212
+ Rupesh K Srivastava, Jonathan Masci, Sohrob Kazerounian, Faustino Gomez, and Jürgen Schmidhuber. Compete to compute. In Neural Information Processing Systems (NIPS), pp. 2310–2318, 2013.
213
+
214
+ Guang Yang, Cora Sau Wan Lai, Joseph Cichon, Lei Ma, Wei Li, and Wen-Biao Gan. Sleep promotes branch-specific formation of dendritic spines after learning. Science, 344(6188):1173–1178, 2014.
215
+
216
+ # 7 APPENDIX A
217
+
218
+ 7.1 DEEP GENERATIVE REPLAY
219
+
220
+ # Algorithm 1: Deep Generative Replay
221
+
222
+ 1: Input: Current parameters of DGM, new samples: $( X , Y )$ , dictionary for new samples: $D _ { t a s k s }$ (there can be multiple tasks), minimum fraction: $\kappa$ , memory capacity: $N _ { m a x }$
223
+ 2: Output: New parameters of DGM // Compute sampling fractions
224
+ 3: ηtasks := P tasksDdgm+P Dtasks and $\eta _ { g e n } : = 1 - \eta _ { t a s k s }$
225
+ 4: if $\eta _ { t a s k s } < \kappa | D _ { t a s k s } |$ then
226
+ 5: $\eta _ { t a s k s } : = \kappa | D _ { t a s k s } |$ and $\eta _ { g e n } : = 1 - \eta _ { t a s k s }$
227
+ 6: end if // Compute number of samples
228
+ 7: if $| X | > \eta _ { t a s k s } \times N _ { m a x }$ then
229
+ 8: $n _ { t a s k s } : = \eta _ { t a s k s } \times N _ { m a x }$ and $n _ { g e n } : = N _ { m a x } - n _ { t a s k s }$
230
+ 9: Subsample $( X , Y )$ to meet size $n _ { t a s k s }$
231
+ 10: else
232
+ 11: $n _ { t a s k s } : = | X |$ and $\begin{array} { r } { n _ { g e n } : = \frac { \eta _ { g e n } } { \eta _ { t a s k s } } \times | \boldsymbol { X } | } \end{array}$
233
+ 12 : end if // Generate and reconstruct samples
234
+ 13: Generate $n _ { g e n }$ samples: $X _ { g e n }$ from generator $G$ and labels from learner $L$ : $Y _ { g e n } = L ( X _ { g e n } )$
235
+ 14: $X _ { r e c o n } = \mathrm { R }$ econstruct $\{ X , \bar { X } _ { g e n } \}$ using the generator $G$ // Train the DGM
236
+ 15: Train the generator $G$ on $X _ { r e c o n }$
237
+ 16: Train the learner $L$ on $( X _ { r e c o n } , \{ Y , Y _ { g e n } \} )$
238
+
239
+ Deep Generative Replay (algorithm 1), as described in section 3.1, consolidates new tasks for a DGM with previously learnt tasks. It first computes sampling fractions for new tasks $( \eta _ { t a s k s } )$ and previously learnt tasks $( \eta _ { g e n } )$ and ensures a minimum fraction $\left( \kappa \right)$ per new task (lines 3–6). Then it computes the number of samples to generate from previous tasks and whether to subsample the incoming task samples to satisfy the memory capacity $N _ { m a x }$ (lines 7–12). Finally, it generates the required number of samples from previous tasks, reconstructs all data and trains the DGM on resulting data (lines 13–16). For a dictionary $D , \sum D$ is the total number of tasks in $D$ counting repetitions, while $| D |$ is the total number of tasks without repetitions. $| X |$ is the number of samples in set $X$ .
240
+
241
+ Shin et al. (2017) have recently proposed a similar idea independently and Mocanu et al. (2016) have also employed a generative replay in two-layer restricted boltzmann machines, but they do not describe balancing new and generated samples and cannot recognize repeated tasks (section 4.2). Their generative replay without a dual memory architecture is costly to train (section 4.3) and a lack of reconstruction for new samples makes their representations less robust to noise and occlusions (section 5).
242
+
243
+ # .2 MORE EXPERIMENTS WITH ACCURACY AND FORGETTING CURVES
244
+
245
+ In this section, we present more experiments on the Shapes and the Hindi dataset, which contain sequences of tasks with geometric shapes and hindi consonants recognition respectively. We observed similar forgetting patterns as on the Digits dataset in section 4. All baselines exhibited catastrophic forgetting on these sequences of tasks, but DGR and DGDMN were able to learn the task structure sequentially (figures 10, 11). The same is reflected in the average forgetting curves in figure 12.
246
+
247
+ # 7.3 JOINTLY VS. SEQUENTIALLY LEARNT STRUCTURE
248
+
249
+ To explore whether learning tasks sequentially results in a similar structure as learning them jointly, we visualized t-SNE (Maaten & Hinton, 2008) embeddings of the latent vectors of the LTM generator (VAE) in DGDMN after training it: (a) jointly over all tasks (Figure 13a), and (b) sequentially over tasks seen one at a time (Figure 13b) on the Digits dataset. To maintain consistency, we used the same random seed in t-SNE for both joint and sequential embeddings.
250
+
251
+ ![](images/05b4bab32d0b9e68553bda5e373e69654589fb514fc51d925f2d5818d6e2ca9a.jpg)
252
+ Figure 10: Accuracy curves for Shapes (x: tasks seen, y: classification accuracy on task).
253
+
254
+ ![](images/b51f69223903dc4952bd19665dde326e9ed7cba7903da592f2e9073496931e4f.jpg)
255
+ Figure 11: Accuracy curves for Hindi (x: tasks seen, y: classification accuracy on task).
256
+
257
+ We observe that the LTM’s latent space effectively segregates the 10 digits in both cases (joint and sequential). Though the absolute locations of the digit clusters differ in the two plots, the relative locations of digits share some similarity between both plots i.e. the neighboring digit clusters for each cluster are roughly similar. This may not be sufficient to conclude that the LTM discovers the same latent representation for the underlying shared structure of tasks in these cases and we leave a more thorough investigation to future work.
258
+
259
+ # 7.4 VISUALIZATIONS FOR THE JOINTLY AND SEQUENTIALLY LEARNT LTM
260
+
261
+ We also show visualizations of digits from the LTM when trained jointly on Digits tasks (Figure 14a) and when trained sequentially (Figure 14b). Though the digits generated from the jointly trained LTM are quite sharp, the same is not true for the sequentially trained LTM. We observe that the
262
+
263
+ ![](images/e79a088951e726503a561fe4995d32d1972ad7a91f519bbfe083393efc4407a4.jpg)
264
+ Figure 12: Forgetting curves on Shapes and Hindi dataset (x: tasks seen, y: avg classification accuracy on tasks seen).
265
+
266
+ ![](images/b346b7c891174d1856f608b81586a975de69cf624acbc77171f782633274087d.jpg)
267
+ Figure 13: t-SNE embedding for latent vectors of the VAE generator on Digits dataset when: (a) tasks are learnt jointly, and (b) tasks are learnt sequentially.
268
+
269
+ sequentially trained LTM produces sharp samples of the recently learnt tasks (digits 6, 7, 8 and 9), but blurred samples of previously learnt tasks, which is due to partial forgetting on these previous tasks.
270
+
271
+ ![](images/a1824bc3921b759388c7ee5826f4e401c4ef0a1b98d34fba3c8635d2c1683845.jpg)
272
+ Figure 14: Visualization of digits from LTM when trained: (a) jointly, (b) sequentially
273
+
274
+ # 8 APPENDIX B
275
+
276
+ # 8.1 DATASET PREPROCESSING
277
+
278
+ All our datasets have images with intensities normalized in the range [0.0, 1.0] and size $( 2 8 \times 2 8 )$ , except Hindi which has $( 3 2 \times 3 2 )$ size images.
279
+
280
+ Permnist: Our version involved six tasks, each containing a fixed permutation on images sampled from the original MNIST dataset. We sampled 30, 000 images from the training set and all the 10, 000 test set images for each task. The tasks were as follows: (i) Original MNIST, (ii) 8x8 central patch of each image blackened, (iii) 8x8 central patch of each image whitened, (iv) 8x8 central patch of each image permuted with a fixed random permutation, (v) 12x12 central patch of each image permuted with a fixed random permutation, and (vi) mirror images of MNIST. This way each task is as hard as MNIST and the tasks share some common underlying structure.
281
+
282
+ Digits: We introduce this smaller dataset which contains 10 tasks with the $t ^ { t h }$ task being classification of digit $t$ from the MNIST dataset.
283
+
284
+ TDigits: We introduced a transformed variant of MNIST containing all ten digits, their mirror images, their upside down images, and their images when reflected about the main diagonal making a total of 40 tasks. This dataset poses similar difficulty as the Digits dataset and we use it for experiments involving longer sequence of tasks.
285
+
286
+ Shapes: This dataset was extracted from the Quick, Draw! dataset recently released by Google (2017), which contains 50 million drawings across 345 categories of hand-drawn images. We subsampled 4, 500 training images and 500 test images from all geometric shapes in Quick, Draw! (namely circle, hexagon, octagon, square, triangle and zigzag).
287
+
288
+ Hindi: Extracted from the Devanagri dataset (Kaggle, 2017) and contains a sequence of 8 tasks, each involving image classification of a hindi language consonant.
289
+
290
+ # 8.2 TRAINING ALGORITHM AND ITS PARAMETERS
291
+
292
+ All models were trained with RMSProp (Hinton, 2012) using learning rate $= \ 0 . 0 0 1$ , $\rho = 0 . 9$ , $\epsilon = 1 0 ^ { - 8 }$ and no decay. We used a batch size of 128 and all classifiers were provided 20 epochs of training when trained jointly, and 6 epochs when trained sequentially over tasks. For generative models (VAEs), we used gradient clipping in RMSProp with $\mathtt { c l i p n o r m = 1 . 0 }$ and clipvalue $=$ 0.5, and they were always trained for 25 epochs regardless of the task or dataset involved.
293
+
294
+ # 8.3 NEURAL NETWORK ARCHITECTURES
295
+
296
+ We chose all our models by first training them jointly on all tasks in a dataset to ensure that our models had enough capacity to perform reasonably well on all tasks. But we gave preference to simpler models over very high capacity models.
297
+
298
+ Classifier Models: Our implementation of NN, DropNN, PPR, EWC, learner for DGR and the learner for LTM in DGDMN used a neural network with three fully-connected layers with the number of units tuned differently according to the dataset (24, 24 units for Digits, 48, 48 for Permnist and 36, 36 for TDigits). DropNN also added two dropout layers, one after each hidden layer with droput rate $= 0 . 2$ each. The classifiers (learners) for Shapes and Hindi datasets had two convolutional layers (1 $2 , 2 0 : 3 \times 3$ kernels for Shapes and 2 $4 , 3 2 : 3 \times 3$ kernels for Hindi) each followed by a $2 \times 2$ max-pooling layer. The last two layers were fully-connected (16, 6 for Shapes and 144, 36 for Hindi). The hidden layers used ReLU activations, the last layer had a softmax activation, and the model was trained to minimize the cross-entropy objective function. The learners for STTMs in DGDMN were kept smaller for speed and efficiency concerns.
299
+
300
+ Generative models: The generators (VAE) for DGR and LTM of DGDMN employed encoders and decoders with two fully connected hidden layers each with ReLU activation for Permnist, Digits and TDigits, and convolutional variants for Shapes and Hindi. The sizes and number of units/kernels in the layers were tuned independently for each dataset with an approximate coarse grid-search. The size of the latent variable $z$ was set to 32 for Digits, 64 for Permnist, 96 for TDigits, 32 for Shapes and 48 for Hindi. The STTM generators for DGDMN were kept smaller for speed and efficiency.
301
+
302
+ # 8.4 HYPERPARAMETERS OF DGDMN
303
+
304
+ DGDMN has two new hyperparameters: (i) $\kappa$ : minimum fraction of $N _ { m a x }$ reserved for incoming tasks, and (ii) $n _ { S T M }$ : number of STTMs (also sleep/consolidation frequency). Both these have straightforward interpretations and can be set directly without complex hyperparameter searches.
305
+
306
+ $\kappa$ ensures continual incorporation of new tasks by guaranteeing them a minimum fraction of LTM samples during consolidation. Given that LTM should perform well on last $K$ tasks seen in long
307
+
308
+ task sequence of $T$ tasks, we observed that it is safe to assume that about $5 0 \%$ of the LTM would be
309
+ crowded by the earlier $T - K$ tasks. The remaining 0.5 fraction should be distributed to the last $K$
310
+ tasks. So choosing this choice in secti $\textstyle \kappa = { \frac { 0 . 5 } { K } }$ woith in pand as a good starting point for tuning). We made, and hence plotted the average accuracy over $K = 1 0$ $\kappa = 0 . 0 5$
311
+ the last 10 tasks as a metric.
312
+
313
+ $n _ { S T M }$ controls the consolidation cycle frequency. Increasing $n _ { S T M }$ gives more STTMs, less frequent consolidations and hence a learning speed advantage. But this also means that fewer samples of previous tasks would participate in consolidation (due to maximum capacity $N _ { m a x }$ of LTM), and hence more forgetting might occur. This parameter does not affect learning much till the LTM remains unsaturated (i.e. $N _ { m a x }$ capacity is unfilled by generated $^ +$ new samples) and becomes active after that. For long sequences of tasks, we found it best to keep at least $7 5 \%$ of the total samples from previously learnt tasks to have appropriate retention. Hence, $n _ { S T M }$ can be set as approximately $\frac { 0 . 2 5 } { \kappa }$ in practice (as we did in section 4.3), or as a starting point for tuning.
314
+
315
+ # 8.5 ALGORITHM SPECIFIC HYPERPARAMETERS
316
+
317
+ PPR: We used a maximum memory capacity of about $3 - 6$ times the number of samples in a task for the dataset being learnt on (i.e. 18, 000 for Digits, 60, 000 for Permnist, 15, 000 for Shapes and 5, 400 for Hindi). While replaying, apart from the task samples, the remaining memory was filled with random samples and corresponding labels.
318
+
319
+ EWC: Most values of the coefficient of the Fisher Information Matrix based regularizer between 1 to 500 worked reasonably well for our datasets. We chose 100 for our experiments.
320
+
321
+ DGR and DGDMN: $N _ { m a x }$ for the DGM in DGR and for the LTM in DGDMN for Digits, Permnist, Shapes and Hindi was set as the total number of samples in the datasets (summed over all tasks) to ensure that there was enough capacity to regenerate the datasets well. For TDigits, we deliberately restricted memory capacity to see the effects of learning tasks over a long time and we kept $N _ { m a x }$ as half the total number of samples. $n _ { S T M }$ was kept at 2 for Digits, Permnist and Shapes, 5 for TDigits and 2 for Hindi. $\kappa$ was set to be small, so that it does not come into play for Digits, Permnist, Shapes and Hindi since we already provided memories with full capacity for all samples. For TDigits, we used $\kappa = 0 . 0 5$ which would let us incorporate roughly 10 out of the 40 tasks well.
parse/train/BkVsWbbAW/BkVsWbbAW_content_list.json ADDED
@@ -0,0 +1,1744 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ [
2
+ {
3
+ "type": "text",
4
+ "text": "DEEP GENERATIVE DUAL MEMORY NETWORK FOR CONTINUAL LEARNING ",
5
+ "text_level": 1,
6
+ "bbox": [
7
+ 189,
8
+ 112,
9
+ 808,
10
+ 160
11
+ ],
12
+ "page_idx": 0
13
+ },
14
+ {
15
+ "type": "text",
16
+ "text": "Anonymous authors Paper under double-blind review ",
17
+ "bbox": [
18
+ 183,
19
+ 184,
20
+ 398,
21
+ 212
22
+ ],
23
+ "page_idx": 0
24
+ },
25
+ {
26
+ "type": "text",
27
+ "text": "ABSTRACT ",
28
+ "text_level": 1,
29
+ "bbox": [
30
+ 454,
31
+ 250,
32
+ 544,
33
+ 263
34
+ ],
35
+ "page_idx": 0
36
+ },
37
+ {
38
+ "type": "text",
39
+ "text": "Despite advances in deep learning, artificial neural networks do not learn the same way as humans do. Today, neural networks can learn multiple tasks when trained on them jointly, but cannot maintain performance on learnt tasks when tasks are presented one at a time – this phenomenon called catastrophic forgetting is a fundamental challenge to overcome before neural networks can learn continually from incoming data. In this work, we derive inspiration from human memory to develop an architecture capable of learning continuously from sequentially incoming tasks, while averting catastrophic forgetting. Specifically, our model consists of a dual memory architecture to emulate the complementary learning systems (hippocampus and the neocortex) in the human brain and maintains a consolidated long-term memory via generative replay of past experiences. We (i) substantiate our claim that replay should be generative, (ii) show the benefits of generative replay and dual memory via experiments, and (iii) demonstrate improved performance retention even for small models with low capacity. Our architecture displays many important characteristics of the human memory and provides insights on the connection between sleep and learning in humans. ",
40
+ "bbox": [
41
+ 233,
42
+ 279,
43
+ 764,
44
+ 500
45
+ ],
46
+ "page_idx": 0
47
+ },
48
+ {
49
+ "type": "text",
50
+ "text": "1 INTRODUCTION ",
51
+ "text_level": 1,
52
+ "bbox": [
53
+ 176,
54
+ 523,
55
+ 336,
56
+ 540
57
+ ],
58
+ "page_idx": 0
59
+ },
60
+ {
61
+ "type": "text",
62
+ "text": "Many machine learning models, when trained sequentially on tasks, forget how to perform the previously learnt tasks. This phenomenon called catastrophic forgetting is prominent in neural networks (McCloskey & Cohen, 1989). Without a way to avert catastrophic forgetting, a learning system needs to store all training data and relearn on it along with new incoming data, when retraining. Hence, it is an important challenge to overcome in order to enable systems to learn continuously. ",
63
+ "bbox": [
64
+ 174,
65
+ 554,
66
+ 825,
67
+ 625
68
+ ],
69
+ "page_idx": 0
70
+ },
71
+ {
72
+ "type": "text",
73
+ "text": "McCloskey & Cohen (1989) first suggested that the underlying cause of forgetting was the distributed shared representation of tasks via network weights. Subsequent works attempted to remedy the issue by reducing representational overlap between input representations via activation sharpening algorithms (Kortge, 1990), orthogonal recoding of inputs (Lewandowsky, 1991) or orthogonal activations at all hidden layers (McRae & Hetherington, 1993; French, 1994). More recent works have explored activations like dropout (Goodfellow et al., 2015) and local winner-takes-all (Srivastava et al., 2013) to create sparse, less correlated feature representations. But such sparse encodings can be task specific at times and in general act as heuristics to mildly pacify the underlying problem. ",
74
+ "bbox": [
75
+ 174,
76
+ 631,
77
+ 825,
78
+ 742
79
+ ],
80
+ "page_idx": 0
81
+ },
82
+ {
83
+ "type": "text",
84
+ "text": "Further, natural cognitive systems are also connectionist in nature and yet they forget gradually but not ‘catastrophically’. For instance, humans demonstrate gradual systematic forgetting. Frequently and recently encountered tasks tend to survive much longer in the human memory, while those rarely encountered are slowly forgotten. Some of the earlier tasks may be seen again, but it is not necessary for them to be retained in memory (French, 1999). Hence only sparsifying representations does not solve the problem. Instead, neuroscientific evidence suggests that humans have evolved mechanisms to separately learn new incoming tasks and consolidate the learning with previous knowledge to avert catastrophic forgetting (McClelland et al., 1995; O’Neill et al., 2010; French, 1999). ",
85
+ "bbox": [
86
+ 174,
87
+ 750,
88
+ 825,
89
+ 861
90
+ ],
91
+ "page_idx": 0
92
+ },
93
+ {
94
+ "type": "text",
95
+ "text": "Complementary learning systems: McClelland et al. (1995) suggested that this separation has been achieved in the human brain via evolution of two separate areas of the brain, the hippocampus and the neocortex. The neocortex is a long term memory which specializes in consolidating new information with previous knowledge and gradually learns the joint structure of all tasks and experiences; whereas the hippocampus acts as a temporary memory to rapidly learn new tasks and then slowly transfer the knowledge to neocortex after acquisition. ",
96
+ "bbox": [
97
+ 174,
98
+ 867,
99
+ 823,
100
+ 924
101
+ ],
102
+ "page_idx": 0
103
+ },
104
+ {
105
+ "type": "text",
106
+ "text": "",
107
+ "bbox": [
108
+ 173,
109
+ 103,
110
+ 823,
111
+ 132
112
+ ],
113
+ "page_idx": 1
114
+ },
115
+ {
116
+ "type": "text",
117
+ "text": "Experience replay: Another factor deemed essential for sequential learning is experience replay. McClelland et al. (1995); O’Neill et al. (2010) have emphasized the importance of replayed data patterns in the human brain during sleep and waking rest. Robins (1995; 2004) proposed several replay techniques (a.k.a. pseudopattern rehearsal) to achieve replay, but they involved generating replay data without storing input representations and our experiments show that they lack the accuracy required for consolidation. ",
118
+ "bbox": [
119
+ 174,
120
+ 138,
121
+ 825,
122
+ 222
123
+ ],
124
+ "page_idx": 1
125
+ },
126
+ {
127
+ "type": "text",
128
+ "text": "Weight consolidation or freezing: Recent evidence from neuroscience also suggests that mammalian brain protects knowledge in the neocortex via task-specific consolidation of neural synapses over long periods of time (Yang et al., 2014; Benna & Fusi, 2016). Such techniques have recently been employed in progressive neural networks (Rusu et al., 2016) and Pathnets (Fernando et al., 2017) both of which freeze neural network weights after learning tasks. Kirkpatrick et al. (2017) have used the fisher information matrix (FIM) to slow down learning on network weights which correlate with previously acquired knowledge. ",
129
+ "bbox": [
130
+ 173,
131
+ 229,
132
+ 825,
133
+ 327
134
+ ],
135
+ "page_idx": 1
136
+ },
137
+ {
138
+ "type": "text",
139
+ "text": "In this paper, we address the catastrophic forgetting problem by drawing inspiration from the above neuroscientific insights and present a method to overcome catastrophic forgetting. More specifically, we propose a dual-memory architecture for learning tasks sequentially while averting catastrophic forgetting. Our model comprises of two generative models: a short-term memory (STM) to emulate the human hippocampal system and a long term memory (LTM) to emulate the neocortical learning system. The STM learns new tasks without interfering with previously learnt tasks in the LTM. The LTM stores all previously learnt tasks and aids the STM in learning tasks similar to previous tasks. During sleep/down-time, the STM generates and transfers samples of learnt tasks to the LTM. These are gradually consolidated with the LTM’s knowledge base of previous tasks via generative replay. ",
140
+ "bbox": [
141
+ 174,
142
+ 333,
143
+ 825,
144
+ 459
145
+ ],
146
+ "page_idx": 1
147
+ },
148
+ {
149
+ "type": "text",
150
+ "text": "Our approach is inspired from the strengths of deep generative models, experience replay and the complementary learning systems literature. We demonstrate our method’s effectiveness in averting catastrophic forgetting by sequentially learning multiple tasks. Moreover, our experiments shed light on some characteristics of human memory as observed in the psychology and neuroscience literature. ",
151
+ "bbox": [
152
+ 174,
153
+ 465,
154
+ 825,
155
+ 522
156
+ ],
157
+ "page_idx": 1
158
+ },
159
+ {
160
+ "type": "text",
161
+ "text": "2 PROBLEM SETTING: SEQUENTIAL MULTITASK LEARNING ",
162
+ "text_level": 1,
163
+ "bbox": [
164
+ 176,
165
+ 541,
166
+ 686,
167
+ 558
168
+ ],
169
+ "page_idx": 1
170
+ },
171
+ {
172
+ "type": "text",
173
+ "text": "Formally, our problem setting can be called Sequential Multitask Learning and is characterized by a set of tasks $\\mathbb { T }$ , which are to be learnt by a model parameterized by weights $\\theta$ (e.g. a neural network). From here on, we will use the the phrase model and neural network interchangeably. In this work we mainly consider supervised learning tasks i.e. task $t \\in \\mathbb { T }$ has training examples: $\\{ x _ { i } ^ { t } , y _ { i } ^ { t } \\} _ { i = 1 : N _ { t } }$ for $x _ { i } ^ { t } \\in \\mathcal X$ and $y _ { i } ^ { t } \\in \\bar { \\mathcal { V } }$ , but our model easily generalizes to unsupervised learning settings. Note that tasks are presented sequentially and the total number of tasks $\\lvert \\mathbb { T } \\rvert$ is not known a priori. ",
174
+ "bbox": [
175
+ 174,
176
+ 571,
177
+ 825,
178
+ 655
179
+ ],
180
+ "page_idx": 1
181
+ },
182
+ {
183
+ "type": "text",
184
+ "text": "Finite memory: We further assume that any training algorithm can store some examples from each task if needed, but the storage $( N _ { m a x } )$ is limited and can be smaller than the total number of examples from all tasks $\\left( \\sum _ { t = 1 } ^ { | \\mathbb { T } | } N _ { t } \\right)$ . So, algorithms cannot store all training examples and re-learn on them when new tasks arrive. The same restriction applies to algorithms with generative models i.e. no more than $N _ { m a x }$ examples allowed at any time (generated $^ +$ stored). ",
185
+ "bbox": [
186
+ 174,
187
+ 662,
188
+ 825,
189
+ 741
190
+ ],
191
+ "page_idx": 1
192
+ },
193
+ {
194
+ "type": "text",
195
+ "text": "For testing, the model can be asked to predict the label $y ^ { t } \\in \\mathcal { V }$ for any example $x ^ { t } \\in \\mathcal { X }$ from any previously seen task $t \\in \\mathbb { T }$ . Our goal is to devise an algorithm which learns these tasks sequentially while avoiding catastrophic forgetting and can achieve a test loss close to that of a model which learnt all the tasks jointly. ",
196
+ "bbox": [
197
+ 174,
198
+ 747,
199
+ 825,
200
+ 804
201
+ ],
202
+ "page_idx": 1
203
+ },
204
+ {
205
+ "type": "text",
206
+ "text": "3 DEEP GENERATIVE DUAL MEMORY NETWORK ",
207
+ "text_level": 1,
208
+ "bbox": [
209
+ 174,
210
+ 823,
211
+ 598,
212
+ 839
213
+ ],
214
+ "page_idx": 1
215
+ },
216
+ {
217
+ "type": "text",
218
+ "text": "The idea of replaying experience to a neural network has been used previously for reinforcement learning (Lin, 1993; Mnih et al., 2015). A study by O’Neill et al. (2010) suggests that experience replay also occurs in the human brain during sleep and waking rest and aids in consolidation of learnt experiences. We propose that experience replay must be generative in nature. This is better than storing all samples in replay memories as is common in reinforcement learning (Mnih et al., 2015), since sampling from a generative model automatically provides the most frequently encountered samples. It is also feasible with limited total memory, whereas explicitly storing samples from previous tasks requires determining which and how many samples to store for each task. Determining this can depend on the total tasks $\\left| \\mathbb { T } \\right|$ , number of examples per task $N _ { t }$ and frequency of occurrence of samples, which are often not available a priori. ",
219
+ "bbox": [
220
+ 174,
221
+ 853,
222
+ 825,
223
+ 924
224
+ ],
225
+ "page_idx": 1
226
+ },
227
+ {
228
+ "type": "text",
229
+ "text": "",
230
+ "bbox": [
231
+ 174,
232
+ 103,
233
+ 825,
234
+ 174
235
+ ],
236
+ "page_idx": 2
237
+ },
238
+ {
239
+ "type": "text",
240
+ "text": "Previously proposed non-generative approaches to experience replay (Robins, 1995; French, 1997; Robins, 2004) propose to preserve neural networks’ learnt mappings by arbitrarily sampling random inputs and their corresponding outputs from the neural networks and using them along with new task samples while training. These approaches have only been tested in small binary input spaces in previous works, and our experiments in section 4 show that sampling random inputs in highdimensional spaces (e.g. images) does not preserve the mapping learnt by neural networks. ",
241
+ "bbox": [
242
+ 174,
243
+ 180,
244
+ 825,
245
+ 265
246
+ ],
247
+ "page_idx": 2
248
+ },
249
+ {
250
+ "type": "text",
251
+ "text": "3.1 GENERATIVE EXPERIENCE REPLAY ",
252
+ "text_level": 1,
253
+ "bbox": [
254
+ 176,
255
+ 284,
256
+ 455,
257
+ 296
258
+ ],
259
+ "page_idx": 2
260
+ },
261
+ {
262
+ "type": "image",
263
+ "img_path": "images/6170b28f0b9ad0e31d7cc1635be8649edabf848daa9d52ed8abbc48ead26cfa6.jpg",
264
+ "image_caption": [
265
+ "Figure 1: Deep Generative Replay to train a Deep Generative Memory "
266
+ ],
267
+ "image_footnote": [],
268
+ "bbox": [
269
+ 174,
270
+ 313,
271
+ 820,
272
+ 463
273
+ ],
274
+ "page_idx": 2
275
+ },
276
+ {
277
+ "type": "text",
278
+ "text": "Deep Generative Memory (DGM): We first introduce a sub-model called the Deep Generative Memory (see figure 1) which has three elements: (i) a generative model (the generator $G$ ), (ii) a feedforward network (the learner $L$ ), and (iii) a dictionary $( D _ { d g m } )$ with task IDs of learnt tasks and the number of times they were encountered. We call this a memory because of its weights and learning capacity, not due to any recurrent connections. We assume availability of unique task IDs for replay and to identify repetition. In practice, a task identification system (e.g., a HMM-based inference model) like in previous works (Kirkpatrick et al., 2017) suffices for this purpose. We choose variational autoencoder (VAE) (Kingma & Welling, 2014) for the generator, since our generative model requires reconstruction capabilities (see section 3.2). ",
279
+ "bbox": [
280
+ 174,
281
+ 510,
282
+ 825,
283
+ 636
284
+ ],
285
+ "page_idx": 2
286
+ },
287
+ {
288
+ "type": "text",
289
+ "text": "Deep Generative Replay (DGR): We update a DGM with samples from (multiple) new tasks using our algorithm Deep Generative Replay (see figure 1 above and algorithm 1 in appendix A). Given new incoming samples $( X , Y )$ , DGR first computes the fraction of total samples that should come from incoming samples $( \\eta _ { t a s k s } )$ and the fraction to come from previous task samples $( \\eta _ { g e n } )$ proportionate to the number of tasks (counting repetitions). It allots a minimum fraction $\\kappa$ of the memory capacity $N _ { m a x }$ per new task. This ensures that as the DGM saturates with tasks over time, new tasks are still learnt at the cost of gradually losing performance on the least recent previous tasks. This saturation is synonymous to how learning slows down in humans as they age but they still continue to learn new tasks while forgetting old things gradually (French, 1999). Next, DGR computes the number of samples to be generated from previous tasks and subsamples the incoming samples (if needed) to obey maximum memory capacity $( N _ { m a x } )$ . It then generates samples of previously learnt tasks $( X _ { g e n } , Y _ { g e n } )$ using the generator and learner, reconstructs the data $\\{ X , X _ { g e n } \\}$ using the generator (hence we use a VAE) and then trains the DGM on resulting samples $\\scriptstyle ( X _ { r e c o n }$ , $\\{ Y , Y _ { g e n } \\} )$ . Doing this final reconstruction provides robustness to noise and occlusion (section 5). ",
290
+ "bbox": [
291
+ 173,
292
+ 642,
293
+ 825,
294
+ 837
295
+ ],
296
+ "page_idx": 2
297
+ },
298
+ {
299
+ "type": "text",
300
+ "text": "3.2 DUAL MEMORY NETWORKS ",
301
+ "text_level": 1,
302
+ "bbox": [
303
+ 176,
304
+ 856,
305
+ 405,
306
+ 869
307
+ ],
308
+ "page_idx": 2
309
+ },
310
+ {
311
+ "type": "text",
312
+ "text": "A good continual learning system needs to quickly acquire new tasks and also retain performance on previously learnt tasks. These conflicting requirements are hard to satisfy simultaneously. Hence, inspired by nature’s solution to this problem, we propose a dual memory network to combat forgetting. ",
313
+ "bbox": [
314
+ 176,
315
+ 882,
316
+ 825,
317
+ 924
318
+ ],
319
+ "page_idx": 2
320
+ },
321
+ {
322
+ "type": "image",
323
+ "img_path": "images/81669f8d5703e75d381c36489d050107cda125a58c6375aa8cb5d5b7d89b3746.jpg",
324
+ "image_caption": [
325
+ "Figure 2: Deep Generative Dual Memory Network (DGDMN) "
326
+ ],
327
+ "image_footnote": [],
328
+ "bbox": [
329
+ 174,
330
+ 99,
331
+ 820,
332
+ 262
333
+ ],
334
+ "page_idx": 3
335
+ },
336
+ {
337
+ "type": "text",
338
+ "text": "Our architecture (DGDMN) shown in figure 2 comprises of a large deep generative memory (DGM) called the long-term memory (LTM) which stores information of all previously learnt tasks like the neocortex, and a short-term memory (STM) which behaves similar to the hippocampus and learns new incoming tasks quickly without interference from previous tasks. The STM is a collection of small, dedicated, task-specific deep generative memories (called short-term task memory – STTM), which can each learn one unique task. If an incoming task comes is already in an STTM, the same STTM is used to retrain on it, otherwise a fresh STTM is allocated to the task. Additionally, if the task has been previously consolidated then the LTM reconstructs the incoming samples for that task using the generator (hence we use a VAE), predicts labels for the reconstructions using its learner and sends these newly generated samples to the STTM allocated to this task. This provides extra samples on tasks which have been learnt previously and helps to learn them better, while also preserving the previous performance on that task to some extent. ",
339
+ "bbox": [
340
+ 173,
341
+ 319,
342
+ 825,
343
+ 486
344
+ ],
345
+ "page_idx": 3
346
+ },
347
+ {
348
+ "type": "text",
349
+ "text": "Once all $\\left( n _ { S T M } \\right)$ STTMs are exhausted, the architecture sleeps (like humans) to consolidate all tasks into the LTM and free up the STTMs for new tasks. While asleep, the STM generates and sends samples of learnt tasks to the LTM, where these are consolidated via deep generative replay (see figure 2). While testing on task $t$ (even intermittently between tasks), if any STTM currently contains task $t$ , it is used to predict the labels, else the prediction is deferred to the LTM. This allows predicting on all tasks seen uptil now (including the most recent ones) without sleeping. ",
350
+ "bbox": [
351
+ 174,
352
+ 493,
353
+ 825,
354
+ 577
355
+ ],
356
+ "page_idx": 3
357
+ },
358
+ {
359
+ "type": "text",
360
+ "text": "4 EXPERIMENTS ",
361
+ "text_level": 1,
362
+ "bbox": [
363
+ 176,
364
+ 598,
365
+ 326,
366
+ 614
367
+ ],
368
+ "page_idx": 3
369
+ },
370
+ {
371
+ "type": "text",
372
+ "text": "We perform experiments to demonstrate forgetting on sequential image classification tasks. We briefly describe our datasets here (details in appendix B): (a) Permnist is a catastrophic forgetting (Goodfellow et al., 2015; Kirkpatrick et al., 2017) benchmark and each task contains a fixed permutation of pixels on MNIST images (LeCun et al., 1998), (b) Digits dataset involves classifying a single MNIST digit per task, (c) TDigits is a transformed variant of MNIST similar to Digits but with 40 tasks for long task sequences, (d) Shapes contains several geometric shape classification tasks, and (e) Hindi contains a sequence of 8 tasks with hindi language consonant recognition. ",
373
+ "bbox": [
374
+ 174,
375
+ 631,
376
+ 825,
377
+ 728
378
+ ],
379
+ "page_idx": 3
380
+ },
381
+ {
382
+ "type": "text",
383
+ "text": "Along with our model (DGDMN), we test several baselines for catastrophic forgetting, which are briefly described here (implementation and hyperparameter details in appendix B): (a) Feedforward neural networks (NN): We use these to characterize the forgetting in the absence of any prevention mechanism and as a datum for other approaches, (b) Neural nets with dropout (DropNN): Goodfellow et al. (2015) suggested using dropout as a means to prevent representational overlaps and pacify catastrophic forgetting, (c) Pseudopattern Rehearsal (PPR): A non-generative approach to experience replay (Robins, 2004), (d) Elastic Weight Consolidation (EWC): Kirkpatrick et al. (2017) proposed using the Fisher Information Matrix for task-specific consolidation of weights in a neural network, and (e) Deep Generative Replay (DGR): Using a single DGM to separate the effects of generative replay and dual memory architecture. ",
384
+ "bbox": [
385
+ 174,
386
+ 734,
387
+ 825,
388
+ 875
389
+ ],
390
+ "page_idx": 3
391
+ },
392
+ {
393
+ "type": "text",
394
+ "text": "In our preliminary experiments, we observed that large networks with excessive parameters can more easily adapt to sequentially incoming tasks, thereby masking the severity of catastrophic forgetting. So we have chosen network architectures which have to share all their parameters appropriately amongst the various tasks in a dataset to achieve reasonable joint accuracy on the dataset. This allows us to evaluate an algorithm carefully while ignoring the benefits provided by excessive parameterization. ",
395
+ "bbox": [
396
+ 176,
397
+ 882,
398
+ 823,
399
+ 924
400
+ ],
401
+ "page_idx": 3
402
+ },
403
+ {
404
+ "type": "text",
405
+ "text": "",
406
+ "bbox": [
407
+ 171,
408
+ 103,
409
+ 823,
410
+ 132
411
+ ],
412
+ "page_idx": 4
413
+ },
414
+ {
415
+ "type": "text",
416
+ "text": "4.1 ACCURACY AND FORGETTING CURVES ",
417
+ "text_level": 1,
418
+ "bbox": [
419
+ 174,
420
+ 148,
421
+ 485,
422
+ 162
423
+ ],
424
+ "page_idx": 4
425
+ },
426
+ {
427
+ "type": "image",
428
+ "img_path": "images/f90671a567428e4bdd15231af6701dd7dee23b3dc65ef2700483768a4983043a.jpg",
429
+ "image_caption": [
430
+ "Figure 3: Accuracy curves for Permnist (x: tasks seen, y: classification accuracy on task). "
431
+ ],
432
+ "image_footnote": [],
433
+ "bbox": [
434
+ 183,
435
+ 178,
436
+ 815,
437
+ 428
438
+ ],
439
+ "page_idx": 4
440
+ },
441
+ {
442
+ "type": "text",
443
+ "text": "We trained DGDMN and all above baselines sequentially on the image classification tasks of Permnist, Digits, Shapes and Hindi datasets (separately). We show results on the Shapes and Hindi dataset in appendix A. The classification accuracy on a held out test set for each task, after training on the $t ^ { t h }$ task has been shown in figures 3 and 4. We used the same network architecture for each of NN, PPR, EWC, learner in DGR, and learner in the LTM of DGDMN (for a single dataset). DropNN had two intermediate dropout layers after each hidden layer (see appendix B for details). ",
444
+ "bbox": [
445
+ 173,
446
+ 470,
447
+ 826,
448
+ 555
449
+ ],
450
+ "page_idx": 4
451
+ },
452
+ {
453
+ "type": "text",
454
+ "text": "We observe from figures 3a and 3b, that NN and DropNN forget catastrophically when they learn new tasks. This shows that sparse representation based methods rely on the neural network being of high enough capacity to learn sparse representations (Goodfellow et al., 2015) and may not perform well if the network does not have redundant weights available. EWC forgets less than NN and DropNN, but it rapidly slows down learning on many weights and its learning effectively stagnates after Task 3 (e.g. see Tasks 5 and 6 in figure 3d). The learning slowdown on weights hinders EWC from reusing those weights later on to jointly discover common structures amongst previously learnt and newly incoming tasks. Note that the networks do have the capacity to learn all tasks and our algorithms DGR and DGDMN outperform all baselines by learning all tasks sequentially with this same learner network (figures 3e, 3f). ",
455
+ "bbox": [
456
+ 174,
457
+ 561,
458
+ 825,
459
+ 702
460
+ ],
461
+ "page_idx": 4
462
+ },
463
+ {
464
+ "type": "text",
465
+ "text": "We observed heavy forgetting on Digits (figure 4) for most baselines, which is expected because all samples in the $t ^ { t h }$ task have a single label $\\mathbf { \\rho } ( t )$ and so the $t ^ { t h }$ task can be learnt on its own by setting the $\\hat { t } ^ { t h }$ bias of the softmax layer to be high and the other biases low. Such sequential tasks cause catastrophic forgetting. We observed that NN, DropNN, PPR and EWC learnt only the task being trained on and forgot all previous knowledge immediately. Sometimes, we also observed saturation due to the softmax bias being set very high and then being unable to recover from it. PPR showed severe saturation since its replay prevented it from coming out of the saturation. ",
466
+ "bbox": [
467
+ 174,
468
+ 708,
469
+ 825,
470
+ 805
471
+ ],
472
+ "page_idx": 4
473
+ },
474
+ {
475
+ "type": "text",
476
+ "text": "DGR and DGDMN still retain performance on all tasks of Digits, and our replay strategy prevents saturation by appropriately balancing the ratios of new incoming samples and generated samples from previous tasks. The average forgetting on all tasks $\\in \\{ 1 , \\ldots , t \\}$ , after training on the $t ^ { t h }$ task (for both Digits and Permnist) is shown in figure 5. For absolute reference, the accuracy of NN by training it jointly on all tasks uptil the $t ^ { t h }$ task has also been shown for each $t$ . Again DGR and DGDMN outperform baselines in terms of retained average accuracy. In figure 5b, NN, DropNN, PPR and EWC follow nearly overlapping curves $\\begin{array} { r } { ( a c c \\approx \\frac { 1 } { t } } \\end{array}$ ) since they are only able to learn one task at a time. Further, though PPR involves experience replay, it does not compare against DGR and ",
477
+ "bbox": [
478
+ 174,
479
+ 811,
480
+ 825,
481
+ 924
482
+ ],
483
+ "page_idx": 4
484
+ },
485
+ {
486
+ "type": "image",
487
+ "img_path": "images/18714c2ef10b46abede86490f2ee7f34c52a46f8fc88844d5515b77a16b2e69d.jpg",
488
+ "image_caption": [
489
+ "Figure 4: Accuracy curves for Digits (x: tasks seen, y: classification accuracy on task). "
490
+ ],
491
+ "image_footnote": [],
492
+ "bbox": [
493
+ 183,
494
+ 101,
495
+ 813,
496
+ 353
497
+ ],
498
+ "page_idx": 5
499
+ },
500
+ {
501
+ "type": "image",
502
+ "img_path": "images/c51550482d517a0103f006376cf5c3ec3bae898c93b182b62c7ce37e79a7f42d.jpg",
503
+ "image_caption": [
504
+ "Figure 5: Forgetting curves (x: tasks seen, y: avg classification accuracy on tasks seen). "
505
+ ],
506
+ "image_footnote": [],
507
+ "bbox": [
508
+ 236,
509
+ 397,
510
+ 761,
511
+ 547
512
+ ],
513
+ "page_idx": 5
514
+ },
515
+ {
516
+ "type": "text",
517
+ "text": "DGDMN (figures 3c, 4c). Although, it does preserve its learnt mapping around the points randomly sampled from its domain, these random samples are not close to real images and fail to preserve performance. These observations substantiate our claim that any replay mechanism must model the input domain accurately and hence needs to be generative in nature. We observed similar results for the Shapes and Hindi dataset (appendix A). ",
518
+ "bbox": [
519
+ 174,
520
+ 604,
521
+ 825,
522
+ 674
523
+ ],
524
+ "page_idx": 5
525
+ },
526
+ {
527
+ "type": "text",
528
+ "text": "We point out that datasets like Digits, which contain tasks with highly correlated input (and/or output) samples should be important benchmarks for continual learning for two main reasons: (i) High correlation amongst task samples promotes overfitting to the new incoming task and therefore causes catastrophic forgetting. Being able to retain performance on such task sequences is a strong indicator of the efficacy of a continual learning algorithm. (ii) Humans also learn by seeing many correlated samples together in a short span of time, rather than witnessing nearly IID samples (like in Permnist). For examples, kids learn a single alphabet per day in kindergarten by seeing and writing that alphabet many times that day. Since NN, DropNN and PPR do not fare well on such tasks, we show experiments on EWC, DGR and DGDMN from here on. ",
529
+ "bbox": [
530
+ 174,
531
+ 681,
532
+ 825,
533
+ 806
534
+ ],
535
+ "page_idx": 5
536
+ },
537
+ {
538
+ "type": "text",
539
+ "text": "4.2 REPEATED TASKS AND REVISION ",
540
+ "text_level": 1,
541
+ "bbox": [
542
+ 176,
543
+ 827,
544
+ 442,
545
+ 840
546
+ ],
547
+ "page_idx": 5
548
+ },
549
+ {
550
+ "type": "text",
551
+ "text": "It is well known in psychology literature that human learning improves via revision (Kahana & Howard, 2005; Cepeda et al., 2006). We show performance of EWC and DGDMN on Permnist, when some tasks are repeated (figure 6). DGR performs very similar to DGDMN, hence we omit it. EWC stagnates and once learning has slowed down on the weights important for Task 1, the weights cannot be changed again, not even for improving Task 1. Further, it did not learn Task 6 the first time and revision does not help either. However, DGDMN learns all tasks uptil Task 6, then benefits by revising Task 1 again (accuracy goes up), and somewhat for Task 6 (it did not forget Task 6 substantially). We reiterate that DGDMN, by its design, benefits significantly from revision because STTMs learning a repeated task gain extra samples from the LTM (or generated samples from themselves, if they had learnt the task before). While many previous works do not investigate revision, it is crucial for learning continuously and should improve performance on tasks. The ability to learn from correlated task samples and revision makes our memory architecture functionally similar to that of humans. ",
552
+ "bbox": [
553
+ 174,
554
+ 854,
555
+ 825,
556
+ 924
557
+ ],
558
+ "page_idx": 5
559
+ },
560
+ {
561
+ "type": "image",
562
+ "img_path": "images/eae57c9c87ebd7c5affebc56623c475814c7bb1417300a3e17e7091d2aed7d27.jpg",
563
+ "image_caption": [
564
+ "Figure 6: Accuracy curves when tasks are revised: (a) EWC, (b) DGDMN. "
565
+ ],
566
+ "image_footnote": [],
567
+ "bbox": [
568
+ 207,
569
+ 101,
570
+ 794,
571
+ 267
572
+ ],
573
+ "page_idx": 6
574
+ },
575
+ {
576
+ "type": "text",
577
+ "text": "",
578
+ "bbox": [
579
+ 173,
580
+ 325,
581
+ 825,
582
+ 424
583
+ ],
584
+ "page_idx": 6
585
+ },
586
+ {
587
+ "type": "text",
588
+ "text": "4.3 CONNECTIONS TO COMPLEMENTARY LEARNING SYSTEMS AND SLEEP ",
589
+ "text_level": 1,
590
+ "bbox": [
591
+ 174,
592
+ 448,
593
+ 696,
594
+ 460
595
+ ],
596
+ "page_idx": 6
597
+ },
598
+ {
599
+ "type": "text",
600
+ "text": "To explore the role of the dual memory architecture and differentiate between DGDMN and DGR, we trained these algorithms on the long sequence of 40 tasks from TDigits dataset. We limited $N _ { m a x }$ to 120, 000 samples for this task to explore the case where the LTM in DGDMN (DGM in DGR) cannot regenerate as many samples as in the full dataset and has to forget some tasks. At least $\\kappa = 0 . 0 5$ fraction of memory was ensured per new task and consolidation in DGDMN happened after $n _ { S T M } = 5$ tasks. ",
601
+ "bbox": [
602
+ 173,
603
+ 474,
604
+ 825,
605
+ 558
606
+ ],
607
+ "page_idx": 6
608
+ },
609
+ {
610
+ "type": "image",
611
+ "img_path": "images/551b6c0ce39a768723325fa8dfec54d2c5ca847b4712a311f8e4fb3e4524d2f4.jpg",
612
+ "image_caption": [
613
+ "Figure 7: Accuracy curves for TDigits on: (a) tasks seen so far, (b) last 10 tasks seen. "
614
+ ],
615
+ "image_footnote": [],
616
+ "bbox": [
617
+ 207,
618
+ 578,
619
+ 794,
620
+ 751
621
+ ],
622
+ "page_idx": 6
623
+ },
624
+ {
625
+ "type": "text",
626
+ "text": "The average forgetting curves vs. tasks encountered are plotted in figure 7a. DGDMN and DGR start around an average accuracy of 1.0, but start dropping after 10 tasks since the LTM (DGM for DGR) begins to saturate. While DGDMN drops slowly and retains $> 4 0 \\%$ accuracy on all tasks, DGR drops below $2 0 \\%$ accuracy. This is because DGR consolidates its DGM too often and the DGM’s self-generated slightly erroneous samples compound errors quite fast. DGDMN uses small STTMs to learn single tasks with low error and transfers them simultaneously to the LTM. As a consequence, DGDMN consolidates its LTM with more accurate samples and less often, hence its error accumulates much slower. We discuss the effect of the small error in STTM representations in section 5. ",
627
+ "bbox": [
628
+ 173,
629
+ 797,
630
+ 825,
631
+ 922
632
+ ],
633
+ "page_idx": 6
634
+ },
635
+ {
636
+ "type": "text",
637
+ "text": "Even though DGDMN displays inevitable forgetting in figure $\\mathrm { 7 a }$ (due to memory constraint), the forgetting is gradual and not catastrophic as seen for NN, DropNN, PPR etc. on Digits dataset. We also measure average accuracy on the most recent few tasks seen (say 10). Figure 7b shows that DGDMN oscillates around $9 0 \\%$ average accuracy, whereas DGR��s frequent consolidation propagates errors too fast and its accuracy drops even on this metric. ",
638
+ "bbox": [
639
+ 174,
640
+ 103,
641
+ 825,
642
+ 174
643
+ ],
644
+ "page_idx": 7
645
+ },
646
+ {
647
+ "type": "text",
648
+ "text": "Another advantage of dual memories is revealed by the training time for the algorithms. Figure 9a shows an order of magnitude of difference between DGDMN and DGR in training time. This is because STTMs are smaller and faster to train than the LTM. LTM preserves all the tasks seen so far and hence requires a large number of samples to consolidate, which is costly and should not be done after every task. Learning new tasks quickly in the STM and holding them till sleep provides a speed advantage and allows learning quickly with only periodic consolidation. ",
649
+ "bbox": [
650
+ 174,
651
+ 180,
652
+ 825,
653
+ 263
654
+ ],
655
+ "page_idx": 7
656
+ },
657
+ {
658
+ "type": "text",
659
+ "text": "The dual memory architecture is a critical design choice for scalability and has also emerged naturally in humans, in the form of the complementary learning systems and the need to sleep periodically. Even though sleeping is a dangerous behavior for any organism since it can be harmed or attacked by a predator while asleep, sleep has still survived through eons of evolution and never been lost (Joiner, 2016). Today, most organisms with even a slightly developed nervous system (centralized or diffuse) display either sleep or light-resting behavior (Nath et al., 2017). The experiment demonstrates the importance of sleep, since without the dual memory architecture intertwined with periodic sleep, learning would be very short lived and highly time consuming (as in DGR). ",
660
+ "bbox": [
661
+ 174,
662
+ 270,
663
+ 826,
664
+ 382
665
+ ],
666
+ "page_idx": 7
667
+ },
668
+ {
669
+ "type": "text",
670
+ "text": "5 ANALYSIS AND DISCUSSION ",
671
+ "text_level": 1,
672
+ "bbox": [
673
+ 176,
674
+ 402,
675
+ 439,
676
+ 417
677
+ ],
678
+ "page_idx": 7
679
+ },
680
+ {
681
+ "type": "text",
682
+ "text": "In this section we show that DGDMN shares some more remarkable characteristics with the human memory and present a discussion of some more related ideas. Due to space constraints, visualizations of the learnt latent structures when training jointly vs. sequentially have been deferred to appendix A. The hyperparameters of DGDMN $\\kappa$ and $n _ { S T M }$ ) have intuitive interpretations and we have provided simple heuristics to choose them without any complex searches (in appendix B). ",
683
+ "bbox": [
684
+ 174,
685
+ 433,
686
+ 825,
687
+ 502
688
+ ],
689
+ "page_idx": 7
690
+ },
691
+ {
692
+ "type": "text",
693
+ "text": "Resilience to noise and occlusion: We use a VAE to be able to reconstruct representations of samples. Reconstructed images are less noisy and can recover from partial occlusion, which gives our model human-like abilities to recognize objects in noisy, distorted or occluded images. We test our LTM model and a NN model by jointly training on uncorrupted Digits data and testing on noisy and occluded images. We see that the LTM is more robust to noisy and occluded images and exhibits smoother degradation in classification accuracy because of its denoising reconstructive properties (see figure 8). ",
694
+ "bbox": [
695
+ 173,
696
+ 510,
697
+ 825,
698
+ 607
699
+ ],
700
+ "page_idx": 7
701
+ },
702
+ {
703
+ "type": "image",
704
+ "img_path": "images/b1a7b1d3587e4b7d8ba4199220da570ab89bff3e6745f2c708d9bca8f8c3211e.jpg",
705
+ "image_caption": [
706
+ "Figure 8: (a) LTM reconstruction from noisy and occluded digits, (b) Classification accuracy with increasing gaussian noise, and (c) Classification accuracy with increasing occlusion factor. "
707
+ ],
708
+ "image_footnote": [],
709
+ "bbox": [
710
+ 194,
711
+ 627,
712
+ 816,
713
+ 800
714
+ ],
715
+ "page_idx": 7
716
+ },
717
+ {
718
+ "type": "text",
719
+ "text": "The choice of underlying generative model: Our consolidation ability and retention performance relies heavily on the generation and reconstruction ability of the underlying generative model. We chose a VAE for its reconstructive capabilities but our architecture is agnostic to the choice of the underlying generative model as long as the generator can generate reliable samples and reconstruct incoming samples accurately. Hence, variants of Generative Adversarial Networks (GAN) Goodfellow et al. (2014) like BiGANs (Donahue et al., 2017), ALI (Dumoulin et al., 2017) and AVB (Mescheder et al., 2017) can also be used for the generative model depending on the modeled domain. ",
720
+ "bbox": [
721
+ 174,
722
+ 853,
723
+ 823,
724
+ 924
725
+ ],
726
+ "page_idx": 7
727
+ },
728
+ {
729
+ "type": "image",
730
+ "img_path": "images/9158c81af36b3949c6e51f753ee820453a27c854b40008e26b8f5668e9eedb3e.jpg",
731
+ "image_caption": [
732
+ "Figure 9: (a) Training time for DGDMN and DGR, (b) Accuracy curves: DGDMN (no STM). "
733
+ ],
734
+ "image_footnote": [],
735
+ "bbox": [
736
+ 204,
737
+ 102,
738
+ 790,
739
+ 271
740
+ ],
741
+ "page_idx": 8
742
+ },
743
+ {
744
+ "type": "text",
745
+ "text": "",
746
+ "bbox": [
747
+ 174,
748
+ 324,
749
+ 820,
750
+ 353
751
+ ],
752
+ "page_idx": 8
753
+ },
754
+ {
755
+ "type": "text",
756
+ "text": "Why use short-term memory?: Our LTM always learns from STTMs and never from real data, and the STTMs’ errors slowly propagate into the LTM and contribute to forgetting. An alternative could be to directly store data from new incoming tasks, consolidate it into the LTM after periodic intervals, and then discard the data. We show the accuracy curves on Digits dataset for this approach in figure 9b. This results in higher retention compared to DGDMN in figure 4 because LTM now learns from real data. However, this approach is not truly online since recently learnt tasks cannot be used immediately until after a sleep phase. Since the STM’s error can be made smaller by using high capacity generators and classifiers, we suggest using a STM for true online continual learning. ",
757
+ "bbox": [
758
+ 173,
759
+ 359,
760
+ 825,
761
+ 472
762
+ ],
763
+ "page_idx": 8
764
+ },
765
+ {
766
+ "type": "text",
767
+ "text": "Connections to knowledge distillation: Previous works on (joint) multitask learning have also proposed approaches to learn individual tasks with small networks and then “distilling” them jointly into a larger neural network (Rusu et al., 2015). Such distillation can sometimes improve performance on individual tasks if they share structure and at other times mitigate inter-task interference due to refinement of learnt functions while distilling (Parisotto et al., 2016). Though we do not use temperature-controlled soft-labels while consolidating tasks into the LTM (unlike distillation), we surmise that due to refinement and compression during consolidation phase, DGDMN is also able to learn joint task structure effectively while mitigating interference between tasks. ",
768
+ "bbox": [
769
+ 174,
770
+ 478,
771
+ 825,
772
+ 589
773
+ ],
774
+ "page_idx": 8
775
+ },
776
+ {
777
+ "type": "text",
778
+ "text": "Approaches based on synaptic consolidation: Though our architecture draws inspiration from complementary learning systems and experience replay in the human brain, there is also considerable neuroscientific evidence for synaptic consolidation in the human brain (like in EWC). It might be interesting to explore how synaptic consolidation can be incorporated in our dual memory architecture without causing stagnation and we leave this to future work. We also plan to extend our architecture to learning optimal policies over time via reinforcement learning without explicit replay memories. ",
779
+ "bbox": [
780
+ 174,
781
+ 597,
782
+ 825,
783
+ 680
784
+ ],
785
+ "page_idx": 8
786
+ },
787
+ {
788
+ "type": "text",
789
+ "text": "6 CONCLUSION ",
790
+ "text_level": 1,
791
+ "bbox": [
792
+ 174,
793
+ 700,
794
+ 318,
795
+ 715
796
+ ],
797
+ "page_idx": 8
798
+ },
799
+ {
800
+ "type": "text",
801
+ "text": "In this work, we have developed a model capable of learning continuously on sequentially incoming tasks, while averting catastrophic forgetting. Our model employs a dual memory architecture to emulate the complementary learning systems (hippocampus and the neocortex) in the human brain and maintains a consolidated long-term memory via generative replay of past experiences. We have shown that generative replay performs the best for long-term performance retention even for neural networks with small capacity, while demonstrating the benefits of using generative replay and a dual memory architecture via our experiments. Our model hyperparameters have simple interpretations and can be set without much tuning. Moreover, our architecture displays remarkable parallels with the human memory system and provides useful insights about the connection between sleep and learning in humans. ",
802
+ "bbox": [
803
+ 174,
804
+ 732,
805
+ 825,
806
+ 871
807
+ ],
808
+ "page_idx": 8
809
+ },
810
+ {
811
+ "type": "text",
812
+ "text": "REFERENCES ",
813
+ "text_level": 1,
814
+ "bbox": [
815
+ 176,
816
+ 102,
817
+ 285,
818
+ 118
819
+ ],
820
+ "page_idx": 9
821
+ },
822
+ {
823
+ "type": "text",
824
+ "text": "Marcus K Benna and Stefano Fusi. Computational principles of synaptic memory consolidation. Nature neuroscience, 2016. ",
825
+ "bbox": [
826
+ 173,
827
+ 126,
828
+ 823,
829
+ 155
830
+ ],
831
+ "page_idx": 9
832
+ },
833
+ {
834
+ "type": "text",
835
+ "text": "Nicholas J Cepeda, Harold Pashler, Edward Vul, John T Wixted, and Doug Rohrer. Distributed practice in verbal recall tasks: A review and quantitative synthesis. Psychological bulletin, 132(3): 354, 2006. ",
836
+ "bbox": [
837
+ 173,
838
+ 162,
839
+ 826,
840
+ 205
841
+ ],
842
+ "page_idx": 9
843
+ },
844
+ {
845
+ "type": "text",
846
+ "text": "Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. In International Conference on Learning Representations (ICLR), 2017. ",
847
+ "bbox": [
848
+ 171,
849
+ 213,
850
+ 825,
851
+ 243
852
+ ],
853
+ "page_idx": 9
854
+ },
855
+ {
856
+ "type": "text",
857
+ "text": "Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. In International Conference on Learning Representations (ICLR), 2017. ",
858
+ "bbox": [
859
+ 176,
860
+ 251,
861
+ 823,
862
+ 294
863
+ ],
864
+ "page_idx": 9
865
+ },
866
+ {
867
+ "type": "text",
868
+ "text": "Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. arXiv preprint arXiv:1701.08734, 2017. ",
869
+ "bbox": [
870
+ 176,
871
+ 303,
872
+ 823,
873
+ 345
874
+ ],
875
+ "page_idx": 9
876
+ },
877
+ {
878
+ "type": "text",
879
+ "text": "Robert M French. Dynamically constraining connectionist networks to produce distributed, orthogonal representations to reduce catastrophic interference. network, 1111:00001, 1994. ",
880
+ "bbox": [
881
+ 173,
882
+ 353,
883
+ 825,
884
+ 383
885
+ ],
886
+ "page_idx": 9
887
+ },
888
+ {
889
+ "type": "text",
890
+ "text": "Robert M French. Pseudo-recurrent connectionist networks: An approach to the’sensitivitystability’dilemma. Connection Science, 9(4):353–380, 1997. ",
891
+ "bbox": [
892
+ 171,
893
+ 391,
894
+ 825,
895
+ 420
896
+ ],
897
+ "page_idx": 9
898
+ },
899
+ {
900
+ "type": "text",
901
+ "text": "Robert M French. Catastrophic forgetting in connectionist networks. Trends in cognitive sciences, 3 (4):128–135, 1999. ",
902
+ "bbox": [
903
+ 171,
904
+ 428,
905
+ 823,
906
+ 458
907
+ ],
908
+ "page_idx": 9
909
+ },
910
+ {
911
+ "type": "text",
912
+ "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Neural Information Processing Systems (NIPS), pp. 2672–2680, 2014. ",
913
+ "bbox": [
914
+ 173,
915
+ 465,
916
+ 825,
917
+ 508
918
+ ],
919
+ "page_idx": 9
920
+ },
921
+ {
922
+ "type": "text",
923
+ "text": "Ian J Goodfellow, Mehdi Mirza, Da Xiao, Aaron Courville, and Yoshua Bengio. An empirical investigation of catastrophic forgetting in gradient-based neural networks. arXiv preprint arXiv:1312.6211, 2015. ",
924
+ "bbox": [
925
+ 173,
926
+ 517,
927
+ 825,
928
+ 559
929
+ ],
930
+ "page_idx": 9
931
+ },
932
+ {
933
+ "type": "text",
934
+ "text": "Google. The quick, draw! dataset. URL: https://github.com/googlecreativelab/quickdraw-dataset, 2017. ",
935
+ "bbox": [
936
+ 174,
937
+ 568,
938
+ 825,
939
+ 598
940
+ ],
941
+ "page_idx": 9
942
+ },
943
+ {
944
+ "type": "text",
945
+ "text": "Geoffrey Hinton. Neural networks for machine learning - lecture 6a - overview of mini-batch gradient descent, 2012. ",
946
+ "bbox": [
947
+ 174,
948
+ 606,
949
+ 825,
950
+ 635
951
+ ],
952
+ "page_idx": 9
953
+ },
954
+ {
955
+ "type": "text",
956
+ "text": "William J Joiner. Unraveling the evolutionary determinants of sleep. Current Biology, 26(20): R1073–R1087, 2016. ",
957
+ "bbox": [
958
+ 174,
959
+ 643,
960
+ 825,
961
+ 672
962
+ ],
963
+ "page_idx": 9
964
+ },
965
+ {
966
+ "type": "text",
967
+ "text": "Kaggle. Devanagari character set. URL: https://www.kaggle.com/rishianand/devanagari-character-set, 2017. ",
968
+ "bbox": [
969
+ 173,
970
+ 680,
971
+ 825,
972
+ 709
973
+ ],
974
+ "page_idx": 9
975
+ },
976
+ {
977
+ "type": "text",
978
+ "text": "Michael J Kahana and Marc W Howard. Spacing and lag effects in free recall of pure lists. Psychonomic Bulletin & Review, 12(1):159–164, 2005. ",
979
+ "bbox": [
980
+ 171,
981
+ 718,
982
+ 825,
983
+ 747
984
+ ],
985
+ "page_idx": 9
986
+ },
987
+ {
988
+ "type": "text",
989
+ "text": "D. P. Kingma and M. Welling. Auto-encoding variational bayes. In International Conference on Learning Representations (ICLR), 2014. ",
990
+ "bbox": [
991
+ 171,
992
+ 755,
993
+ 823,
994
+ 785
995
+ ],
996
+ "page_idx": 9
997
+ },
998
+ {
999
+ "type": "text",
1000
+ "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, pp. 201611835, 2017. ",
1001
+ "bbox": [
1002
+ 173,
1003
+ 792,
1004
+ 826,
1005
+ 849
1006
+ ],
1007
+ "page_idx": 9
1008
+ },
1009
+ {
1010
+ "type": "text",
1011
+ "text": "Chris A Kortge. Episodic memory in connectionist networks. In Proceedings of the 12th Annual Conference of the Cognitive Science Society, volume 764, pp. 771. Erlbaum, 1990. ",
1012
+ "bbox": [
1013
+ 174,
1014
+ 858,
1015
+ 823,
1016
+ 887
1017
+ ],
1018
+ "page_idx": 9
1019
+ },
1020
+ {
1021
+ "type": "text",
1022
+ "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
1023
+ "bbox": [
1024
+ 174,
1025
+ 895,
1026
+ 823,
1027
+ 924
1028
+ ],
1029
+ "page_idx": 9
1030
+ },
1031
+ {
1032
+ "type": "text",
1033
+ "text": "Stephan Lewandowsky. Gradual unlearning and catastrophic interference: A comparison of distributed architectures. Relating theory and data: Essays on human memory in honor of Bennet B. Murdock, pp. 445–476, 1991. ",
1034
+ "bbox": [
1035
+ 174,
1036
+ 103,
1037
+ 823,
1038
+ 146
1039
+ ],
1040
+ "page_idx": 10
1041
+ },
1042
+ {
1043
+ "type": "text",
1044
+ "text": "Long-Ji Lin. Reinforcement learning for robots using neural networks. PhD thesis, Fujitsu Laboratories Ltd, 1993. ",
1045
+ "bbox": [
1046
+ 171,
1047
+ 154,
1048
+ 825,
1049
+ 183
1050
+ ],
1051
+ "page_idx": 10
1052
+ },
1053
+ {
1054
+ "type": "text",
1055
+ "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008. ",
1056
+ "bbox": [
1057
+ 171,
1058
+ 189,
1059
+ 825,
1060
+ 219
1061
+ ],
1062
+ "page_idx": 10
1063
+ },
1064
+ {
1065
+ "type": "text",
1066
+ "text": "James L McClelland, Bruce L McNaughton, and Randall C O’reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory. Psychological review, 102(3):419, 1995. ",
1067
+ "bbox": [
1068
+ 173,
1069
+ 226,
1070
+ 823,
1071
+ 270
1072
+ ],
1073
+ "page_idx": 10
1074
+ },
1075
+ {
1076
+ "type": "text",
1077
+ "text": "Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of learning and motivation, 24:109–165, 1989. ",
1078
+ "bbox": [
1079
+ 173,
1080
+ 275,
1081
+ 825,
1082
+ 306
1083
+ ],
1084
+ "page_idx": 10
1085
+ },
1086
+ {
1087
+ "type": "text",
1088
+ "text": "Ken McRae and Phil A Hetherington. Catastrophic interference is eliminated in pretrained networks. In Proceedings of the 15h Annual Conference of the Cognitive Science Society, pp. 723–728, 1993. ",
1089
+ "bbox": [
1090
+ 174,
1091
+ 311,
1092
+ 826,
1093
+ 342
1094
+ ],
1095
+ "page_idx": 10
1096
+ },
1097
+ {
1098
+ "type": "text",
1099
+ "text": "Lars Mescheder, Sebastian Nowozin, and Andreas Geiger. Adversarial variational bayes: Unifying variational autoencoders and generative adversarial networks. arXiv preprint arXiv:1701.04722, 2017. ",
1100
+ "bbox": [
1101
+ 173,
1102
+ 348,
1103
+ 826,
1104
+ 391
1105
+ ],
1106
+ "page_idx": 10
1107
+ },
1108
+ {
1109
+ "type": "text",
1110
+ "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
1111
+ "bbox": [
1112
+ 176,
1113
+ 398,
1114
+ 823,
1115
+ 443
1116
+ ],
1117
+ "page_idx": 10
1118
+ },
1119
+ {
1120
+ "type": "text",
1121
+ "text": "Decebal Constantin Mocanu, Maria Torres Vega, Eric Eaton, Peter Stone, and Antonio Liotta. Online contrastive divergence with generative replay: Experience replay without storing data. CoRR, abs/1610.05555, 2016. ",
1122
+ "bbox": [
1123
+ 173,
1124
+ 449,
1125
+ 825,
1126
+ 492
1127
+ ],
1128
+ "page_idx": 10
1129
+ },
1130
+ {
1131
+ "type": "text",
1132
+ "text": "Ravi D Nath, Claire N Bedbrook, Michael J Abrams, Ty Basinger, Justin S Bois, David A Prober, Paul W Sternberg, Viviana Gradinaru, and Lea Goentoro. The jellyfish cassiopea exhibits a sleep-like state. Current Biology, 27(19):2984–2990, 2017. ",
1133
+ "bbox": [
1134
+ 174,
1135
+ 498,
1136
+ 825,
1137
+ 542
1138
+ ],
1139
+ "page_idx": 10
1140
+ },
1141
+ {
1142
+ "type": "text",
1143
+ "text": "Joseph O’Neill, Barty Pleydell-Bouverie, David Dupret, and Jozsef Csicsvari. Play it again: reactivation of waking experience and memory. Trends in neurosciences, 33(5):220–229, 2010. ",
1144
+ "bbox": [
1145
+ 173,
1146
+ 549,
1147
+ 825,
1148
+ 579
1149
+ ],
1150
+ "page_idx": 10
1151
+ },
1152
+ {
1153
+ "type": "text",
1154
+ "text": "Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In International Conference on Learning Representations (ICLR), 2016. ",
1155
+ "bbox": [
1156
+ 173,
1157
+ 585,
1158
+ 826,
1159
+ 628
1160
+ ],
1161
+ "page_idx": 10
1162
+ },
1163
+ {
1164
+ "type": "text",
1165
+ "text": "Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Connection Science, 7(2): 123–146, 1995. ",
1166
+ "bbox": [
1167
+ 174,
1168
+ 636,
1169
+ 825,
1170
+ 665
1171
+ ],
1172
+ "page_idx": 10
1173
+ },
1174
+ {
1175
+ "type": "text",
1176
+ "text": "Anthony Robins. Sequential learning in neural networks: A review and a discussion of pseudorehearsal based methods. Intelligent Data Analysis, 8(3):301–322, 2004. ",
1177
+ "bbox": [
1178
+ 173,
1179
+ 671,
1180
+ 825,
1181
+ 702
1182
+ ],
1183
+ "page_idx": 10
1184
+ },
1185
+ {
1186
+ "type": "text",
1187
+ "text": "Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. arXiv preprint arXiv:1511.06295, 2015. ",
1188
+ "bbox": [
1189
+ 173,
1190
+ 708,
1191
+ 825,
1192
+ 751
1193
+ ],
1194
+ "page_idx": 10
1195
+ },
1196
+ {
1197
+ "type": "text",
1198
+ "text": "Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. ",
1199
+ "bbox": [
1200
+ 173,
1201
+ 758,
1202
+ 825,
1203
+ 801
1204
+ ],
1205
+ "page_idx": 10
1206
+ },
1207
+ {
1208
+ "type": "text",
1209
+ "text": "Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Neural Information Processing Systems (NIPS), 2017. ",
1210
+ "bbox": [
1211
+ 173,
1212
+ 808,
1213
+ 823,
1214
+ 838
1215
+ ],
1216
+ "page_idx": 10
1217
+ },
1218
+ {
1219
+ "type": "text",
1220
+ "text": "Rupesh K Srivastava, Jonathan Masci, Sohrob Kazerounian, Faustino Gomez, and Jürgen Schmidhuber. Compete to compute. In Neural Information Processing Systems (NIPS), pp. 2310–2318, 2013. ",
1221
+ "bbox": [
1222
+ 173,
1223
+ 844,
1224
+ 823,
1225
+ 887
1226
+ ],
1227
+ "page_idx": 10
1228
+ },
1229
+ {
1230
+ "type": "text",
1231
+ "text": "Guang Yang, Cora Sau Wan Lai, Joseph Cichon, Lei Ma, Wei Li, and Wen-Biao Gan. Sleep promotes branch-specific formation of dendritic spines after learning. Science, 344(6188):1173–1178, 2014. ",
1232
+ "bbox": [
1233
+ 174,
1234
+ 895,
1235
+ 823,
1236
+ 924
1237
+ ],
1238
+ "page_idx": 10
1239
+ },
1240
+ {
1241
+ "type": "text",
1242
+ "text": "7 APPENDIX A ",
1243
+ "text_level": 1,
1244
+ "bbox": [
1245
+ 174,
1246
+ 102,
1247
+ 313,
1248
+ 118
1249
+ ],
1250
+ "page_idx": 11
1251
+ },
1252
+ {
1253
+ "type": "text",
1254
+ "text": "7.1 DEEP GENERATIVE REPLAY ",
1255
+ "bbox": [
1256
+ 176,
1257
+ 133,
1258
+ 408,
1259
+ 148
1260
+ ],
1261
+ "page_idx": 11
1262
+ },
1263
+ {
1264
+ "type": "text",
1265
+ "text": "Algorithm 1: Deep Generative Replay ",
1266
+ "text_level": 1,
1267
+ "bbox": [
1268
+ 176,
1269
+ 171,
1270
+ 429,
1271
+ 186
1272
+ ],
1273
+ "page_idx": 11
1274
+ },
1275
+ {
1276
+ "type": "text",
1277
+ "text": "1: Input: Current parameters of DGM, new samples: $( X , Y )$ , dictionary for new samples: $D _ { t a s k s }$ (there can be multiple tasks), minimum fraction: $\\kappa$ , memory capacity: $N _ { m a x }$ \n2: Output: New parameters of DGM // Compute sampling fractions \n3: ηtasks := P tasksDdgm+P Dtasks and $\\eta _ { g e n } : = 1 - \\eta _ { t a s k s }$ \n4: if $\\eta _ { t a s k s } < \\kappa | D _ { t a s k s } |$ then \n5: $\\eta _ { t a s k s } : = \\kappa | D _ { t a s k s } |$ and $\\eta _ { g e n } : = 1 - \\eta _ { t a s k s }$ \n6: end if // Compute number of samples \n7: if $| X | > \\eta _ { t a s k s } \\times N _ { m a x }$ then \n8: $n _ { t a s k s } : = \\eta _ { t a s k s } \\times N _ { m a x }$ and $n _ { g e n } : = N _ { m a x } - n _ { t a s k s }$ \n9: Subsample $( X , Y )$ to meet size $n _ { t a s k s }$ \n10: else \n11: $n _ { t a s k s } : = | X |$ and $\\begin{array} { r } { n _ { g e n } : = \\frac { \\eta _ { g e n } } { \\eta _ { t a s k s } } \\times | \\boldsymbol { X } | } \\end{array}$ \n12 : end if // Generate and reconstruct samples \n13: Generate $n _ { g e n }$ samples: $X _ { g e n }$ from generator $G$ and labels from learner $L$ : $Y _ { g e n } = L ( X _ { g e n } )$ \n14: $X _ { r e c o n } = \\mathrm { R }$ econstruct $\\{ X , \\bar { X } _ { g e n } \\}$ using the generator $G$ // Train the DGM \n15: Train the generator $G$ on $X _ { r e c o n }$ \n16: Train the learner $L$ on $( X _ { r e c o n } , \\{ Y , Y _ { g e n } \\} )$ ",
1278
+ "bbox": [
1279
+ 178,
1280
+ 189,
1281
+ 820,
1282
+ 497
1283
+ ],
1284
+ "page_idx": 11
1285
+ },
1286
+ {
1287
+ "type": "text",
1288
+ "text": "Deep Generative Replay (algorithm 1), as described in section 3.1, consolidates new tasks for a DGM with previously learnt tasks. It first computes sampling fractions for new tasks $( \\eta _ { t a s k s } )$ and previously learnt tasks $( \\eta _ { g e n } )$ and ensures a minimum fraction $\\left( \\kappa \\right)$ per new task (lines 3–6). Then it computes the number of samples to generate from previous tasks and whether to subsample the incoming task samples to satisfy the memory capacity $N _ { m a x }$ (lines 7–12). Finally, it generates the required number of samples from previous tasks, reconstructs all data and trains the DGM on resulting data (lines 13–16). For a dictionary $D , \\sum D$ is the total number of tasks in $D$ counting repetitions, while $| D |$ is the total number of tasks without repetitions. $| X |$ is the number of samples in set $X$ . ",
1289
+ "bbox": [
1290
+ 173,
1291
+ 520,
1292
+ 825,
1293
+ 632
1294
+ ],
1295
+ "page_idx": 11
1296
+ },
1297
+ {
1298
+ "type": "text",
1299
+ "text": "Shin et al. (2017) have recently proposed a similar idea independently and Mocanu et al. (2016) have also employed a generative replay in two-layer restricted boltzmann machines, but they do not describe balancing new and generated samples and cannot recognize repeated tasks (section 4.2). Their generative replay without a dual memory architecture is costly to train (section 4.3) and a lack of reconstruction for new samples makes their representations less robust to noise and occlusions (section 5). ",
1300
+ "bbox": [
1301
+ 174,
1302
+ 638,
1303
+ 825,
1304
+ 722
1305
+ ],
1306
+ "page_idx": 11
1307
+ },
1308
+ {
1309
+ "type": "text",
1310
+ "text": ".2 MORE EXPERIMENTS WITH ACCURACY AND FORGETTING CURVES ",
1311
+ "text_level": 1,
1312
+ "bbox": [
1313
+ 187,
1314
+ 741,
1315
+ 666,
1316
+ 755
1317
+ ],
1318
+ "page_idx": 11
1319
+ },
1320
+ {
1321
+ "type": "text",
1322
+ "text": "In this section, we present more experiments on the Shapes and the Hindi dataset, which contain sequences of tasks with geometric shapes and hindi consonants recognition respectively. We observed similar forgetting patterns as on the Digits dataset in section 4. All baselines exhibited catastrophic forgetting on these sequences of tasks, but DGR and DGDMN were able to learn the task structure sequentially (figures 10, 11). The same is reflected in the average forgetting curves in figure 12. ",
1323
+ "bbox": [
1324
+ 174,
1325
+ 767,
1326
+ 825,
1327
+ 837
1328
+ ],
1329
+ "page_idx": 11
1330
+ },
1331
+ {
1332
+ "type": "text",
1333
+ "text": "7.3 JOINTLY VS. SEQUENTIALLY LEARNT STRUCTURE ",
1334
+ "text_level": 1,
1335
+ "bbox": [
1336
+ 174,
1337
+ 856,
1338
+ 560,
1339
+ 869
1340
+ ],
1341
+ "page_idx": 11
1342
+ },
1343
+ {
1344
+ "type": "text",
1345
+ "text": "To explore whether learning tasks sequentially results in a similar structure as learning them jointly, we visualized t-SNE (Maaten & Hinton, 2008) embeddings of the latent vectors of the LTM generator (VAE) in DGDMN after training it: (a) jointly over all tasks (Figure 13a), and (b) sequentially over tasks seen one at a time (Figure 13b) on the Digits dataset. To maintain consistency, we used the same random seed in t-SNE for both joint and sequential embeddings. ",
1346
+ "bbox": [
1347
+ 174,
1348
+ 882,
1349
+ 825,
1350
+ 924
1351
+ ],
1352
+ "page_idx": 11
1353
+ },
1354
+ {
1355
+ "type": "image",
1356
+ "img_path": "images/05b4bab32d0b9e68553bda5e373e69654589fb514fc51d925f2d5818d6e2ca9a.jpg",
1357
+ "image_caption": [
1358
+ "Figure 10: Accuracy curves for Shapes (x: tasks seen, y: classification accuracy on task). "
1359
+ ],
1360
+ "image_footnote": [],
1361
+ "bbox": [
1362
+ 183,
1363
+ 101,
1364
+ 815,
1365
+ 352
1366
+ ],
1367
+ "page_idx": 12
1368
+ },
1369
+ {
1370
+ "type": "image",
1371
+ "img_path": "images/b51f69223903dc4952bd19665dde326e9ed7cba7903da592f2e9073496931e4f.jpg",
1372
+ "image_caption": [
1373
+ "Figure 11: Accuracy curves for Hindi (x: tasks seen, y: classification accuracy on task). "
1374
+ ],
1375
+ "image_footnote": [],
1376
+ "bbox": [
1377
+ 183,
1378
+ 397,
1379
+ 815,
1380
+ 648
1381
+ ],
1382
+ "page_idx": 12
1383
+ },
1384
+ {
1385
+ "type": "text",
1386
+ "text": "",
1387
+ "bbox": [
1388
+ 173,
1389
+ 708,
1390
+ 823,
1391
+ 737
1392
+ ],
1393
+ "page_idx": 12
1394
+ },
1395
+ {
1396
+ "type": "text",
1397
+ "text": "We observe that the LTM’s latent space effectively segregates the 10 digits in both cases (joint and sequential). Though the absolute locations of the digit clusters differ in the two plots, the relative locations of digits share some similarity between both plots i.e. the neighboring digit clusters for each cluster are roughly similar. This may not be sufficient to conclude that the LTM discovers the same latent representation for the underlying shared structure of tasks in these cases and we leave a more thorough investigation to future work. ",
1398
+ "bbox": [
1399
+ 174,
1400
+ 744,
1401
+ 825,
1402
+ 827
1403
+ ],
1404
+ "page_idx": 12
1405
+ },
1406
+ {
1407
+ "type": "text",
1408
+ "text": "7.4 VISUALIZATIONS FOR THE JOINTLY AND SEQUENTIALLY LEARNT LTM ",
1409
+ "text_level": 1,
1410
+ "bbox": [
1411
+ 174,
1412
+ 853,
1413
+ 704,
1414
+ 867
1415
+ ],
1416
+ "page_idx": 12
1417
+ },
1418
+ {
1419
+ "type": "text",
1420
+ "text": "We also show visualizations of digits from the LTM when trained jointly on Digits tasks (Figure 14a) and when trained sequentially (Figure 14b). Though the digits generated from the jointly trained LTM are quite sharp, the same is not true for the sequentially trained LTM. We observe that the ",
1421
+ "bbox": [
1422
+ 176,
1423
+ 882,
1424
+ 825,
1425
+ 924
1426
+ ],
1427
+ "page_idx": 12
1428
+ },
1429
+ {
1430
+ "type": "image",
1431
+ "img_path": "images/e79a088951e726503a561fe4995d32d1972ad7a91f519bbfe083393efc4407a4.jpg",
1432
+ "image_caption": [
1433
+ "Figure 12: Forgetting curves on Shapes and Hindi dataset (x: tasks seen, y: avg classification accuracy on tasks seen). "
1434
+ ],
1435
+ "image_footnote": [],
1436
+ "bbox": [
1437
+ 238,
1438
+ 102,
1439
+ 761,
1440
+ 246
1441
+ ],
1442
+ "page_idx": 13
1443
+ },
1444
+ {
1445
+ "type": "image",
1446
+ "img_path": "images/b346b7c891174d1856f608b81586a975de69cf624acbc77171f782633274087d.jpg",
1447
+ "image_caption": [
1448
+ "Figure 13: t-SNE embedding for latent vectors of the VAE generator on Digits dataset when: (a) tasks are learnt jointly, and (b) tasks are learnt sequentially. "
1449
+ ],
1450
+ "image_footnote": [],
1451
+ "bbox": [
1452
+ 272,
1453
+ 304,
1454
+ 723,
1455
+ 473
1456
+ ],
1457
+ "page_idx": 13
1458
+ },
1459
+ {
1460
+ "type": "text",
1461
+ "text": "sequentially trained LTM produces sharp samples of the recently learnt tasks (digits 6, 7, 8 and 9), but blurred samples of previously learnt tasks, which is due to partial forgetting on these previous tasks. ",
1462
+ "bbox": [
1463
+ 174,
1464
+ 541,
1465
+ 825,
1466
+ 570
1467
+ ],
1468
+ "page_idx": 13
1469
+ },
1470
+ {
1471
+ "type": "image",
1472
+ "img_path": "images/a1824bc3921b759388c7ee5826f4e401c4ef0a1b98d34fba3c8635d2c1683845.jpg",
1473
+ "image_caption": [
1474
+ "Figure 14: Visualization of digits from LTM when trained: (a) jointly, (b) sequentially "
1475
+ ],
1476
+ "image_footnote": [],
1477
+ "bbox": [
1478
+ 225,
1479
+ 584,
1480
+ 772,
1481
+ 777
1482
+ ],
1483
+ "page_idx": 13
1484
+ },
1485
+ {
1486
+ "type": "text",
1487
+ "text": "8 APPENDIX B ",
1488
+ "text_level": 1,
1489
+ "bbox": [
1490
+ 174,
1491
+ 835,
1492
+ 312,
1493
+ 852
1494
+ ],
1495
+ "page_idx": 13
1496
+ },
1497
+ {
1498
+ "type": "text",
1499
+ "text": "8.1 DATASET PREPROCESSING ",
1500
+ "text_level": 1,
1501
+ "bbox": [
1502
+ 174,
1503
+ 868,
1504
+ 397,
1505
+ 883
1506
+ ],
1507
+ "page_idx": 13
1508
+ },
1509
+ {
1510
+ "type": "text",
1511
+ "text": "All our datasets have images with intensities normalized in the range [0.0, 1.0] and size $( 2 8 \\times 2 8 )$ , except Hindi which has $( 3 2 \\times 3 2 )$ size images. ",
1512
+ "bbox": [
1513
+ 174,
1514
+ 895,
1515
+ 825,
1516
+ 924
1517
+ ],
1518
+ "page_idx": 13
1519
+ },
1520
+ {
1521
+ "type": "text",
1522
+ "text": "Permnist: Our version involved six tasks, each containing a fixed permutation on images sampled from the original MNIST dataset. We sampled 30, 000 images from the training set and all the 10, 000 test set images for each task. The tasks were as follows: (i) Original MNIST, (ii) 8x8 central patch of each image blackened, (iii) 8x8 central patch of each image whitened, (iv) 8x8 central patch of each image permuted with a fixed random permutation, (v) 12x12 central patch of each image permuted with a fixed random permutation, and (vi) mirror images of MNIST. This way each task is as hard as MNIST and the tasks share some common underlying structure. ",
1523
+ "bbox": [
1524
+ 174,
1525
+ 103,
1526
+ 825,
1527
+ 200
1528
+ ],
1529
+ "page_idx": 14
1530
+ },
1531
+ {
1532
+ "type": "text",
1533
+ "text": "Digits: We introduce this smaller dataset which contains 10 tasks with the $t ^ { t h }$ task being classification of digit $t$ from the MNIST dataset. ",
1534
+ "bbox": [
1535
+ 173,
1536
+ 202,
1537
+ 823,
1538
+ 228
1539
+ ],
1540
+ "page_idx": 14
1541
+ },
1542
+ {
1543
+ "type": "text",
1544
+ "text": "TDigits: We introduced a transformed variant of MNIST containing all ten digits, their mirror images, their upside down images, and their images when reflected about the main diagonal making a total of 40 tasks. This dataset poses similar difficulty as the Digits dataset and we use it for experiments involving longer sequence of tasks. ",
1545
+ "bbox": [
1546
+ 174,
1547
+ 228,
1548
+ 825,
1549
+ 284
1550
+ ],
1551
+ "page_idx": 14
1552
+ },
1553
+ {
1554
+ "type": "text",
1555
+ "text": "Shapes: This dataset was extracted from the Quick, Draw! dataset recently released by Google (2017), which contains 50 million drawings across 345 categories of hand-drawn images. We subsampled 4, 500 training images and 500 test images from all geometric shapes in Quick, Draw! (namely circle, hexagon, octagon, square, triangle and zigzag). ",
1556
+ "bbox": [
1557
+ 174,
1558
+ 284,
1559
+ 825,
1560
+ 339
1561
+ ],
1562
+ "page_idx": 14
1563
+ },
1564
+ {
1565
+ "type": "text",
1566
+ "text": "Hindi: Extracted from the Devanagri dataset (Kaggle, 2017) and contains a sequence of 8 tasks, each involving image classification of a hindi language consonant. ",
1567
+ "bbox": [
1568
+ 171,
1569
+ 339,
1570
+ 823,
1571
+ 367
1572
+ ],
1573
+ "page_idx": 14
1574
+ },
1575
+ {
1576
+ "type": "text",
1577
+ "text": "8.2 TRAINING ALGORITHM AND ITS PARAMETERS ",
1578
+ "text_level": 1,
1579
+ "bbox": [
1580
+ 174,
1581
+ 386,
1582
+ 532,
1583
+ 398
1584
+ ],
1585
+ "page_idx": 14
1586
+ },
1587
+ {
1588
+ "type": "text",
1589
+ "text": "All models were trained with RMSProp (Hinton, 2012) using learning rate $= \\ 0 . 0 0 1$ , $\\rho = 0 . 9$ , $\\epsilon = 1 0 ^ { - 8 }$ and no decay. We used a batch size of 128 and all classifiers were provided 20 epochs of training when trained jointly, and 6 epochs when trained sequentially over tasks. For generative models (VAEs), we used gradient clipping in RMSProp with $\\mathtt { c l i p n o r m = 1 . 0 }$ and clipvalue $=$ 0.5, and they were always trained for 25 epochs regardless of the task or dataset involved. ",
1590
+ "bbox": [
1591
+ 174,
1592
+ 410,
1593
+ 825,
1594
+ 481
1595
+ ],
1596
+ "page_idx": 14
1597
+ },
1598
+ {
1599
+ "type": "text",
1600
+ "text": "8.3 NEURAL NETWORK ARCHITECTURES ",
1601
+ "text_level": 1,
1602
+ "bbox": [
1603
+ 176,
1604
+ 498,
1605
+ 470,
1606
+ 512
1607
+ ],
1608
+ "page_idx": 14
1609
+ },
1610
+ {
1611
+ "type": "text",
1612
+ "text": "We chose all our models by first training them jointly on all tasks in a dataset to ensure that our models had enough capacity to perform reasonably well on all tasks. But we gave preference to simpler models over very high capacity models. ",
1613
+ "bbox": [
1614
+ 176,
1615
+ 523,
1616
+ 825,
1617
+ 565
1618
+ ],
1619
+ "page_idx": 14
1620
+ },
1621
+ {
1622
+ "type": "text",
1623
+ "text": "Classifier Models: Our implementation of NN, DropNN, PPR, EWC, learner for DGR and the learner for LTM in DGDMN used a neural network with three fully-connected layers with the number of units tuned differently according to the dataset (24, 24 units for Digits, 48, 48 for Permnist and 36, 36 for TDigits). DropNN also added two dropout layers, one after each hidden layer with droput rate $= 0 . 2$ each. The classifiers (learners) for Shapes and Hindi datasets had two convolutional layers (1 $2 , 2 0 : 3 \\times 3$ kernels for Shapes and 2 $4 , 3 2 : 3 \\times 3$ kernels for Hindi) each followed by a $2 \\times 2$ max-pooling layer. The last two layers were fully-connected (16, 6 for Shapes and 144, 36 for Hindi). The hidden layers used ReLU activations, the last layer had a softmax activation, and the model was trained to minimize the cross-entropy objective function. The learners for STTMs in DGDMN were kept smaller for speed and efficiency concerns. ",
1624
+ "bbox": [
1625
+ 174,
1626
+ 573,
1627
+ 825,
1628
+ 712
1629
+ ],
1630
+ "page_idx": 14
1631
+ },
1632
+ {
1633
+ "type": "text",
1634
+ "text": "Generative models: The generators (VAE) for DGR and LTM of DGDMN employed encoders and decoders with two fully connected hidden layers each with ReLU activation for Permnist, Digits and TDigits, and convolutional variants for Shapes and Hindi. The sizes and number of units/kernels in the layers were tuned independently for each dataset with an approximate coarse grid-search. The size of the latent variable $z$ was set to 32 for Digits, 64 for Permnist, 96 for TDigits, 32 for Shapes and 48 for Hindi. The STTM generators for DGDMN were kept smaller for speed and efficiency. ",
1635
+ "bbox": [
1636
+ 174,
1637
+ 719,
1638
+ 825,
1639
+ 803
1640
+ ],
1641
+ "page_idx": 14
1642
+ },
1643
+ {
1644
+ "type": "text",
1645
+ "text": "8.4 HYPERPARAMETERS OF DGDMN ",
1646
+ "text_level": 1,
1647
+ "bbox": [
1648
+ 176,
1649
+ 820,
1650
+ 447,
1651
+ 834
1652
+ ],
1653
+ "page_idx": 14
1654
+ },
1655
+ {
1656
+ "type": "text",
1657
+ "text": "DGDMN has two new hyperparameters: (i) $\\kappa$ : minimum fraction of $N _ { m a x }$ reserved for incoming tasks, and (ii) $n _ { S T M }$ : number of STTMs (also sleep/consolidation frequency). Both these have straightforward interpretations and can be set directly without complex hyperparameter searches. ",
1658
+ "bbox": [
1659
+ 176,
1660
+ 847,
1661
+ 823,
1662
+ 888
1663
+ ],
1664
+ "page_idx": 14
1665
+ },
1666
+ {
1667
+ "type": "text",
1668
+ "text": "$\\kappa$ ensures continual incorporation of new tasks by guaranteeing them a minimum fraction of LTM samples during consolidation. Given that LTM should perform well on last $K$ tasks seen in long ",
1669
+ "bbox": [
1670
+ 174,
1671
+ 895,
1672
+ 821,
1673
+ 924
1674
+ ],
1675
+ "page_idx": 14
1676
+ },
1677
+ {
1678
+ "type": "text",
1679
+ "text": "task sequence of $T$ tasks, we observed that it is safe to assume that about $5 0 \\%$ of the LTM would be \ncrowded by the earlier $T - K$ tasks. The remaining 0.5 fraction should be distributed to the last $K$ \ntasks. So choosing this choice in secti $\\textstyle \\kappa = { \\frac { 0 . 5 } { K } }$ woith in pand as a good starting point for tuning). We made, and hence plotted the average accuracy over $K = 1 0$ $\\kappa = 0 . 0 5$ \nthe last 10 tasks as a metric. ",
1680
+ "bbox": [
1681
+ 174,
1682
+ 103,
1683
+ 825,
1684
+ 172
1685
+ ],
1686
+ "page_idx": 15
1687
+ },
1688
+ {
1689
+ "type": "text",
1690
+ "text": "$n _ { S T M }$ controls the consolidation cycle frequency. Increasing $n _ { S T M }$ gives more STTMs, less frequent consolidations and hence a learning speed advantage. But this also means that fewer samples of previous tasks would participate in consolidation (due to maximum capacity $N _ { m a x }$ of LTM), and hence more forgetting might occur. This parameter does not affect learning much till the LTM remains unsaturated (i.e. $N _ { m a x }$ capacity is unfilled by generated $^ +$ new samples) and becomes active after that. For long sequences of tasks, we found it best to keep at least $7 5 \\%$ of the total samples from previously learnt tasks to have appropriate retention. Hence, $n _ { S T M }$ can be set as approximately $\\frac { 0 . 2 5 } { \\kappa }$ in practice (as we did in section 4.3), or as a starting point for tuning. ",
1691
+ "bbox": [
1692
+ 174,
1693
+ 180,
1694
+ 825,
1695
+ 291
1696
+ ],
1697
+ "page_idx": 15
1698
+ },
1699
+ {
1700
+ "type": "text",
1701
+ "text": "8.5 ALGORITHM SPECIFIC HYPERPARAMETERS ",
1702
+ "text_level": 1,
1703
+ "bbox": [
1704
+ 174,
1705
+ 309,
1706
+ 513,
1707
+ 323
1708
+ ],
1709
+ "page_idx": 15
1710
+ },
1711
+ {
1712
+ "type": "text",
1713
+ "text": "PPR: We used a maximum memory capacity of about $3 - 6$ times the number of samples in a task for the dataset being learnt on (i.e. 18, 000 for Digits, 60, 000 for Permnist, 15, 000 for Shapes and 5, 400 for Hindi). While replaying, apart from the task samples, the remaining memory was filled with random samples and corresponding labels. ",
1714
+ "bbox": [
1715
+ 174,
1716
+ 334,
1717
+ 825,
1718
+ 390
1719
+ ],
1720
+ "page_idx": 15
1721
+ },
1722
+ {
1723
+ "type": "text",
1724
+ "text": "EWC: Most values of the coefficient of the Fisher Information Matrix based regularizer between 1 to 500 worked reasonably well for our datasets. We chose 100 for our experiments. ",
1725
+ "bbox": [
1726
+ 173,
1727
+ 397,
1728
+ 821,
1729
+ 425
1730
+ ],
1731
+ "page_idx": 15
1732
+ },
1733
+ {
1734
+ "type": "text",
1735
+ "text": "DGR and DGDMN: $N _ { m a x }$ for the DGM in DGR and for the LTM in DGDMN for Digits, Permnist, Shapes and Hindi was set as the total number of samples in the datasets (summed over all tasks) to ensure that there was enough capacity to regenerate the datasets well. For TDigits, we deliberately restricted memory capacity to see the effects of learning tasks over a long time and we kept $N _ { m a x }$ as half the total number of samples. $n _ { S T M }$ was kept at 2 for Digits, Permnist and Shapes, 5 for TDigits and 2 for Hindi. $\\kappa$ was set to be small, so that it does not come into play for Digits, Permnist, Shapes and Hindi since we already provided memories with full capacity for all samples. For TDigits, we used $\\kappa = 0 . 0 5$ which would let us incorporate roughly 10 out of the 40 tasks well. ",
1736
+ "bbox": [
1737
+ 174,
1738
+ 433,
1739
+ 825,
1740
+ 544
1741
+ ],
1742
+ "page_idx": 15
1743
+ }
1744
+ ]
parse/train/BkVsWbbAW/BkVsWbbAW_middle.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/BkVsWbbAW/BkVsWbbAW_model.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/SkxpDT4YvS/SkxpDT4YvS.md ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/SkxpDT4YvS/SkxpDT4YvS_content_list.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/SkxpDT4YvS/SkxpDT4YvS_middle.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/SkxpDT4YvS/SkxpDT4YvS_model.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/Yx1OzVU_SRi/Yx1OzVU_SRi.md ADDED
@@ -0,0 +1,421 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Predicting What You Already Know Helps: Provable Self-Supervised Learning
2
+
3
+ Jason D. Lee1, Qi Lei1, Nikunj Saunshi1, Jiacheng Zhuo2
4
+
5
+ 1 Princeton University 2 University of Texas at Austin {jasonlee@,qilei@,nsaunshi@cs}.princeton.edu, jzhuo@utexas.edu
6
+
7
+ # Abstract
8
+
9
+ Self-supervised representation learning solves auxiliary prediction tasks (known as pretext tasks) without requiring labeled data to learn useful semantic representations. These pretext tasks are created solely using the input features, such as predicting a missing image patch, recovering the color channels of an image from context, or predicting missing words in text; yet predicting this known information helps in learning representations effective for downstream prediction tasks.
10
+
11
+ We posit a mechanism exploiting the statistical connections between certain reconstruction-based pretext tasks that guarantee to learn a good representation. Formally, we quantify how the approximate independence between the components of the pretext task (conditional on the label and latent variables) allows us to learn representations that can solve the downstream task by just training a linear layer on top of the learned representation. We prove the linear layer yields small approximation error even for complex ground truth function class and will drastically reduce labeled sample complexity.
12
+
13
+ # 1 Introduction
14
+
15
+ Self-supervised learning revitalizes machine learning models in computer vision, NLP, and control problems (see reference therein [36, 38, 15, 63, 35]). Training a model with auxiliary tasks based only on input features reduces the extensive costs of data collection and semantic annotations for downstream tasks. It is also known to improve the adversarial robustness of models [29, 11, 12]. Self-supervised learning creates pseudo labels solely based on input features, and solves auxiliary prediction tasks (or pretext tasks) in a supervised manner. However, the underlying principles of self-supervised learning are mysterious since it is a-priori unclear why predicting what we already know should help. We thus raise the following question:
16
+
17
+ What conceptual connection between pretext and downstream tasks ensures good representations? What is a good way to quantify this?
18
+
19
+ As a thought experiment, consider a simple downstream task of classifying desert, forest, and sea images. A meaningful pretext task is to predict the background color of images (known as image colorization [66]). Denote $X _ { 1 } , X _ { 2 } , Y$ to be the input image, color channel, and the downstream label respectively. Given knowledge of the label $Y$ , one can possibly predict the background $X _ { 2 }$ without knowing much about $X _ { 1 }$ . In other words, $X _ { 2 }$ is approximately independent of $X _ { 1 }$ conditional on the label $Y$ . Consider another task of inpainting [48] the front of a building $\left( X _ { 2 } \right)$ from the rest $( X _ { 1 } )$ . While knowing the label “building” $( Y )$ is not sufficient for successful inpainting, adding additional latent variables $Z$ such as architectural style, location, window positions, etc. will ensure that variation in $X _ { 2 }$ given $Y , Z$ is small. We can mathematically interpret this as $X _ { 1 }$ being approximate conditionally independent of $X _ { 2 }$ given $Y , Z$ .
20
+
21
+ The main insight that we exploit in this work is that with approximate conditional independence (as in the above examples), a method that predicts $X _ { 2 }$ from $X _ { 1 }$ will inadvertently implicitly encode and learn to predict $Y$ (and $Z$ ) from $X _ { 1 }$ as an intermediate step, and then predict $X _ { 2 }$ from $Y ^ { 1 }$ . Building upon this insight, we make the following contributions.
22
+
23
+ Contributions. The goal of this paper, as in statistical learning theory, is to investigate the statistical connections between the random variables of input features (in this paper $( X _ { 1 } , X _ { 2 } ) )$ and downstream labels $Y$ , and show how specific connections can guarantee a successful learning procedure. For self-supervised learning (SSL), success is measured using the following 2 notions, 1) expressivity, i.e. does the learned representation from SSL have the ability to express the ground truth prediction function for labels $Y$ , and 2) sample complexity, i.e. can it do so with way fewer labeled samples than what would be required without SSL.
24
+
25
+ In this work, we show such guarantees for a class of reconstruction-based SSL methods under a statistical assumption of approximate conditional independence $( A C I )$ . In particular we show that under such an assumption, the learned representation from SSL will end up having the following properties, 1) it can express the ground truth label as a linear function, thus guaranteeing expressivity, and 2) will also end up being low-rank (or low-dimensional), thus guaranteeing smaller labeled sample complexity. Note that such an expressive and sample efficient (summarized as good) representation is often not a-priori available. For instance, the original input features themselves may not be able to express the ground truth function linearly, while kernel methods with a fixed kernel, while expressive, may not be sample efficient for many problems of interest. The strategy in modern machine learning is to find such a good representation as the output of a complicated neural network. The benefit of SSL, as we formally show here, is that the complicated but good representation function can be learned using just unlabeled data, so that labeled data is just needed to learn a linear function.
26
+
27
+ The reconstruction-based SSL method (differentiated from other SSL methods in Section 1.1) we consider is strongly motivated by empirical works [66, 48, 15, 25], but is a simplification that captures the essence of the problem and is amenable to a precise theoretical analysis. We consider a two-staged pipeline, where we first learn a representation function $\psi$ (e.g. output of a neural network) from input $X _ { 1 }$ and pretext target $X _ { 2 }$ using unlabeled data by minimizing $\mathbb { E } _ { ( X _ { 1 } , X _ { 2 } ) } [ \| X _ { 2 } - \psi ( X _ { 1 } ) \| ^ { 2 } ]$ In the second stage of downstream task, we learn a linear layer on top of representation $\psi$ using labeled samples $( X _ { 1 } , Y )$ , thus restricting to learning from a significantly smaller hypothesis class of ${ \mathcal { H } } _ { \psi } = \{ f : X _ { 1 } \to Y | f$ is linear in $\psi \}$ . The key non-trivial question of expressivity is now whether the ground truth predictor $f ^ { * } \equiv \bar { \mathbb { E } } [ Y | X _ { 1 } ]$ can be approximated well by this class $\mathcal { H } _ { \psi }$ , and the question of sample complexity reduces to the understanding the sample complexity of learning $\mathcal { H } _ { \psi }$ . Under appropriate statistical connections2 between input data $X _ { 1 } , X _ { 2 }$ and target $Y$ , we prove both the desired properties, expressivity and low sample complexity, for the aforementioned SSL method.
28
+
29
+ Our statistical assumption based on approximate conditional independence (ACI) helps us demonstrate how solving pretext tasks created from known information can learn useful representations. Specifically, we show that once the complicated representation function $\psi$ is learned using an abundance of unlabeled data in the SSL stage, not only is $\psi$ expressive enough, but it will also require only $\tilde { \mathcal { O } } ( k )$ labeled samples to solve a $k$ -way supervised learning task under exact conditional independence (CI). In contrast, solving the downstream task without any pretraining will require a lot of labeled data to learn the representation function from scratch. Since the strong exact conditional independence assumption will likely not be satisfied in practice, our main contribution is to derive similar risk bounds when only approximate CI (ACI) is satisfied. We quantify the notion of ACI using the norm of a certain partial covariance matrix (Definition 4.1) and our risk bound scales linearly with it. We verify this and other aspects of our main Theorem 4.2 using simulations and also find that pretext task helps when CI is approximately enforced in text domain. We further demonstrate on a real-world image dataset that a pretext task-based linear model performs at least as well as many baselines.
30
+
31
+ # 1.1 Related work
32
+
33
+ Self-supervised learning (SSL) methods in practice: There has been a flurry of self-supervised methods lately. One class of methods reconstruct images from corrupted or incomplete versions of it, like denoising auto-encoders [61], image inpainting [48], and split-brain autoencoder [67]. Pretext tasks are also created using visual common sense, including predicting rotation angle [22], relative patch position [16], recovering color channels [66], solving jigsaw puzzle games [45], and discriminating images created from distortion [17]. We refer to the above procedures as reconstruction-based SSL. Another popular paradigm is contrastive learning [13, 14]. The idea is to learn representations that bring similar data points closer while pushing randomly selected points further away [63, 39, 5] or to maximize a contrastive-based mutual information lower bound between different views [30, 46, 54]. A popular approach for text domain is based on language modeling where models like BERT and GPT create auxiliary tasks for next word predictions [15, 49]. The natural ordering or topology of data is also exploited in video-based [64, 43, 19], graph-based [65, 33] or map-based [68] SSL. For instance, the pretext task is to determine the correct temporal order for video frames as in [43].
34
+
35
+ Theory for SSL: While we theoretically study reconstruction-based SSL, prior work has different flavors of theoretical results for different kinds of SSL methods. Most relevant are the guarantees for representation learning using SSL methods on downstream tasks that just learn a linear classifier on top of the learned representations. [5] shows guarantees for representations from a contrastive learning objective: $L _ { 1 } ^ { c o n t } ( \psi ) = \mathbb { E } _ { ( X _ { 1 } , X _ { 2 } ) , X _ { 2 } ^ { \prime } } [ \log ( 1 + e ^ { - \psi ( X _ { 1 } ) ^ { \top } \psi ( X _ { 2 } ) + \psi ( X _ { 1 } ) ^ { \top } \psi ( X _ { 2 } ^ { \prime } ) } ) ]$ . Under a class conditional independence assumption, i.e. $X _ { 1 } \perp X _ { 2 } \mid Y$ , they show that representation $\psi$ that does well on contrastive objective, i.e. $L _ { 1 } ^ { c o n t } ( \psi ) \leq \epsilon$ , will have $\mathcal { O } ( \epsilon )$ linear classification loss on the average binary task involving pairs of classes $( y _ { 1 } , y _ { 2 } )$ . However, their analysis cannot handle the general case of approximate conditional independence. Recently, Tosh et al. [56] show that contrastive learning representations can linearly recover continuous functions of the underlying topic posterior under a topic modeling assumption for text. While their assumption bears similarity to ours, the assumption of independent sampling of words is strong and does not generalizable to other domains like images. Most relevant is a concurrent work [57] that shows guarantees for a contrastive learning objective that looks like $L _ { 2 } ^ { c o n t } ( \psi , \eta ) = \mathbb { E } _ { ( X _ { 1 } , X _ { 2 } ) , X _ { 2 } ^ { \prime } } \left[ \log ( 1 + e ^ { - \psi ( X _ { 1 } ) ^ { \top } \eta ( X _ { 2 } ) } ) + \log ( 1 + e ^ { \psi ( X _ { 1 } ) ^ { \top } \overline { { \eta ( X _ { 2 } ^ { ' } ) } } } ) \right] .$ , with a multi-view redundancy assumptions that is very similar to our ACI assumption. We take a closer look at their assumption in Section F.2. All the above objectives are different from the simple reconstruction-based objective we consider: $L ( \psi ) = \mathbb { E } _ { ( X _ { 1 } , X _ { 2 } ) } \left[ \lVert X _ { 2 } - \psi ( X _ { 1 } ) \rVert ^ { 2 } \right]$ . Saunshi et al. [51] show guarantees for representations learned using language modeling on sentence classification tasks. Some more recent work [58, 44, 55, 62] provide theoretical understanding on SSL respectively based on causality, mutual information, gradient-descent dynamics, and alignment/uniformity of representations, without explicit risk bounds for downstream tasks. There is a mutual information maximization view of contrastive learning, but [59] points out issues with it. Previous attempts to explain negative sampling [42] based methods use the theory of noise contrastive estimation [27, 40] to show asymptotic guarantees, without explicit connections to downstream tasks. CI is also used in sufficient dimension reduction [21, 20], while CI and redundancy assumptions on multiple views [37, 2] are used to analyze a canonical-correlation based dimension reduction algorithm and also for self-supervised learning algorithms like co-training [10]. Finally, [1, 60] provide a theoretical analysis for denoising auto-encoder.
36
+
37
+ # 1.2 Overview of results:
38
+
39
+ Section 2 introduces notation, setup, and the self-supervised learning procedure considered in this work. In Section 3, we analyze downstream sample complexity under exact CI and unlimited labeled data to highlight the key ideas. Section 4 presents our main result with relaxed conditions: under ACI with latent variables, and assuming finite samples in both pretext and downstream tasks, for various function classes, and both regression and classification tasks. Experiments verifying our theoretical findings are in Section 6. Proofs of most results are in the Appendix.
40
+
41
+ # 2 Preliminary
42
+
43
+ # 2.1 Notation
44
+
45
+ We use lower case symbols $( x )$ to denote scalar quantities, bold lower case symbols $( { \pmb x } )$ for vector values, capital letters $( X )$ for random variables, and capital and bold letters $\boldsymbol { X }$ for matrices. $P _ { X }$ denotes the probability law of random variable $X$ , and the space of square-integrable functions with probability $P$ is denoted by $L ^ { 2 } ( P )$ . We use standard $\mathcal { O }$ notation to hide universal factors and $\tilde { \mathcal { O } }$ to hide log factors. $\| \cdot \|$ stands for $\ell _ { 2 }$ -norm for vectors or Frobenius norm for matrices.
46
+
47
+ Linear conditional expectation. $\mathbb { E } ^ { L } [ Y | X ]$ denotes the prediction of $Y$ with linear regression:
48
+
49
+ $$
50
+ \mathbb { E } ^ { L } [ Y | X = x ] : = W ^ { * } x + b ^ { * } , \mathrm { ~ w h e r e ~ } W ^ { * } , b ^ { * } : = \operatorname * { a r g m i n } _ { W , b } \mathbb { E } [ \| Y - W X - b \| ^ { 2 } ] .
51
+ $$
52
+
53
+ In other words, $\mathbb { E } ^ { L } [ Y | X ]$ denotes the best linear predictor of $Y$ given $X$ . We also note that $\mathbb { E } [ Y | X ] \equiv$ arg $\begin{array} { r l } { \operatorname* { m i n } _ { f } \mathbb { E } [ \| Y - \bar { f } ( \bar { X } ) \| ^ { 2 } ] } \end{array}$ is the best predictor of $Y$ given $X$ .
54
+
55
+ (Partial) covariance matrix. For random variables $X , Y$ , we denote $\pmb { \Sigma } _ { X Y }$ to be covariance matrix of $X$ and $Y$ . For simplicity in most cases, we assume $\mathbb { E } [ X ] = 0$ and $\mathbb { E } [ Y ] = 0$ ; thus we do not distinguish $\mathbb { E } [ X Y ]$ and $\pmb { \Sigma } _ { X Y }$ . The partial covariance matrix between $X$ and $Y$ given $Z$ is:
56
+
57
+ $$
58
+ \Sigma _ { X Y | Z } : = \operatorname { c o v } \{ X - \mathbb { E } ^ { L } [ X | Z ] , Y - \mathbb { E } ^ { L } [ Y | Z ] \} \equiv \Sigma _ { X Y } - \Sigma _ { X Z } \Sigma _ { Z Z } ^ { - 1 } \Sigma _ { Z Y } ,
59
+ $$
60
+
61
+ which captures the correlation between $X$ and $Y$ setting aside the effect of $Z$ .
62
+
63
+ Sub-gaussian random vectors. $X \in \mathbb { R } ^ { d }$ is $\rho ^ { 2 }$ -sub-gaussian if for every fixed unit vector $\pmb { v } \in \mathbb { R } ^ { d }$ , the variable $v ^ { \top } X$ is $\rho ^ { 2 }$ -sub-gaussian, i.e., $\begin{array} { r } { \mathbb { E } \bigl [ e ^ { s \cdot { \pmb v } ^ { \top } ( { \pmb X } - \mathbb { E } [ { \pmb X } ] ) } \bigr ] \leq e ^ { s ^ { 2 } \rho ^ { 2 } / 2 } ( \bar { \forall } s \in \mathbb { R } ) . } \end{array}$ .
64
+
65
+ # 2.2 Setup and methodology
66
+
67
+ We denote by $X _ { 1 }$ the input variable, $X _ { 2 }$ the target random variable for the pretext task, and $Y$ the label for the downstream task, with $\bar { X _ { 1 } ^ { \ ' } } \in \mathcal { X } _ { 1 } \overset { } { \subset } \mathbb { R } ^ { d _ { 1 } } , X _ { 2 } \in \mathcal { X } _ { 2 } \subset \mathbb { R } ^ { d _ { 2 } }$ and $Y \in \mathcal { V } \subset \mathbb { R } ^ { k }$ . If $\mathcal { V }$ is finite with $| \mathcal { V } | = k$ , we assume $\mathcal { V } \subset \mathbb { R } ^ { k }$ is the one-hot encoding of the labels. $P _ { X _ { 1 } X _ { 2 } Y }$ denotes the joint distribution over $\mathcal { X } _ { 1 } \times \mathcal { X } _ { 2 } \times \mathcal { Y }$ . $P _ { X _ { 1 } Y } , P _ { X _ { 1 } }$ denote the corresponding marginal distributions. Our proposed self-supervised learning aims to fulfill the following two steps:
68
+
69
+ Step 1 (pretext task): Learn a representation $\psi ( { \pmb x } _ { 1 } )$ close to $\begin{array} { r } { \psi ^ { * } : = \arg \operatorname* { m i n } _ { g \in { \mathcal { H } } } \mathbb { E } \| X _ { 2 } - g ( X _ { 1 } ) \| ^ { 2 } } \end{array}$ , where $\mathcal { H }$ can vary for different settings that we will specify and discuss later.
70
+
71
+ Step 2 (downstream task): Perform linear regression on $Y$ with $\psi ( X _ { 1 } )$ , i.e. $f ( \pmb { x } _ { 1 } ) : = ( \pmb { W } ^ { * } ) ^ { \top } \psi ( \pmb { x } _ { 1 } )$
72
+ where $\begin{array} { r } { W ^ { * } \operatorname * { a r g m i n } _ { W } \mathbb { E } _ { X _ { 1 } , Y } [ \| Y - W ^ { \top } \psi ( X _ { 1 } ) \| ^ { 2 } ] } \end{array}$ . Namely we learn $f ( \cdot ) = \mathbb { E } ^ { L } [ Y | \psi ( \cdot ) ]$ .
73
+
74
+ We study this simplified version in the main text, where in practice, the SSL procedure may utilize an encoder-decoder structure, while the downstream task uses both $X _ { 1 }$ and $X _ { 2 }$ to predict $Y$ . We incorporate these extensions in Appendix C.3 and G.
75
+
76
+ With finite samples, performance of a learned representation $\psi$ on the downstream task depends on the following quantities that capture expressivity and sample complexity respectively:
77
+
78
+ Approximation error indicates whether $Y$ is linearly separable by the learned representation $\psi$ , thus measuring expressivity. We measure this by comparing $W \psi ( X _ { 1 } )$ to the optimal predictor $f ^ { * } : = \mathbb { E } [ Y | X _ { 1 } ^ { - } = \bar { { \mathbf { x } } } _ { 1 } ]$ . Denote $\begin{array} { r } { e _ { \mathrm { a p x } } ( \psi ) = \operatorname* { m i n } _ { W } \mathbb { \vec { E } } [ \| f ^ { * } ( \bar { X } _ { 1 } ) - W \psi ( X _ { 1 } ) \| ^ { 2 } ] } \end{array}$ . This gives a measure of how well $\psi$ can linearly predict $Y$ when given infinite samples for the task.
79
+
80
+ Estimation error measure sample complexity of $\psi$ on the downstream task and assume access to $n _ { 2 }$ i.i.d. samples $( \pmb { x } _ { 1 } ^ { ( 1 ) } , \pmb { y } ^ { ( 1 ) } ) , \idotsint _ { \ast } ( \bar { \pmb { x } _ { 1 } ^ { ( n _ { 2 } ) } } , \bar { \pmb { y } } ^ { ( n _ { 2 } ) } )$ drawn from $P _ { X _ { 1 } Y }$ . We express the $n _ { 2 }$ samples collectively as $X _ { 1 } ^ { \mathrm { d o w n } } \ \in \ \mathbb { R } ^ { n _ { 2 } \times d _ { 1 } }$ , $\boldsymbol { Y } \in \mathbb { R } ^ { n _ { 2 } \times k }$ and overload notation to say $\psi ( X _ { 1 } ^ { \mathrm { d o w n } } ) = $ $\left[ \psi ( \pmb { x } _ { 1 } ^ { ( 1 ) } ) | \psi ( \pmb { x } _ { 1 } ^ { ( 2 ) } ) \cdots | \psi ( \pmb { x } _ { 1 } ^ { ( n _ { 2 } ) } ) \right] ^ { \top } \in \mathbb { R } ^ { n _ { 2 } \times d _ { 2 } }$ . We perform linear regression on the learned representation $\psi$ and measure excess risk, that incorporates both approximation and estimation errors.
81
+
82
+ $$
83
+ \hat { W } \operatorname { a r g m i n } _ { W } \frac { 1 } { 2 n _ { 2 } } \| Y - \psi ( X _ { 1 } ) W \| _ { F } ^ { 2 } ; ~ \mathrm { E R } _ { \psi } ( \hat { W } ) : = \frac { 1 } { 2 } \mathbb { E } \| f ^ { * } ( X _ { 1 } ) - \hat { W } ^ { \top } \psi ( X _ { 1 } ) \| _ { 2 } ^ { 2 } .
84
+ $$
85
+
86
+ # 3 Guaranteed recovery with conditional independence
87
+
88
+ In this section, we focus on the case where the input $X _ { 1 }$ and pretext target $X _ { 2 }$ are conditionally independent (CI) given the downstream label $Y$ . While this is a strong assumption that is rarely satisfied in practice, it helps us understand the role of CI with clean results and builds up to our main results with ACI with latent variables in Section 4. As a warm-up, we show how CI helps when $( X _ { 1 } , X _ { 2 } , Y )$ are jointly Gaussian to give us a flavor for the results to follow in Appendix B. We then analyze it for general random variables under two settings: (a) when the function class used for $\psi$ is universal, (b) when $\psi$ is restricted to be a linear function of given features. For now we assume access to a large amount of unlabeled data so as to learn the optimal $\psi ^ { * }$ perfectly and this will be relaxed later in Section 4. The general recipe for the results is as follows:
89
+
90
+ 1. Find a closed-form expression for the optimal solution $\psi ^ { * }$ for the pretext task.
91
+ 2. Use conditional independence to show that optimal $f ^ { * }$ is linear in $\psi ^ { * }$ , i.e., $e _ { \mathrm { a p x } } ( \psi ^ { * } )$ is small.
92
+ 3. Exploit the low rank structure of $\psi ^ { * }$ to show small estimation error on downstream tasks.
93
+
94
+ Data assumption. Suppose $Y = f ^ { * } ( X _ { 1 } ) + N$ , where $f ^ { * } = \mathbb { E } [ Y | X _ { 1 } ]$ and $\mathbb { E } [ N ] = 0$ . We assume $N$ is $\sigma ^ { 2 }$ -subgaussian. For simplicity, we assume non-degeneracy: $\Sigma _ { X _ { i } X _ { i } }$ , $\Sigma _ { Y Y }$ are full rank.
95
+
96
+ Assumption 3.1. Let $X _ { 1 } \in \mathbb { R } ^ { d _ { 1 } } , X _ { 2 } \in \mathbb { R } ^ { d _ { 2 } }$ be random variables from some unknown distribution. Let label $Y \in \mathcal { D }$ be a discrete random variable with $k = \ | \mathcal { V } | \ < \ d _ { 2 }$ . We assume conditional independence: $X _ { 1 } \bot X _ { 2 } | Y$ .
97
+
98
+ Here $Y$ can be interpreted as the multi-class labels where $k$ is the number of classes. For regression problems, one can think about $Y$ as the discretized values of continuous labels. We do not specify the dimension for $Y$ since $Y$ could be arbitrarily encoded but the results only depend on $k$ and the variance of $Y$ (conditional on the input $X _ { 1 }$ ).
99
+
100
+ # 3.1 Universal function class.
101
+
102
+ Suppose we learn the optimal $\psi ^ { * }$ among all measurable functions The optimal function $\psi ^ { * }$ in this case is naturally given by conditional expectation: $\psi ^ { * } ( \pmb { x } _ { 1 } ) = \mathbb { E } [ X _ { 2 } | X _ { 1 } = \pmb { x } _ { 1 } ]$ . We show that $\mathrm { C I }$ implies that $\psi ^ { * }$ is good for downstream tasks, which is not apriori clear.
103
+
104
+ Lemma 3.1 (Approximation error). If random variables $X _ { 1 } , X _ { 2 } , Y$ satisfy Assumption 3.1, and $\pmb { A } \in \mathbb { R } ^ { \mathcal { V } \times d _ { 2 } }$ with $\pmb { A } _ { y , : } : = \mathbb { E } [ X _ { 2 } | Y = \pmb { \dot { y } } ]$ has rank $k = | \mathcal { D } |$ . Then $f ^ { * } \equiv W ^ { * } \psi ^ { * }$ , i.e., $\bar { e } _ { a p x } ( \psi ^ { * } ) = 0$ .
105
+
106
+ This tells us that although $f ^ { * }$ could be nonlinear in $\scriptstyle { \mathbf { { \vec { x } } } } _ { 1 }$ , it is guaranteed to be linear in $\psi ^ { * } ( \pmb { x } _ { 1 } )$ .
107
+
108
+ Proof Sketch of Lemma 3.1. Lemma is proved by law of total expectation:
109
+
110
+ $$
111
+ \begin{array} { r l } & { \psi ^ { * } ( \cdot ) : = \mathbb { E } [ X _ { 2 } | X _ { 1 } ] = \mathbb { E } [ \mathbb { E } [ X _ { 2 } | X _ { 1 } , Y ] | X _ { 1 } ] = \mathbb { E } [ \mathbb { E } [ X _ { 2 } | Y ] | X _ { 1 } ] } \\ & { \qquad = \displaystyle \sum _ { y } P ( Y = y | X _ { 1 } ) \mathbb { E } [ X _ { 2 } | Y = y ] = : f ( X _ { 1 } ) ^ { \top } { \pmb { A } } , } \end{array}
112
+ $$
113
+
114
+ where $f ( x _ { 1 } ) _ { y } = P ( Y = y | X _ { 1 } = x _ { 1 } )$ , and $\pmb { A } \in \mathbb { R } ^ { \mathcal { V } \times d _ { 2 } }$ satisfies $A _ { y , : } = \mathbb { E } [ X _ { 2 } | Y = y ]$ . One could see that through predicting $X _ { 2 }$ , due to the CI assumption, $\psi ^ { * }$ has implicitly encoded the information of $Y | X _ { 1 }$ . Finally due to the fact that matrix $\pmb { A }$ is full rank, we get that $f ^ { * }$ is linear in $\psi ^ { * }$ as well.
115
+
116
+ We see that besides $\mathrm { C I }$ , another important property is $\mathbb { E } [ X _ { 2 } | Y ]$ being rank $k$ . This means $X _ { 2 }$ is correlated with every instance of $Y$ , and thus captures information of every prediction class. This is naturally a necessary assumption for $X _ { 2 }$ to be a reasonable pretext task for predicting $Y$ . Note that this assumption does not trivialize the problem and that even though $\psi$ is designed to predict $X _ { 2 }$ , it can still be a better representation than $X _ { 2 }$ for downstream tasks. Note that $Y$ does not have to be linear in $X _ { 2 }$ but is proven to be linear in $\psi$ , since $\psi$ learns to ignore some information in $X _ { 2 }$ that is irrelevant to $Y$ . We provide this simple example for better understanding:
117
+
118
+ Example 3.1. Let $Y \in \{ - 1 , 1 \}$ be binary labels, and $X _ { 1 } , X _ { 2 }$ be 2−mixture Gaussian random variables with $X _ { 1 } \sim \mathcal { N } ( Y \pmb { \mu } _ { 1 } , \mathbf { I } ) , X _ { 2 } \sim \mathcal { N } ( Y \pmb { \mu } _ { 2 } , \mathbf { I } )$ . In this example, $X _ { 1 } \bot X _ { 2 } | Y$ . Although $\mathbb { E } [ Y | X _ { 2 } ]$ and $\mathbb { E } [ Y | X _ { 1 } ]$ are not linear, $\mathbb { E } [ Y | \psi ]$ is linear: $\begin{array} { r } { \psi ( \pmb { x } _ { 1 } ) = P ( Y = 1 | X _ { 1 } = \pmb { x } _ { 1 } ) \pmb { \mu } _ { 2 } - P ( Y = - 1 | X _ { 1 } = } \end{array}$ ${ \pmb x } _ { 1 } ) { \pmb \mu } _ { 2 }$ and $f ^ { * } ( { \pmb x } _ { 1 } ) = P ( Y = 1 | X _ { 1 } = { \pmb x } _ { 1 } ) - P ( Y = - 1 | X _ { 1 } = { \pmb x } _ { 1 } ) \equiv \mu _ { 2 } ^ { T } \psi ( { \pmb x } _ { 1 } ) / \| { \pmb \mu } _ { 2 } \| ^ { 2 } .$
119
+
120
+ Given that $\psi ^ { * }$ is good for downstream, we now care about the sample complexity. We will need to assume that the representation has some nice concentration properties. We make an assumption about the whitened data $\psi ^ { * } ( X _ { 1 } )$ to ignore scaling factors.
121
+
122
+ Assumption 3.2. We assume the whitened feature variable $U : = \Sigma _ { \psi } ^ { - 1 / 2 } \psi ( X _ { 1 } )$ is a $\rho ^ { 2 }$ -subgaussian random variable, where $\Sigma _ { \psi } = \mathbb { E } [ \psi ( X _ { 1 } ) \psi ( X _ { 1 } ) ^ { \top } ]$ .
123
+
124
+ We note that all bounded random variables satisfy sub-gaussian property.
125
+
126
+ Theorem 3.2 (General conditional independence). Fix a failure probability $\delta \in ( 0 , 1 )$ , under the same assumption as Lemma 3.1 and Assumption 3.2 for $\psi ^ { * }$ , if additionally $n \gg \rho ^ { 4 } ( k + \log ( 1 / \delta ) )$ , then the excess risk of the learned predictor $\pmb { x } _ { 1 } \hat { \pmb { W } } ^ { \top } \psi ^ { * } ( \pmb { x } _ { 1 } )$ on the downstream task satsifies
127
+
128
+ $$
129
+ \begin{array} { r } { \mathrm { E R } _ { \psi ^ { * } } [ \hat { W } ] \leq \tilde { \mathcal { O } } \left( \frac { k } { n _ { 2 } } \sigma ^ { 2 } \right) ^ { 3 } } \end{array}
130
+ $$
131
+
132
+ Remark 3.1. This analysis assumes we could perfectly learn $\psi ^ { * } = \mathbb { E } [ X _ { 2 } | X _ { 1 } ]$ disregarding the number of samples in the SSL phase (unlabeled data is cheap to obtain). Here by sample complexity we refer to the labeled data $( X _ { 1 } , Y )$ . We defer the effect of imprecise representation $\psi$ in Section $^ { 4 }$ .
133
+
134
+ # 3.2 Function class induced by feature maps.
135
+
136
+ Given feature map $\phi _ { 1 } : \mathcal { X } _ { 1 } \mathbb { R } ^ { D _ { 1 } }$ , we consider the function class $\mathcal { H } _ { 1 } = \{ \psi : \mathcal { X } _ { 1 } \mathbb { R } ^ { d _ { 2 } } | \exists B \in$ $\mathbb { R } ^ { d _ { 2 } \times D _ { 1 } } , \psi ( { \pmb x } _ { 1 } ) = { \pmb B } \phi _ { 1 } ( { \pmb x } _ { 1 } ) \}$ .
137
+
138
+ Claim 3.3 (Closed form solution). The optimal function in $\mathcal { H }$ is $\psi ^ { * } ( { \pmb x } _ { 1 } ) = \Sigma _ { X _ { 2 } \phi _ { 1 } } \Sigma _ { \phi _ { 1 } \phi _ { 1 } } ^ { - 1 } \phi _ { 1 } ( { \pmb x } _ { 1 } ) ,$ where and $\pmb { \Sigma } _ { \phi _ { 1 } \phi _ { 1 } } : = \pmb { \Sigma } _ { \phi _ { 1 } ( X _ { 1 } ) \phi _ { 1 } ( X _ { 1 } ) } .$ .
139
+
140
+ We again show the benefit of $\mathrm { C I }$ , but only comparing the performance of $\psi ^ { * }$ to the original features $\phi _ { 1 }$ . Since $\psi ^ { * }$ is linear in $\phi _ { 1 }$ , it cannot have smaller approximation error than $\phi _ { 1 }$ . However CI will ensure that $\psi ^ { * }$ has the same approximation error as $\phi _ { 1 }$ and enjoys better sample complexity.
141
+
142
+ Lemma 3.4 (Approximation error). If Assumption 3.1 is satisfied, and if the matrix $\pmb { A } \in \mathbb { R } ^ { \mathcal { V } \times d _ { 2 } }$ with $\pmb { A } _ { y , : } : = \mathbb { E } [ X _ { 2 } | \bar { Y } = \pmb { y } ]$ is of rank $k = | \mathcal { D } |$ . Then $e _ { a p x } ( \psi ^ { * } ) = \stackrel { \cdot } { e } _ { a p x } ( \phi _ { 1 } )$ .
143
+
144
+ We additionally need an assumption on the residual $a ( \pmb { x } _ { 1 } ) : = \mathbb { E } [ Y | X _ { 1 } = \pmb { x } _ { 1 } ] - \mathbb { E } ^ { L } [ Y | \phi _ { 1 } ( \pmb { x } _ { 1 } ) ] .$
145
+
146
+ Assumption 3.3. (Bounded approx. error; Condition $^ 3$ in $I 3 2 J )$ ) We have almost surely
147
+
148
+ $$
149
+ \| \Sigma _ { \phi _ { 1 } \phi _ { 1 } } ^ { - 1 / 2 } \phi _ { 1 } ( X _ { 1 } ) a ( X _ { 1 } ) ^ { \top } \| _ { F } \leq b _ { 0 } \sqrt { k }
150
+ $$
151
+
152
+ Theorem 3.5. (CI with approximation error) Fix a failure probability $\delta \in ( 0 , 1 )$ , under the same assumption as Lemma 3.4, Assumption 3.2 for $\psi ^ { * }$ and Assumption 3.3, if $n _ { 2 } \gg \dot { \rho } ^ { 4 } ( k + \log ( 1 / \delta ) )$ , then the excess risk of the learned predictor $\pmb { x } _ { 1 } \hat { \pmb { W } } ^ { \top } \psi ^ { * } ( \pmb { x } _ { 1 } )$ on the downstream task satisfies:
153
+
154
+ $$
155
+ \begin{array} { r } { \mathrm { E R } _ { \psi ^ { * } } [ \hat { W } ] \leq e _ { a p x } ( \phi _ { 1 } ) + \tilde { \mathcal { O } } \Big ( \frac { k } { n _ { 2 } } \sigma ^ { 2 } \Big ) . } \end{array}
156
+ $$
157
+
158
+ Thus with SSL, the requirement of labels is reduced from complexity for $D _ { 1 }$ to ${ \mathcal { O } } ( k )$ .
159
+
160
+ # 4 Beyond conditional independence
161
+
162
+ In the previous section, we focused on the case where we have exact CI. A weaker but more realistic assumption is that $Y$ captures some portion of the dependence between $X _ { 1 }$ and $X _ { 2 }$ but not all. We quantify this notion of approximate ACI through a quantity $\epsilon _ { \mathrm { C I } } ^ { 2 }$ (Definition 4.1), and show excess risk bounds for the representation learned from $\mathsf { S S L } ^ { 4 }$ . In particular, the excess risk will have the form $\begin{array} { r } { \tilde { \mathcal { O } } \left( \frac { d _ { 2 } } { n _ { 2 } } + \epsilon _ { \mathrm { C I } } ^ { 2 } + \epsilon _ { \mathrm { p r e } } ^ { 2 } \right) } \end{array}$ , which suggests that only $n _ { 2 } = \mathcal { O } ( d _ { 2 } )$ labeled samples will be required to get small error on downstream task, as long as approximate CI is satisfied $\cdot \epsilon _ { \mathrm { { C I } } } ^ { 2 }$ is small) and the pretext task is solved well enough ( $\displaystyle \langle \epsilon _ { \mathrm { p r e } } ^ { 2 }$ is small). This is in contrast to not doing SSL, where many more labeled samples will be required to learn a solve the downstream task that learns a complicated representation function from scratch. We now describe the SSL method on finite samples, followed by the definition of ACI which we use to discuss the main excess risk bound and its consequences.
163
+
164
+ SSL with finite samples and general function space: Let $X _ { 1 } ^ { \mathrm { p r e } } = [ \pmb { x } _ { 1 } ^ { ( 1 , \mathrm { p r e } ) } , \cdot \cdot \cdot , \pmb { x } _ { 1 } ^ { ( n _ { 1 } , \mathrm { p r e } ) } ] ^ { \top } \in$ $\mathbb { R } ^ { n _ { 1 } \times d _ { 1 } }$ and $\pmb { X } _ { 2 } = [ \pmb { x } _ { 2 } ^ { ( 1 ) } , \cdots , \pmb { x } _ { 2 } ^ { ( n _ { 1 } ) } ] ^ { \top } \in \mathbb { R } ^ { n _ { 1 } \times d _ { 2 } }$ x(n1)2 ]⊤ ∈ Rn1×d2 be n1 training samples for pretext task, where $( \pmb { x } _ { 1 } ^ { ( i , \mathrm { p r e } ) } , \pmb { x } _ { 2 } ^ { ( i ) } )$ is sampled from $P _ { X _ { 1 } X _ { 2 } }$ . The $n _ { 2 }$ labeled samples for the downstream task are defined as $X _ { 1 } ^ { \mathrm { d o w n } } \in \mathbb { R } ^ { n _ { 2 } \times d _ { 1 } }$ , $\pmb { Y } \in \mathbb { R } ^ { n _ { 2 } \times d _ { 3 } 5 }$ . Given a representation function space $\mathcal { H } : \mathcal { X } _ { 1 } \mathbb { R } ^ { d _ { 2 } }$ , we learn $\tilde { \psi }$ from $\mathcal { H }$ using the $n _ { 1 }$ unlabeled samples and then use the $n _ { 2 }$ labeled samples to learn a linear classifier on the learned representation $\tilde { \psi } ( X _ { 1 } ^ { \mathrm { d o w n } } )$ to fit $\mathbf { Y }$ . This process is summarized below.
165
+
166
+ $$
167
+ \tilde { \psi } : = \underset { f \in \mathcal { H } } { \mathrm { a r g } \mathrm { m i n } } \frac { 1 } { n _ { 1 } } \| X _ { 2 } - f ( X _ { 1 } ^ { \mathrm { p r e } } ) \| _ { F } ^ { 2 } , ~ 2 ) ~ \hat { W } \underset { W } { \mathrm { a r g } \mathrm { m i n } } \frac { 1 } { 2 n _ { 2 } } \| Y - \tilde { \psi } ( X _ { 1 } ^ { \mathrm { d o w n } } ) W \| _ { F } ^ { 2 } .
168
+ $$
169
+
170
+ In our main results, we consider two types of function spaces: $\mathcal { H } \in \{ \mathcal { H } _ { 1 } , \mathcal { H } _ { u } \}$ . Recall that $\mathcal { H } _ { 1 } =$ $\{ \boldsymbol { \psi } ( \cdot ) = B \phi _ { 1 } ( \cdot ) ; B \in \mathbb { R } ^ { d _ { 2 } \times D _ { 1 } } \}$ is a class of linear representations induced by feature map $\phi _ { 1 } :$ $\dot { \mathcal { X } } _ { 1 } \stackrel { } { } \mathbb { R } ^ { D _ { 1 } }$ . We use $\mathcal { H } _ { u }$ to denote a function space with universal approximation power (e.g. deep networks) that ensures $\psi ^ { * } = \mathbb { E } [ X _ { 2 } | X _ { 1 } ] \in \mathcal { \bar { H } } _ { u }$ . We define the optimal predictor in each case as $f _ { \mathcal { H } } ^ { * } ( X _ { 1 } ) = \mathbb { E } ^ { L } [ Y | \phi _ { 1 } ( X _ { 1 } ) ]$ when $\mathcal { H } = \mathcal { H } _ { 1 }$ , $f _ { \mathcal { H } } ^ { * } = f ^ { * }$ for $\mathcal { H } = \mathcal { H } _ { u }$ , we define excess risk as
171
+
172
+ $$
173
+ \begin{array} { r } { \mathrm { E R } _ { \tilde { \psi } } ( \hat { W } ) : = \mathbb { E } _ { X _ { 1 } } \left[ \| f _ { \mathcal { H } } ^ { * } ( X _ { 1 } ) - \hat { W } ^ { \top } \tilde { \psi } ( X _ { 1 } ) \| _ { 2 } ^ { 2 } \right] . } \end{array}
174
+ $$
175
+
176
+ Approximate conditional independence: Our new assumption will generalize Assumption 3.1 in two ways, 1) we allow for additional latent variables $Z$ that together with $Y$ could potentially make $X _ { 1 }$ and $X _ { 2 }$ independent, and 2) we allow this conditional independence to be approximate. Note that allowing for extra latent variable can trivially make $X _ { 1 }$ and $X _ { 2 }$ to be conditionally independent by picking a large enough $Z$ (e.g. $\boldsymbol { Z } = ( X _ { 1 } , X _ { 2 } ) ,$ ). However the following assumption, that needs the pretext target $X _ { 2 }$ to correlate with all instances of variable $\bar { Y } = [ Y , Z ]$ (analogous to Lemma 3.1), will impose this restriction on how large $Z$ can be.
177
+
178
+ Assumption 4.1 (Correlation between $X _ { 2 }$ and $Y , Z )$ . Suppose there exists latent variable $Z \in { }$ ${ \mathcal { Z } } , | { \mathcal { Z } } | = m$ that ensures $\Sigma _ { \phi _ { \bar { y } } } { \cal X } _ { 2 }$ is full column rank and $\| \Sigma _ { Y \phi _ { \bar { y } } } \Sigma _ { X _ { 2 } \phi _ { \bar { y } } } ^ { \dagger } \| _ { 2 } = 1 / \beta$ , where $A ^ { \dagger }$ is pseudo-inverse, and $\phi _ { \bar { y } }$ is the one-hot embedding for $\bar { Y } = [ Y , Z ]$ .
179
+
180
+ Just as in Section 3, this assumption will not assume away the problem (Example 3.1 can be suitably extended). The additional term $1 / \beta$ here captures both the “scale” of $X _ { 2 }$ and also the strength of correlation between $X _ { 2 }$ and $[ Y , Z ]$ that was discussed after Lemma 3.1. For $\Sigma _ { \phi _ { \bar { y } } X _ { 2 } }$ to be full column rank, it is essential that $d _ { 2 } \geq k m$ , and this already gives an upper bound on the size of $Z$ . Given this restriction on $Z$ (and thus $\bar { Y }$ ), we define the notion of approximate conditional independence.
181
+
182
+ Definition 4.1 (Approximate conditional independence with function space $\mathcal { H }$ ). For ${ \bar { Y } } = [ Y , Z ] ,$
183
+
184
+ Firstly we note that this is indeed an extension of exact $\mathrm { C I }$ , since exact CI in both cases will imply that $\epsilon _ { \mathrm { C I } } = 0$ . We present a unified analysis in the appendix that shows the $\epsilon _ { \mathrm { { C I } } }$ for the second case is same as the first case, with covariance operators instead of matrices (A direct derivation is in Claim D.7). We also present more relaxed and general form of the above assumptions in Appendix F.1. With this assumption, we are ready to present our main bound.
185
+
186
+ Bound on excess risk: Recall that we assume that the residual term $N : = Y - \mathbb { E } [ Y | X _ { 1 } ]$ is mean zero and $\sigma ^ { 2 }$ -subgaussian. Before showing our main result, analogous to Assumption 3.3, for the class $\mathcal { H } _ { 1 }$ with non-universal features $\phi _ { 1 }$ , we will need an assumption6 on the residual $a : = f ^ { \ast } - f _ { \mathcal { H } _ { 1 } } ^ { \ast } = \mathbb { E } [ Y | X _ { 1 } ] - \mathbb { E } ^ { L } [ Y | \phi _ { 1 } ( X _ { 1 } ) ]$ :
187
+
188
+ Assumption 4.2. (Bounded approximation error on pretext phase [32]) There exists a universal constant $b _ { 0 }$ , such that $\| \Sigma _ { \phi _ { 1 } \phi _ { 1 } } ^ { - 1 / 2 } \phi _ { 1 } ( X _ { 1 } ) a ( X _ { 1 } ) ^ { \top } \| _ { F } \leq b _ { 0 } \sqrt { d _ { 2 } }$ almost surely.
189
+
190
+ Theorem 4.2. For a fixed $\delta \in ( 0 , 1 )$ , under Assumptions 4.1,3.2 for $\tilde { \psi }$ and $\psi ^ { * }$ and 4.2 for nonuniversal feature maps, if $\dot { n _ { 1 } } , \dot { n _ { 2 } } \gg \rho ^ { 4 } ( d _ { 2 } + \log 1 / \delta )$ , and we learn the pretext tasks such that: $\mathbb { E } \| \tilde { \psi } ( X _ { 1 } ) - \psi ^ { * } ( X _ { 1 } ) \| _ { F } ^ { 2 } \leq \epsilon _ { p r e } ^ { 2 }$ . Then the generalization error for downstream task w.p. $1 - \delta$ is:
191
+
192
+ $$
193
+ \begin{array} { r } { \mathrm { E R } _ { \tilde { \psi } } ( \hat { W } ) \leq \tilde { \mathcal { O } } \left( \underbrace { \sigma ^ { 2 } \frac { d _ { 2 } } { n _ { 2 } } } _ { e s t i m a t i o n \ e r r o r } + \underbrace { \frac { \epsilon _ { C I } ^ { 2 } } { \beta ^ { 2 } } + \frac { \epsilon _ { p r e } ^ { 2 } } { \beta ^ { 2 } } } _ { a p p r o x i m a t i o n \ e r r o r } \right) } \end{array}
194
+ $$
195
+
196
+ We defer the proof to the appendix. The proof technique is similar to that of Section 3. The difference is that now $\tilde { \psi } ( X ^ { ( \mathrm { d o w n } ) } ) \in \mathbb { R } ^ { n _ { 2 } \times d _ { 2 } }$ will be an approximately low rank matrix, where the low rank part is the high-signal features that implicitly comes from $Y , Z$ that can linearly learn downstream task. The remaining part comes from $\epsilon _ { \mathrm { { C I } } }$ and $\epsilon _ { \mathrm { p r e } }$ and causes the approximation error. Again by selecting the top $k m$ (dimension of $\phi _ { \bar { y } }$ ) features we could further improve the bound:
197
+
198
+ Remark 4.1. By applying PCA on $\tilde { \psi } ( X _ { 1 } ^ { d o w n } )$ and keeping the top km principal components only, we can improve the bound in Theorem 4.2 to $\begin{array} { r } { \mathrm { E R } _ { \tilde { \psi } } ( \hat { W } ) \leq \tilde { \mathcal { O } } \left( \sigma ^ { 2 } \frac { k m } { n _ { 2 } } + \frac { \epsilon _ { C I } ^ { 2 } } { \beta ^ { 2 } } + \frac { \epsilon _ { p r e } ^ { 2 } } { \beta ^ { 2 } } \right) } \end{array}$ .
199
+
200
+ We take a closer look at the different sources of errors in Lemma 4.1: 1) The first term is estimation error on learning with finite samples $n _ { 2 }$ with noise level $\sigma ^ { 2 }$ in $Y - f ^ { * } ( X _ { 1 } )$ ; 2) $\epsilon _ { \mathrm { { C I } } }$ measures the approximate CI; and 3) $\epsilon _ { \mathrm { p r e } }$ is the error from not learning the pretext task exactly. The first term is optimal ignoring log factors as we do linear regression on $m k$ -dimensional features. The second and third term together form approximation error. They are non-reducible due to the fact that $f ^ { * }$ is not exactly linear in $\psi$ and we use it as a fixed representation. Fine-tuning the representations might be necessary to get rid of these terms when we have sufficient downstream labeled data. We leave this exploring this as future work. Compared to traditional supervised learning, learning $f _ { \mathcal { H } } ^ { * }$ requires sample complexity scaling with the (Rademacher/Gaussian) complexity of $\mathcal { H }$ (see e.g. [8, 52]), which is very large for complicated models such as deep networks. Thus SSL can significantly reduce the labeled sample complexity down from this complexity measure of $\mathcal { H }$ to $\tilde { \mathcal { O } } ( k m )$ , demonstrating the power of predicting what you already know using unlabeled data. In Section H, we consider a similar result for classification.
201
+
202
+ # 5 Example: Topic Modeling
203
+
204
+ In this section, we will demonstrate how our framework can be instantiated for standard data model like topic modeling. Topic modeling for text that has a rich literature [47, 31, 9, 4, 3] and is used for analyzing and designing algorithms for information retrieval, dimensionality reduction and data analysis for large text corpora. We describe the basic setup below, followed by how our results for reconstruction-based SSL can be instantiated to learn such models.
205
+
206
+ For a set $S$ , let $\Delta _ { S }$ denote the set of all distributions on $S$ . In the topic modeling framework, generation of a text document with a vocabulary set $[ V ] = \{ 1 , \dots , V \}$ is governed by certain latent topics from the set $[ k ]$ , where $k$ is the total number of topics. Each topic $i \in [ k ]$ is associated with a distribution over the vocabulary $[ V ]$ that is denoted by vector $A _ { i } \in \Delta _ { [ V ] }$ ; stack these vectors into the columns of a matrix $A \in \mathbb { R } ^ { V \times k }$ . A document $X = ( x _ { 1 } , \ldots , x _ { n } ) \in [ V ] ^ { N }$ of length $N$ is then sampled from a mixture of the $k$ topics $\mu \in \Delta _ { [ k ] }$ . The generative process is described below:
207
+
208
+ 1. Sample a topic mixture $\mu \sim \tau$ . $\tau$ is some underlying distribution over $\Delta _ { k }$ , i.e. $\tau \in \Delta _ { \Delta _ { [ k ] } }$
209
+ 2. For each $i \in [ N ]$ , sample a topic $t _ { i } \sim \mu$ and sample a word $x _ { i } \sim A _ { t _ { i } }$ from the topic
210
+
211
+ For the reconstruction SSL task, we evenly split the document as $X = ( \bar { X _ { 1 } } , \bar { X _ { 2 } } )$ , where ${ \bar { X _ { 1 } } }$ and ${ \bar { X _ { 2 } } }$ denote the first and second halves of the document; note that $\bar { X _ { 1 } } , \bar { X _ { 2 } } \in [ V ] ^ { N / 2 }$ . We let $X _ { 1 }$ and $X _ { 2 }$ be the multiset of words in the two halves by using the normalized bag-of-words representation, i.e. $\begin{array} { r } { X _ { i } = \frac { 2 } { N } \mathfrak { b a g \mathrm { - } 0 f \mathrm { - } w o r d s } ( \bar { X } _ { i } ) \in \mathbb { R } ^ { V } , \ i \in \{ 1 , 2 \} ^ { 7 } } \end{array}$ . The downstream task is chosen to be a linear function of the topic posterior distribution $\mu$ for a given document $X$ , i.e. $Y = w ^ { \top } \mathbb { E } [ \mu | X ] + N$ , where $N$ is 0 mean and $\sigma ^ { 2 }$ -subgaussian. The error of a predictor $f : [ V ] ^ { N } \to \mathbb { R }$ is measured as $\mathbb { E } _ { \mu , X } \left[ \left( f ( X ) - \mu ^ { \top } w \right) ^ { 2 } \right]$ , the optimal predictor being $f ^ { * } ( X ) = \mathbb { E } \left[ Y \mid X \right]$ .
212
+
213
+ A crucial property of topic model described above is that words in the document are sampled independently given the topic mixture $\mu$ , thus giving us the property: $X _ { 1 } \perp X _ { 2 } \mid \mu$ . Although the cardinality of $\mu \in \Delta _ { [ k ] }$ (that implicitly shows up in Theorem 4.2) is infinite, we can still show the benefit of SSL using our theoretical framework. We will show appropriate bounds for $\epsilon _ { \mathrm { { C I } } }$ and $\beta$ , that show up in Theorem 4.2, using the topic model generative process. We make the following standard assumptions about the topic modeling distribution, motivated by prior work [4, 3].
214
+
215
+ Assumption 5.1. Let $A \in \mathbb { R } ^ { V \times k }$ be the word-topic matrix and $\Gamma = \mathbb { E } _ { \mu \sim \tau } \left[ \mu \mu ^ { \top } \right]$ be the topic covariance matrix, then the following hold
216
+
217
+ • (Anchor word) The word-topic matrix $A$ is $p$ -separable for $p > 0$ , i.e. for every topic $i \in [ k ]$ there is a word $j$ such that $A _ { i } ( j ) \geq p$ and $A _ { i ^ { \prime } } ( j ) = 0$ when $i ^ { \prime } \neq i$
218
+ • Γ is full rank, so condition number $\begin{array} { r } { \kappa = \frac { \lambda _ { \operatorname* { m a x } } ( \Gamma ) } { \lambda _ { \operatorname* { m i n } } ( \Gamma ) } < \infty } \end{array}$
219
+
220
+ ![](images/ffa67961959b8edf724a37057e6e93790277393e044833c20c6286cf93881d24.jpg)
221
+ Figure 1: Left two: how MSE scales with $k$ (the dimension of $Y$ ) and $\epsilon _ { C I }$ (Definition 4.1) with the linear function class. Right two: how MSE scales with $k$ and $\epsilon$ with $\psi ^ { * }$ and non-linear function class. Mean of 30 trials are shown in solid line and one standard error is shown by shadow.
222
+
223
+ Theorem 5.1. Let $\epsilon _ { C I }$ be the definition (2) from Definition 4.1 and $\beta$ as defined in Assumption 4.1 and suppose the topic model satisfies Assumption 5.1, then there exists a latent variable $\bar { Y } \in \bar { \mathcal { V } }$ such that the following hold
224
+
225
+ 1. $\bar { Y }$ takes $k$ distinct values, i.e. $| \bar { \mathcal { V } } | = \underline { { k } }$
226
+ 2. $X _ { 1 }$ and $X _ { 1 }$ are uncorrelated given $\bar { Y }$ , which implies $\epsilon _ { C I } = \mathbf { 0 }$
227
+ 3 $ \xi [ Y | X _ { 1 } ]$ is a linear function of $\mathbb { E } [ { \bar { Y } } | X _ { 1 } ]$
228
+ 4. $\beta ^ { - 1 } \leq \kappa \| w \| _ { 2 } / \lambda _ { \operatorname* { m i n } } ( A ) \leq \kappa \| w \| _ { 2 } / p$
229
+
230
+ The proof for this is presented in Section E.1. Note that the $p$ -separability is not necessarily needed, and the bound with $\lambda _ { \mathrm { m i n } } ( A )$ can be invoked instead. Thus the upper bound from Theorem 4.2) will look like $\tilde { \mathcal { O } } \left( \sigma ^ { 2 } \frac { k } { n _ { 2 } } + \epsilon _ { \mathrm { p r e } } ^ { 2 } \frac { \kappa \| w \| _ { 2 } } { p } \right)$ , thus requiring only ${ \mathcal { O } } ( k )$ samples for the downstream task.
231
+
232
+ # 6 Experiments
233
+
234
+ In this section, we empirically verify our claim that SSL performs well when ACI is satisfied. More details for experiments can be found in Section J, including experiments in the text domain.
235
+
236
+ Simulations. With synthetic data, we verify how excess risk (ER) scales with the cardinality/feature dimension of $\mathcal { V } \left( k \right)$ , and ACI ( $\epsilon _ { C I }$ in Definition 4.1). We consider a mixture of Gaussian data and conduct experiments with both linear function space $\mathcal { H } _ { 1 }$ with $\phi _ { 1 }$ as identity map) and universal function space $\mathcal { H } _ { u }$ . We sample the label $Y$ uniformly from $\{ 1 , . . . , k \}$ . For $i$ -th class, the centers $\mu _ { 1 i } \in \mathbb { R } ^ { d _ { 1 } }$ and $\mu _ { 2 i } \in \mathbb { R } ^ { d _ { 2 } }$ are uniformly sampled from $[ 0 , 1 0 )$ . Given $Y \ = \ i$ , $\alpha \in [ 0 , 1 ]$ , let $X _ { 1 } \sim \mathcal { N } ( \mu _ { 1 i } , \mathbf { I } )$ , $\hat { X _ { 2 } } \sim \mathcal { N } ( \mu _ { 2 i } , \mathbf { I } )$ , and $X _ { 2 } = ( 1 - \alpha ) \hat { X _ { 2 } } + \alpha X _ { 1 }$ . Therefore $\alpha$ is a correlation coefficient: $\alpha = 0$ ensures $X _ { 2 }$ being CI with $X _ { 1 }$ given $Y$ and when $\alpha = 1$ , $X _ { 2 }$ fully depends on $X _ { 1 }$ . (if $d _ { 1 } \neq d _ { 2 }$ , we append zeros or truncate to fit accordingly).
237
+
238
+ We first conduct experiments with linear function class. We learn a linear representation $\psi$ with $n _ { 1 }$ samples and the linear prediction of $Y$ from $\psi$ with $n _ { 2 }$ samples. We set $d _ { 1 } = 5 0$ , $d _ { 2 } = 4 0$ , $n _ { 1 } = 4 0 0 0$ , $n _ { 2 } = 1 0 0 0$ and ER is measured with Mean Squared Error (MSE). As shown in Figure 1(a)(b), the MSE of learning with $\psi ( X _ { 1 } )$ scales linearly with $k$ as indicated in Theorem 3.5, and scales linearly with $\epsilon _ { C I }$ associated with linear function class as indicated in Theorem 4.2. Next we move on to general function class, i.e., $\psi ^ { * } = \mathbb { E } [ Y | X _ { 1 } ]$ with a closed form solution (see example 3.1). We use the same parameter settings as above. For baseline method, we use kernel linear regression to predict $Y$ using $X _ { 1 }$ (we use RBF kernel which also has universal approximation power). As shown in Figure 1(c)(d), the phenomenon is the same as what we observe in the linear function class setting, and hence they respectively verify Theorem 3.2 and Theorem 4.2 with $\mathcal { H } _ { u }$ .
239
+
240
+ Computer Vision Task. We verify if learning from $\psi$ is more effective than learning directly from $X _ { 1 }$ , in a realistic setting (without enforcing conditional independence). Specifically, we test on the Yearbook dataset [23], and try to predict the date when the portraits are taken (denoted as $Y _ { D }$ ), which ranges from 1905 to 2013. We resize all the portraits to be 128 by 128. We crop out the center 64 by 64 pixels (the face), and treat it as $X _ { 2 }$ , and treat the outer rim as $X _ { 1 }$ as shown in Figure 2. Our task is to predict $Y _ { D }$ , which is the year when the portraits are taken, and the year ranges from 1905 to 2013. For $\psi$ , we learn $X _ { 2 }$ from $X _ { 1 }$ with standard image inpainting techniques [48], and full set of training data (without labels). After that we fix the learned $\psi$ and learn a linear model to predict $Y _ { D }$ from $\psi$ using a smaller set of data (with labels). Besides linear model on $X _ { 1 }$ , another strong baseline that we compare with is using ResNet18 [28] to predict $Y _ { D }$ from $X _ { 1 }$ . With the full set of training data, this model is able to achieve a Mean Absolute Difference of 6.89, close to what state-of-the-art can achieve [23]. ResNet18 has similar amount of parameters as our generator, and hence roughly in the same function class. We show the MSE result as in Figure 2. Learning from $\psi$ is more effective than learning from $X _ { 1 }$ or $X _ { 2 }$ directly, with linear model as well as with ResNet18. Practitioner usually fine-tune $\psi$ with the downstream task, which leads to more competitive performance [48].
241
+
242
+ ![](images/fc15b124dc23b3b1ff030491ce4fcbe761c60f0a1f27e566e15aaf5163c4d265.jpg)
243
+ Figure 2: Left: Example of the $X _ { 2 }$ (in the red box of the 1st row), the $X _ { 1 }$ (out of the red box of the 1st row), the input to the inpainting task (the second row), $\psi ( X _ { 1 } )$ (the 3 row in the red box), and in this example $Y = 1 9 6 7$ . Middle: Mean Squared Error comparison of yearbook regression predicting dates. Right: Mean Absolute Error comparison of yearbook regression predicting dates. Experiments are repeated 10 times, with mean shown in solid line and one standard deviation in shadow.
244
+
245
+ # 7 Conclusion
246
+
247
+ In this work we theoretically quantify how an approximate conditional independence assumption that connects pretext and downstream task data distributions can give sample complexity benefits of self-supervised learning on downstream tasks. Our theoretical findings are also supported by experiments on simulated data and also on real CV and NLP tasks. We would like to note that approximate CI is only a sufficient condition for a useful pretext task. We leave it for future work to investigate other mechanisms by which pretext tasks help with downstream tasks.
248
+
249
+ # Acknowledgment
250
+
251
+ JDL acknowledges support of the ARO under MURI Award W911NF-11-1-0304, the Sloan Research Fellowship, NSF CCF 2002272, NSF IIS 2107304, and an ONR Young Investigator Award. QL was supported by NSF #2030859 and the Computing Research Association for the CIFellows Project. NS is supported by NSF, ONR, Simons Foundation, DARPA and SRC. JZ acknowledges sponsorship of Army Research Office and support of Cooperative Agreement Number W911NF-19-2-0333 and NSF grant 2019844. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.
252
+
253
+ # References
254
+
255
+ [1] Guillaume Alain and Yoshua Bengio. What regularized auto-encoders learn from the datagenerating distribution. The Journal of Machine Learning Research, 15(1):3563–3593, 2014.
256
+ [2] Rie Kubota Ando and Tong Zhang. Two-view feature generation model for semi-supervised learning. In Proceedings of the 24th international conference on Machine learning, pages 25–32, 2007.
257
+ [3] Sanjeev Arora, Rong Ge, Yonatan Halpern, David Mimno, Ankur Moitra, David Sontag, Yichen Wu, and Michael Zhu. A practical algorithm for topic modeling with provable guarantees. In International conference on machine learning. PMLR, 2013.
258
+
259
+ [4] Sanjeev Arora, Rong Ge, and Ankur Moitra. Learning topic models–going beyond svd. In 2012 IEEE 53rd annual symposium on foundations of computer science. IEEE, 2012.
260
+
261
+ [5] Sanjeev Arora, Hrishikesh Khandeparkar, Mikhail Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. In Proceedings of the 36th International Conference on Machine Learning, 2019.
262
+
263
+ [6] Charles R Baker. Joint measures and cross-covariance operators. Transactions of the American Mathematical Society, 186:273–289, 1973.
264
+
265
+ [7] Andrew R Barron. Universal approximation bounds for superpositions of a sigmoidal function. IEEE Transactions on Information theory, 39(3):930–945, 1993.
266
+
267
+ [8] Peter L Bartlett and Shahar Mendelson. Rademacher and gaussian complexities: Risk bounds and structural results. Journal of Machine Learning Research, 3(Nov):463–482, 2002.
268
+
269
+ [9] David M Blei, Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ , and Michael I Jordan. Latent dirichlet allocation. the Journal of machine Learning research, 2003.
270
+
271
+ [10] Avrim Blum and Tom Mitchell. Combining labeled and unlabeled data with co-training. In Proceedings of the eleventh annual conference on Computational learning theory, 1998.
272
+
273
+ [11] Yair Carmon, Aditi Raghunathan, Ludwig Schmidt, John C Duchi, and Percy S Liang. Unlabeled data improves adversarial robustness. In Advances in Neural Information Processing Systems, pages 11190–11201, 2019.
274
+
275
+ [12] Tianlong Chen, Sijia Liu, Shiyu Chang, Yu Cheng, Lisa Amini, and Zhangyang Wang. Adversarial robustness: From self-supervised pre-training to fine-tuning. arXiv preprint arXiv:2003.12862, 2020.
276
+
277
+ [13] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. arXiv preprint arXiv:2002.05709, 2020.
278
+
279
+ [14] Ting Chen, Simon Kornblith, Kevin Swersky, Mohammad Norouzi, and Geoffrey Hinton. Big self-supervised models are strong semi-supervised learners. arXiv preprint arXiv:2006.10029, 2020.
280
+
281
+ [15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
282
+
283
+ [16] Carl Doersch, Abhinav Gupta, and Alexei A Efros. Unsupervised visual representation learning by context prediction. In Proceedings of the IEEE International Conference on Computer Vision, pages 1422–1430, 2015.
284
+
285
+ [17] Alexey Dosovitskiy, Philipp Fischer, Jost Tobias Springenberg, Martin Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with exemplar convolutional neural networks. IEEE transactions on pattern analysis and machine intelligence, 38(9):1734–1747, 2015.
286
+
287
+ [18] Simon S Du, Wei Hu, Sham M Kakade, Jason D Lee, and Qi Lei. Few-shot learning via learning the representation, provably. arXiv preprint arXiv:2002.09434, 2020.
288
+
289
+ [19] Basura Fernando, Hakan Bilen, Efstratios Gavves, and Stephen Gould. Self-supervised video representation learning with odd-one-out networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 3636–3645, 2017.
290
+
291
+ [20] Kenji Fukumizu, Francis R Bach, and Michael I Jordan. Dimensionality reduction for supervised learning with reproducing kernel hilbert spaces. Journal of Machine Learning Research, 5(Jan):73–99, 2004.
292
+
293
+ [21] Kenji Fukumizu, Francis R Bach, Michael I Jordan, et al. Kernel dimension reduction in regression. The Annals of Statistics, 37(4):1871–1905, 2009.
294
+
295
+ [22] Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. arXiv preprint arXiv:1803.07728, 2018.
296
+
297
+ [23] Shiry Ginosar, Kate Rakelly, Sarah Sachs, Brian Yin, and Alexei A Efros. A century of portraits: A visual historical record of american high school yearbooks. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pages 1–7, 2015.
298
+
299
+ [24] Arthur Gretton, Olivier Bousquet, Alex Smola, and Bernhard Schölkopf. Measuring statistical dependence with hilbert-schmidt norms. In International conference on algorithmic learning theory, pages 63–77. Springer, 2005.
300
+
301
+ [25] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. arXiv preprint arXiv:2006.07733, 2020.
302
+
303
+ [26] David Gross. Recovering low-rank matrices from few coefficients in any basis. IEEE Transactions on Information Theory, 57(3):1548–1566, 2011.
304
+
305
+ [27] Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, 2010.
306
+
307
+ [28] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.
308
+
309
+ [29] Dan Hendrycks, Mantas Mazeika, Saurav Kadavath, and Dawn Song. Using self-supervised learning can improve model robustness and uncertainty. In Advances in Neural Information Processing Systems, pages 15637–15648, 2019.
310
+
311
+ [30] R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. arXiv preprint arXiv:1808.06670, 2018.
312
+
313
+ [31] Thomas Hofmann. Probabilistic latent semantic indexing. In Proceedings of the 22nd annual international ACM SIGIR conference on Research and development in information retrieval, 1999.
314
+
315
+ [32] Daniel Hsu, Sham M Kakade, and Tong Zhang. Random design analysis of ridge regression. In Conference on learning theory, pages 9–1, 2012.
316
+
317
+ [33] Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. arXiv preprint arXiv:1905.12265, 2019.
318
+
319
+ [34] Tzee-Ming Huang. Testing conditional independence using maximal nonlinear conditional correlation. The Annals of Statistics, 38(4):2047–2091, 2010.
320
+
321
+ [35] Eric Jang, Coline Devin, Vincent Vanhoucke, and Sergey Levine. Grasp2vec: Learning object representations from self-supervised grasping. arXiv preprint arXiv:1811.06964, 2018.
322
+
323
+ [36] Longlong Jing and Yingli Tian. Self-supervised visual feature learning with deep neural networks: A survey. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2020.
324
+
325
+ [37] Sham M Kakade and Dean P Foster. Multi-view regression via canonical correlation analysis. In International Conference on Computational Learning Theory, pages 82–96. Springer, 2007.
326
+
327
+ [38] Alexander Kolesnikov, Xiaohua Zhai, and Lucas Beyer. Revisiting self-supervised visual representation learning. In Proceedings of the IEEE conference on Computer Vision and Pattern Recognition, pages 1920–1929, 2019.
328
+
329
+ [39] Lajanugen Logeswaran and Honglak Lee. An efficient framework for learning sentence representations. In Proceedings of the International Conference on Learning Representations, 2018.
330
+
331
+ [40] Zhuang Ma and Michael Collins. Noise contrastive estimation and negative sampling for conditional models: Consistency and statistical efficiency. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, 2018.
332
+
333
+ [41] Charles A Micchelli, Yuesheng Xu, and Haizhang Zhang. Universal kernels. Journal of Machine Learning Research, 7(Dec):2651–2667, 2006.
334
+
335
+ [42] Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, 2013.
336
+
337
+ [43] Ishan Misra, C Lawrence Zitnick, and Martial Hebert. Shuffle and learn: unsupervised learning using temporal order verification. In European Conference on Computer Vision, pages 527–544. Springer, 2016.
338
+
339
+ [44] Jovana Mitrovic, Brian McWilliams, Jacob Walker, Lars Buesing, and Charles Blundell. Representation learning via invariant causal mechanisms. arXiv preprint arXiv:2010.07922, 2020.
340
+
341
+ [45] Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European Conference on Computer Vision, pages 69–84. Springer, 2016.
342
+
343
+ [46] Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
344
+
345
+ [47] Christos H Papadimitriou, Prabhakar Raghavan, Hisao Tamaki, and Santosh Vempala. Latent semantic indexing: A probabilistic analysis. Journal of Computer and System Sciences, 2000.
346
+
347
+ [48] Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 2536–2544, 2016.
348
+
349
+ [49] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/researchcovers/languageunsupervised/language understanding paper. pdf, 2018.
350
+
351
+ [50] Michael Reed. Methods of modern mathematical physics: Functional analysis. Elsevier, 2012.
352
+
353
+ [51] Nikunj Saunshi, Sadhika Malladi, and Sanjeev Arora. A mathematical exploration of why language models help solve downstream tasks. arXiv preprint arXiv:2010.03648, 2020.
354
+
355
+ [52] Shai Shalev-Shwartz and Shai Ben-David. Understanding machine learning: From theory to algorithms. Cambridge university press, 2014.
356
+
357
+ [53] Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Y Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, 2013.
358
+
359
+ [54] Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.
360
+
361
+ [55] Yuandong Tian, Lantao Yu, Xinlei Chen, and Surya Ganguli. Understanding self-supervised learning with dual deep networks. arXiv preprint arXiv:2010.00578, 2020.
362
+
363
+ [56] Christopher Tosh, Akshay Krishnamurthy, and Daniel Hsu. Contrastive estimation reveals topic posterior information to linear models. arXiv preprint arXiv:2003.02234, 2020.
364
+
365
+ [57] Christopher Tosh, Akshay Krishnamurthy, and Daniel Hsu. Contrastive learning, multi-view redundancy, and linear models. arXiv preprint arXiv:2008.10150, 2020.
366
+
367
+ [58] Yao-Hung Hubert Tsai, Yue Wu, Ruslan Salakhutdinov, and Louis-Philippe Morency. Demystifying self-supervised learning: An information-theoretical framework. arXiv preprint arXiv:2006.05576, 2020.
368
+
369
+ [59] Michael Tschannen, Josip Djolonga, Paul K Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. arXiv preprint arXiv:1907.13625, 2019.
370
+ [60] Pascal Vincent. A connection between score matching and denoising autoencoders. Neural computation, 23(7):1661–1674, 2011.
371
+ [61] Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pages 1096–1103, 2008.
372
+ [62] Tongzhou Wang and Phillip Isola. Understanding contrastive representation learning through alignment and uniformity on the hypersphere. arXiv preprint arXiv:2005.10242, 2020.
373
+ [63] Xiaolong Wang and Abhinav Gupta. Unsupervised learning of visual representations using videos. In Proceedings of the IEEE International Conference on Computer Vision, 2015.
374
+ [64] Donglai Wei, Joseph J Lim, Andrew Zisserman, and William T Freeman. Learning and using the arrow of time. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8052–8060, 2018.
375
+ [65] Han Yang, Xiao Yan, Xinyan Dai, and James Cheng. Self-enhanced gnn: Improving graph neural networks using model outputs. arXiv preprint arXiv:2002.07518, 2020.
376
+ [66] Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In European conference on computer vision, pages 649–666. Springer, 2016.
377
+ [67] Richard Zhang, Phillip Isola, and Alexei A Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 1058–1067, 2017.
378
+ [68] Zaiwei Zhang, Zhenxiao Liang, Lemeng Wu, Xiaowei Zhou, and Qixing Huang. Path-invariant map networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 11084–11094, 2019.
379
+
380
+ # Checklist
381
+
382
+ The checklist follows the references. Please read the checklist guidelines carefully for information on how to answer these questions. For each question, change the default [TODO] to [Yes] , [No] , or [N/A] . You are strongly encouraged to include a justification to your answer, either by referencing the appropriate section of your paper or providing a brief inline description. For example:
383
+
384
+ • Did you include the license to the code and datasets? [Yes] See Section ??.
385
+ • Did you include the license to the code and datasets? [No] The code and the data are proprietary.
386
+ • Did you include the license to the code and datasets? [N/A]
387
+
388
+ Please do not modify the questions and only use the provided macros for your answers. Note that the Checklist section does not count towards the page limit. In your paper, please delete this instructions block and only keep the Checklist section heading above along with the questions/answers below.
389
+
390
+ 1. For all authors...
391
+
392
+ (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] See Section 1, especially the contribution paragraph.
393
+ (b) Did you describe the limitations of your work? [Yes] See the Conclusion section and line 314-326.
394
+ (c) Did you discuss any potential negative societal impacts of your work? [No] This is mainly a theoretical work with simulations and should not cause much social impacts.
395
+ (d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
396
+
397
+ 2. If you are including theoretical results...
398
+
399
+ (a) Did you state the full set of assumptions of all theoretical results? [Yes] Every assumption is listed as a standalone block. Every theorem or lemma is self-contained.
400
+ (b) Did you include complete proofs of all theoretical results? [Yes] For every theorem, lemma, claim, and some technical remarks, we indicate where their proof is located in the Appendix.
401
+
402
+ 3. If you ran experiments...
403
+
404
+ (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [No] The codes will be made public after this work is accepted for publish.
405
+ (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] The details are provided in the sections 6 and J
406
+ (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] See Figure 1, Figure 5 and Figure 2.
407
+ (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] The details are provided in the Appendix
408
+
409
+ 4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
410
+
411
+ (a) If your work uses existing assets, did you cite the creators? [Yes] See Section 6.
412
+ (b) Did you mention the license of the assets? [Yes] The details are provided in the Appendix
413
+ (c) Did you include any new assets either in the supplemental material or as a URL? [N/A]
414
+ (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]
415
+ (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] All the portrait in the Yearbook dataset are in public domain. Please find the detailed discussion in Section 3 of the Yearbook dataset paper [23]
416
+
417
+ 5. If you used crowdsourcing or conducted research with human subjects...
418
+
419
+ (a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]
420
+ (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]
421
+ (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]
parse/train/Yx1OzVU_SRi/Yx1OzVU_SRi_content_list.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/Yx1OzVU_SRi/Yx1OzVU_SRi_middle.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/Yx1OzVU_SRi/Yx1OzVU_SRi_model.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/rJg76kStwH/rJg76kStwH.md ADDED
@@ -0,0 +1,484 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # EFFICIENT PROBABILISTIC LOGIC REASONING WITH GRAPH NEURAL NETWORKS
2
+
3
+ Yuyu Zhang1, Xinshi Chen1, Yuan Yang1, Arun Ramamurthy2, Bo $\mathbf { L i ^ { 3 } }$ , Yuan $\mathbf { Q } \mathbf { i } ^ { 4 }$ & Le Song1,4 1Georgia Institute of Technology 2Siemens Corporate Technology 3University of Illinois at Urbana Champaign 4Ant Financial {yuyu,xinshi.chen,yyang754}@gatech.edu arun.ramamurthy@siemens.com,lbo@illinois.edu yuan.qi@antfin.com,lsong@cc.gatech.edu
4
+
5
+ # ABSTRACT
6
+
7
+ Markov Logic Networks (MLNs), which elegantly combine logic rules and probabilistic graphical models, can be used to address many knowledge graph problems. However, inference in MLN is computationally intensive, making the industrialscale application of MLN very difficult. In recent years, graph neural networks (GNNs) have emerged as efficient and effective tools for large-scale graph problems. Nevertheless, GNNs do not explicitly incorporate prior logic rules into the models, and may require many labeled examples for a target task. In this paper, we explore the combination of MLNs and GNNs, and use graph neural networks for variational inference in MLN. We propose a GNN variant, named ExpressGNN, which strikes a nice balance between the representation power and the simplicity of the model. Our extensive experiments on several benchmark datasets demonstrate that ExpressGNN leads to effective and efficient probabilistic logic reasoning.
8
+
9
+ # 1 INTRODUCTION
10
+
11
+ Knowledge graphs collect and organize relations and attributes about entities, which are playing an increasingly important role in many applications, including question answering and information retrieval. Since knowledge graphs may contain incorrect, incomplete or duplicated records, additional processing such as link prediction, attribute classification, and record de-duplication is typically needed to improve the quality of knowledge graphs and derive new facts.
12
+
13
+ Markov Logic Networks (MLNs) were proposed to combine hard logic rules and probabilistic graphical models, which can be applied to various tasks on knowledge graphs (Richardson & Domingos, 2006). The logic rules incorporate prior knowledge and allow MLNs to generalize in tasks with small amount of labeled data, while the graphical model formalism provides a principled framework for dealing with uncertainty in data. However, inference in MLN is computationally intensive, typically exponential in the number of entities, limiting the real-world application of MLN. Also, logic rules can only cover a small part of the possible combinations of knowledge graph relations, hence limiting the application of models that are purely based on logic rules.
14
+
15
+ Graph neural networks (GNNs) have recently gained increasing popularity for addressing many graph related problems effectively (Dai et al., 2016; Li et al., 2016; Kipf & Welling, 2017; Schlichtkrull et al., 2018). GNN-based methods typically require sufficient labeled instances on specific end tasks to achieve good performance, however, knowledge graphs have the long-tail nature (Xiong et al., 2018), i.e., a large portion the relations in only are a few triples. Such data scarcity problem among long-tail relations poses tough challenge for purely data-driven methods.
16
+
17
+ In this paper, we explore the combination of the best of both worlds, aiming for a method which is data-driven yet can still exploit the prior knowledge encoded in logic rules. To this end, we design a simple variant of graph neural networks, named ExpressGNN, which can be efficiently trained in the variational EM framework for MLN. An overview of our method is illustrated in Fig. 1. ExpressGNN and the corresponding reasoning framework lead to the following desiderata:
18
+
19
+ ![](images/b1fe856d6eb7af432dd3d4763516c66543772bc7c9be9bba41a3f743fd733c4e.jpg)
20
+ Figure 1: Overview of our method for combining MLN and GNN using the variational EM framework.
21
+
22
+ • Efficient inference and learning: ExpressGNN can be viewed as the inference network for MLN, which scales up MLN inference to much larger knowledge graph problems.
23
+ • Combining logic rules and data supervision: ExpressGNN can leverage the prior knowledge encoded in logic rules, as well as the supervision from graph structured data.
24
+ Compact and expressive model: ExpressGNN may have small number of parameters, yet it is sufficient to represent mean-field distributions in MLN.
25
+ • Capability of zero-shot learning: ExpressGNN can deal with the zero-shot learning problem where the target predicate has few or zero labeled instances.
26
+
27
+ # 2 RELATED WORK
28
+
29
+ Statistical relational learning. There is an extensive literature relating the topic of logic reasoning. Here we only focus on the approaches that are most relevant to statistical relational learning on knowledge graphs. Logic rules can compactly encode the domain knowledge and complex dependencies. Thus, hard logic rules are widely used for reasoning in earlier attempts, such as expert systems (Ignizio, 1991) and inductive logic programming (Muggleton & De Raedt, 1994). However, hard logic is very brittle and has difficulty in coping with uncertainty in both the logic rules and the facts in knowledge graphs. Later studies have explored to introduce probabilistic graphical model in logic reasoning, seeking to combine the advantages of relational and probabilistic approaches. Representative works including Relational Markov Networks (RMNs; Taskar et al. (2007)) and Markov Logic Networks (MLNs; Richardson & Domingos (2006)) were proposed in this background.
30
+
31
+ Markov Logic Networks. MLNs have been widely studied due to the principled probabilistic model and effectiveness in a variety of reasoning tasks, including entity resolution (Singla & Domingos, 2006a), social networks (Zhang et al., 2014), information extraction (Poon & Domingos, 2007), etc. MLNs elegantly handle the noise in both logic rules and knowledge graphs. However, the inference and learning in MLNs is computationally expensive due to the exponential cost of constructing the ground Markov network and the NP-complete optimization problem. This hinders MLNs to be applied to industry-scale applications. Many works appear in the literature to improve the original MLNs in both accuracy (Singla & Domingos, 2005; Mihalkova & Mooney, 2007) and efficiency (Singla & Domingos, 2006b; 2008; Poon & Domingos, 2006; Khot et al., 2011; Bach et al., 2015). Nevertheless, to date, MLNs still struggle to handle large-scale knowledge bases in practice. Our framework ExpressGNN overcomes the scalability challenge of MLNs by efficient stochastic training algorithm and compact posterior parameterization with graph neural networks.
32
+
33
+ Graph neural networks. Graph neural networks (GNNs; Dai et al. (2016); Kipf & Welling (2017)) can learn effective representations of nodes by encoding local graph structures and node attributes. Due to the compactness of model and the capability of inductive learning, GNNs are widely used in modeling relational data (Schlichtkrull et al., 2018; Battaglia et al., 2018). Recently, Qu et al. (2019) proposed Graph Markov Neural Networks (GMNNs), which employs GNNs together with conditional random fields to learn object representations. These existing works are simply data-driven, and not able to leverage the domain knowledge or human prior encoded in logic rules. To the best of our knowledge, ExpressGNN is the first work that connects GNNs with first-order logic rules to combine the advantages of both worlds.
34
+
35
+ Knowledge graph embedding. Another line of research for knowledge graph reasoning is in the family of knowledge graph embedding methods, such as TransE (Bordes et al., 2013), NTN (Socher et al., 2013), DistMult (Kadlec et al., 2017), ComplEx (Trouillon et al., 2016), and RotatE (Sun et al., 2019). These methods design various scoring functions to model relational patterns for knowledge graph reasoning, which are very effective in learning the transductive embeddings of both entities and relations. However, these methods are not able to leverage logic rules, which can be crucial in some relational learning tasks, and have no consistent probabilistic model. Compared to these methods, ExpressGNN has consistent probabilistic model built in the framework, and can incorporate knowledge from logic rules. A recent concurrent work Qu & Tang (2019) has proposed probabilistic Logic Neural Network (pLogicNet), which integrates knowledge graph embedding methods with MLNs with EM framework. Compared to pLogicNet which uses a flattened embedding table as the entity representation, our work explicitly captures the structure knowledge encoded in the knowledge graph with GNNs and supplement the knowledge from logic formulae for the prediction task.
36
+
37
+ # 3 PRELIMINARY
38
+
39
+ Knowledge Graph. A knowledge graph is a tuple $\boldsymbol { \mathcal { K } } = ( \mathcal { C } , \mathcal { R } , \mathcal { O } )$ consisting of a set $\mathcal { C } = \{ c _ { 1 } , \ldots , c _ { M } \}$ of $M$ entities, a set $\mathcal { R } =$ $\{ r _ { 1 } , \hdots , r _ { N } \}$ of $N$ relations, and a collection $\mathcal { O } = \{ o _ { 1 } , \ldots , o _ { L } \}$ of $L$ observed facts. In the language of first-order logic, entities are also called constants. For instance, a constant can be a person or an object. Relations are also called predicates. Each predicate is a logic function defined over $\mathcal { C }$ , i.e., $r ( \cdot ) : \mathcal { C } \times \ldots \times \mathcal { C } \mapsto \{ 0 , 1 \}$ . In general, the arguments of predicates are asymmetric. For instance, for the predicate $r ( c , c ^ { \prime } ) : = \mathtt { L } ( c , c ^ { \prime } )$ (L for Like) which checks whether $c$ likes $c ^ { \prime }$ , the arguments $c$ and $c ^ { \prime }$ are not exchangeable.
40
+
41
+ With a particular set of entities assigned to the arguments, the predicate is called a ground predicate, and each ground predicate $\mathbf { \equiv } \mathbf { a }$ binary random variable, which will be used to define MLN. For a $d$ -ary predicate, there are $M ^ { d }$ ways to ground it. We denote an assignment as $a _ { r }$ . For instance, with $\boldsymbol { a } _ { r } = ( \boldsymbol { c } , \boldsymbol { c } ^ { \prime } )$ , we can simply write a ground predicate $r ( c , c ^ { \prime } )$ as $r ( a _ { r } )$ . Each observed fact in knowledge bases is a truth value $\{ 0 , 1 \}$ assigned to a ground predicate. For instance, a fact $o$ can be $[ \mathrm { L } ( c , c ^ { \prime } ) = 1 ]$ . The number of observed facts is typically much smaller than that of unobserved facts. We adopt the open-world paradigm and treat these unobserved facts $\equiv$ latent variables.
42
+
43
+ ![](images/0c75f978119c71edd39cf5851c09e12989c71d9e690d3b5ffd8101c589eeb71a.jpg)
44
+ Figure 2: Bottom: A knowledge base as a factor graph. $\{ A , C , D \}$ are entities, and F (Friend) and S (Smoke) are predicates. Top: Markov Logic Network (MLN) with formula $f ( c , c ^ { \prime } ) : = \lnot \mathrm { s } ( c ) \lor$ $\neg \mathrm { { E } } ( c , c ^ { \prime } )$ ∨ $\mathrm { \Sigma } \mathrm { S } ( c ^ { \prime } )$ . Shaded circles correspond to latent variables.
45
+
46
+ As a clearer representation, we express a knowledge base $\kappa$ by a bipartite graph $\mathcal { G } _ { K } = ( \mathcal { C } , \mathcal { O } , \mathcal { E } )$ , where nodes on one side of the graph correspond to constants $\mathcal { C }$ and nodes on the other side correspond to observed facts $\mathcal { O }$ , which is called factor in this case. The set of $T$ edges, $\mathcal { E } = \{ e _ { 1 } , \ldots , e _ { T } \}$ , connect constants and the observed facts. More specifically, an edge $e = ( c , o , i )$ between node $c$ and $o$ exists, if the ground predicate associated with $o$ uses $c$ as an argument in its $i$ -th argument position (Fig. 2).
47
+
48
+ Markov Logic Networks. MLNs use logic formulae to define potential functions in undirected graphical models. A logic formula $f ( \cdot ) : \mathcal { C } \times \ldots \times \mathcal { C } \mapsto \{ 0 , 1 \}$ is a binary function defined via the composition of a few predicates. For instance, a logic formula $\bar { \boldsymbol { f } } ( \boldsymbol { c } , \boldsymbol { c } ^ { \prime } )$ can be
49
+
50
+ $\mathtt { S m o k e } ( c ) \wedge \mathtt { F r i d e n d } ( c , c ^ { \prime } ) \Rightarrow \mathtt { S m o k e } ( c ^ { \prime } ) \iff \neg \mathtt { S m o k e } ( c ) \vee \neg \mathtt { F r i d e n d } ( c , c ^ { \prime } ) \vee \mathtt { S m o k e } ( c ^ { \prime } ) ,$ where $\neg$ is negation and the equivalence is established by De Morgan’s law. Similar to predicates, we denote an assignment of constants to the arguments of a formula $f$ as $a _ { f }$ , and the entire collection of consistent assignments of constants as $\mathcal { A } _ { f } = \{ a _ { f } ^ { 1 } , a _ { f } ^ { 2 } , . . . \}$ . A formula with constants assigned to all of its arguments is called a ground formula. Given these logic representations, MLN can be defined as a joint distribution over all observed facts $\mathcal { O }$ and unobserved facts $\mathcal { H }$ as
51
+
52
+ $$
53
+ \begin{array} { r } { P _ { w } \left( \boldsymbol { \mathcal { O } } , \mathcal { H } \right) : = \frac { 1 } { Z ( w ) } \exp \bigg ( \sum _ { f \in \mathcal { F } } w _ { f } \sum _ { a _ { f } \in \mathcal { A } _ { f } } \phi _ { f } \big ( a _ { f } \big ) \bigg ) , } \end{array}
54
+ $$
55
+
56
+ where $Z ( w )$ is the partition function summing over all ground predicates and $\phi _ { f } ( \cdot )$ is the potential function defined by a formula $f$ as illustrated in Fig. 2. One form of $\phi _ { f } ( \cdot )$ can simply be the truth value of the logic formula $f$ . For instance, if the formula is $f ( c , c ^ { \prime } ) : = \neg { \mathrm { S } } ( c ) \lor \neg \mathrm { F } ( c , c ^ { \prime } ) \lor \mathrm { S } ( c ^ { \prime } )$ , then $\phi _ { f } ( c , c ^ { \prime } )$ can simply take value 1 when $f ( c , c ^ { \prime } )$ is true and 0 otherwise. Other more sophisticated $\phi _ { f }$ can also be designed, which have the potential to take into account complex entities, such as images or texts, but will not be the focus of this paper. The weight $w _ { f }$ can be viewed as the confidence score of the formula $f$ : the higher the weight, the more accurate the formula is.
57
+
58
+ Difference between KG and MLN. We note that the graph topology of knowledge graphs and MLN can are very different, although MLN is defined on top of knowledge graphs. Knowledge graphs are typically very sparse, where the number of edges (observed relations) is typically linear in the number of entities. However, the graphs associated with MLN are much denser, where the number of nodes can be quadratic or more in the number of entities, and the number of edges (dependency between variables) is also high-order polynomials in the number of entities.
59
+
60
+ # 4 VARIATIONAL EM FOR MARKOV LOGIC NETWORKS
61
+
62
+ In this section, we introduce the variational EM framework for MLN inference and learning, where we will use ExpressGNN as a key component (detailed in Sec. 5). Markov Logic Networks model the joint probabilistic distribution of all observed and latent variables, as defined in Eq. 1. This model can be trained by maximizing the log-likelihood of all the observed facts $\log { P _ { w } ( \mathcal { O } ) }$ . However, it is intractable to directly maximize the objective, since it requires to compute the partition function $Z ( w )$ and integrate over all variables $\mathcal { O }$ and $\mathcal { H }$ . We instead optimize the variational evidence lower bound (ELBO) of the data log-likelihood, as follows
63
+
64
+ $$
65
+ \begin{array} { r } { \log P _ { w } \left( \mathcal { O } \right) \geqslant \mathcal { L } _ { \mathtt { E L B O } } \big ( Q _ { \theta } , P _ { w } \big ) : = \mathbb { E } _ { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) } \Big [ \log P _ { w } \left( \mathcal { O } , \mathcal { H } \right) \Big ] - \mathbb { E } _ { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) } \Big [ \log Q _ { \theta } \left( \mathcal { H } | \mathcal { O } \right) \Big ] , } \end{array}
66
+ $$
67
+
68
+ where $Q _ { \theta } \left( \mathcal { H } \mid \mathcal { O } \right)$ is a variational posterior distribution of the latent variables given the observed ones. The equality in Eq. 2 holds if the variational posterior $Q _ { \boldsymbol { \theta } } \left( \mathcal { H } | \mathcal { O } \right)$ equals to the true posterior $P _ { w } \left( \mathcal { H } | \mathcal { O } \right)$ . We then use the variational EM algorithm (Ghahramani et al., 2000) to effectively optimize the ELBO. The variational EM algorithm consists of an expectation step (E-step) and a maximization step (M-step), which will be called in an alternating fashion to train the model: 1) In the E-step (Sec. 4.1), we infer the posterior distribution of the latent variables, where $P _ { w }$ is fixed and $Q _ { \theta }$ is optimized to minimize the KL divergence between $Q _ { \boldsymbol { \theta } } \left( \mathcal { H } | \mathcal { O } \right)$ and $P _ { w } \left( \mathcal { H } | \mathcal { O } \right)$ ; 2) In the M-step (Sec. 4.2), we learn the weights of the logic formulae in MLN, where $Q _ { \theta }$ is fixed and $P _ { w }$ is optimized to maximize the data log-likelihood.
69
+
70
+ # 4.1 E-STEP: INFERENCE
71
+
72
+ In the E-step, which is also known as the inference step, we are minimizing the KL divergence between the variational posterior distribution $Q _ { \boldsymbol { \theta } } \left( \mathcal { H } | \mathcal { O } \right)$ and the true posterior distribution $P _ { w } \left( \mathcal { H } | \mathcal { O } \right)$ . The exact inference of MLN is computationally intractable and proven to be NP-complete (Richardson & Domingos, 2006). Therefore, we choose to approximate the true posterior with a mean-field distribution, since the mean-field approximation has been demonstrated to scale up large graphical models, such as latent Dirichlet allocation for modeling topics from large text corpus (Hoffman et al., 2013). In the mean-field variational distribution, each unobserved ground predicate $r ( a _ { r } ) \in \mathcal { H }$ is independently inferred as follows:
73
+
74
+ $$
75
+ \begin{array} { r } { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) : = \prod _ { r ( a _ { r } ) \in \mathcal { H } } Q _ { \theta } ( r ( a _ { r } ) ) , } \end{array}
76
+ $$
77
+
78
+ where each factorized distribution $Q _ { \theta } ( r ( a _ { r } ) )$ follows the Bernoulli distribution. We parameterize the variational posterior $Q _ { \theta }$ with deep learning models as our neural inference network. The design of the inference network is very important and has a lot of considerations, since we need a compact yet expressive model to accurately approximate the true posterior distribution. We employ graph neural networks with tunable embeddings as our inference network (detailed in Sec. 5), which can trade-off between the model compactness and expressiveness.
79
+
80
+ With the mean-field approximation, $\mathcal { L } _ { \mathrm { E L B O } } ( Q _ { \theta } , P _ { w } )$ defined in Eq. 2 can be reorganized as below:
81
+
82
+ $$
83
+ \Big ( \sum _ { f \in \mathcal { F } } w _ { f } \sum _ { a _ { f } \in A _ { f } } \mathbb { E } _ { Q _ { \theta } ( \# | \mathcal { O } ) } \Big [ \phi _ { f } ( a _ { f } ) \Big ] - \log Z ( w ) \Big ) - \Big ( \sum _ { r ( a _ { r } ) \in \mathcal { H } } \mathbb { E } _ { Q _ { \theta } ( r ( a _ { r } ) ) } \Big [ \log Q _ { \theta } ( r ( a _ { r } ) ) \Big ] \Big ] \Big ) ,
84
+ $$
85
+
86
+ where $w _ { f }$ is fixed in the $\mathrm { E }$ -step and thus the partition function $Z ( w )$ can be treated as a constant. We notice that the first term $\mathbb { E } _ { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) } [ \log P _ { w } \left( \mathcal { O } , \mathcal { H } \right) ]$ has the summation over all formulae and all possible assignments to each formula. Thus this double summation may involve a large number of terms. The second term $\mathbb { E } _ { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) } [ \log Q _ { \theta } \left( \mathcal { H } | \mathcal { O } \right) ]$ is the sum of entropy of the variational posterior distributions $Q _ { \theta } ( r ( a _ { r } ) )$ , which also involves a large number of terms since the summation ranges over all possible latent variables. Typically, the number of latent facts in database is much larger than the number of observed facts. Thus, both terms in the objective function pose the challenge of intractable computational cost.
87
+
88
+ To address this challenge, we sample mini-batches of ground formulae to break down the exponential summations by approximating it with a sequence of summations with a controllable number of terms. More specifically, in each optimization iteration, we first sample a batch of ground formulae. For each ground formula in the sampled batch, we compute the first term in Eq. 4 by taking the expectation of the corresponding potential function with respect to the posterior of the involved latent variables. The mean-field approximation enables us to decompose the global expectation over the entire MLN into local expectations over ground formulae. Similarly, for the second term in Eq. 4, we use the posterior of the latent variables in the sampled batch to compute a local sum of entropy.
89
+
90
+ For tasks that have sufficient labeled data as supervision, we can add a supervised learning objective to enhance the inference network, as follows:
91
+
92
+ $$
93
+ \begin{array} { r } { { \mathcal { L } } _ { \mathrm { l a b e l } } ( Q _ { \theta } ) = \sum _ { r ( a _ { r } ) \in { \mathcal { O } } } \log Q _ { \theta } ( r ( a _ { r } ) ) . } \end{array}
94
+ $$
95
+
96
+ This objective is complementary to the ELBO on predicates that are not well covered by logic rules but have sufficient observed facts. Therefore, the overall E-step objective function becomes:
97
+
98
+ $$
99
+ \begin{array} { r } { \mathcal { L } _ { \theta } = \mathcal { L } _ { \mathrm { E L B O } } ( Q _ { \theta } , P _ { w } ) + \lambda \mathcal { L } _ { \mathrm { l a b e l } } ( Q _ { \theta } ) , } \end{array}
100
+ $$
101
+
102
+ where $\lambda$ is a hyperparameter to control the weight. This overall objective essentially combines the knowledge in logic rules and the supervision from labeled data.
103
+
104
+ # 4.2 M-STEP: LEARNING
105
+
106
+ In the M-step, which is also known as the learning step, we are learning the weights of logic formulae in Markov Logic Networks with the variational posterior $Q _ { \boldsymbol { \theta } } \left( \mathcal { H } | \mathcal { O } \right)$ fixed. The partition function $Z ( w )$ in Eq. 4 is not a constant anymore, since we need to optimize those weights in the M-step. There are exponential number of terms in the partition function $Z ( w )$ , which makes it intractable to directly optimize the ELBO. To tackle this problem, we adopt the widely used pseudo-log-likelihood (Richardson & Domingos, 2006) as an alternative objective for optimization, which is defined as:
107
+
108
+ $$
109
+ \begin{array} { r } { P _ { w } ^ { * } ( \mathcal { O } , \mathcal { H } ) : = \mathbb { E } _ { Q _ { \theta } ( \mathcal { H } | \mathcal { O } ) } \left[ \sum _ { r ( a _ { r } ) \in \mathcal { H } } \log P _ { w } ( r ( a _ { r } ) \mid \mathbf { M } \mathbf { B } _ { r ( a _ { r } ) } ) \right] , } \end{array}
110
+ $$
111
+
112
+ where $\mathrm { M B } _ { r ( a _ { r } ) }$ is the Markov blanket of the ground predicate $r ( a _ { r } )$ , i.e., the set of ground predicates that appear in some grounding of a formula with $r ( a _ { r } )$ . For each formula $i$ that connects $r ( a _ { r } )$ to its Markov blanket, we optimize the formula weight $w _ { i }$ by gradient descent, with the derivative:
113
+
114
+ $$
115
+ \nabla _ { w _ { i } } \mathbb { E } _ { Q _ { \theta } } [ \log P _ { w } ( r ( a _ { r } ) \mid \mathbf { M B } _ { r ( a _ { r } ) } ) ] \simeq y _ { r ( a _ { r } ) } - P _ { w } ( r ( a _ { r } ) \mid \mathbf { M B } _ { r ( a _ { r } ) } ) ,
116
+ $$
117
+
118
+ where $y _ { r ( a _ { r } ) } = 0$ or 1 if $r ( a _ { r } )$ is an observed fact, and $y _ { r ( a _ { r } ) } = Q _ { \theta } ( r ( a _ { r } ) )$ otherwise. With the independence property of Markov Logic Networks, the gradients of the logic formulae weights can be efficiently computed on the Markov blanket of each variable.
119
+
120
+ For the M-step, we design a different sampling scheme to make it computationally efficient. For each variable in the Markov blanket, we take the truth value if it’s observed and draw a sample from the variational posterior $Q _ { \theta }$ if it’s latent. In the M-step, the ELBO of a fully observed ground formula depends on the formula weight, thus we need to consider all the fully observed ground formulae. It is computationally intractable to use all possible ground predicates to compute the gradients in Eq. 8. To tackle this challenge, we simply consider all the ground formulae with at most one latent predicate, and pick up the ground predicate if its truth value determines the formula’s truth value. Therefore, we keep a small subset of ground predicates, each of which can directly determine the truth value of a ground formula. Intuitively, this small subset contains all representative ground predicates, and makes good estimation of the gradients with much cheaper computational cost.
121
+
122
+ # 5 INFERENCE NETWORK DESIGN: EXPRESSGNN
123
+
124
+ In the neural variational EM framework, the key component is the posterior model, or the inference network. We need to design the inference network that is both expressive and efficient to approximate the true posterior distribution. A recent concurrent work Qu & Tang (2019) uses a flattened embedding table as the entity representation to model the posterior. However, such simple posterior model is not able to capture the structure knowledge encoded in the knowledge graph. We employ graph neural networks with tunable embeddings to design our inference network. We also investigate the expressive power of GNN from theoretical perspective, which justifies our design.
125
+
126
+ Our inference network, named ExpressGNN, consists of three parts: the first part is a vanilla graph neural network (GNN), the second part uses tunable embeddings, and the third part uses the embeddings to define the variational posterior. For simplicity, we assume that each predicate has two arguments (i.e., consider only $r ( c , c ^ { \prime } ) _ { , } ^ { , }$ ). We design each part as follows:
127
+
128
+ • We build a GNN on the knowledge graph $\mathcal { G } _ { K }$ , which is much smaller than the ground graph of MLN (see comparison in Fig. 2). The computational graph of the GNN is given in Algorithm 1. The GNN parameters $\pmb { \theta } _ { 1 }$ and $\pmb { \theta } _ { 2 }$ are shared across the entire graph and independent of the number of entities. Therefore, the GNN is a compact model with $O ( d ^ { 2 } )$ parameters given $d$ dimensional embeddings, $\mu _ { c } \in \mathbb { R } ^ { d }$ .
129
+ • For each entity in the knowledge graph, we augment its GNN embedding with a tunable embedding $\boldsymbol { \omega } _ { c } \in \mathbb { R } ^ { k }$ as $\hat { \mu } _ { c } = [ \mu _ { c } , \omega _ { c } ]$ . The tunable embeddings increase the expressiveness of the model. As there are $M$ entities, the number of parameters in tunable embeddings is $O ( k M )$ .
130
+ • We use the augmented embeddings of $c _ { 1 }$ and $c _ { 2 }$ to define the variational posterior. Specifically, $Q _ { \theta } ( r ( c _ { 1 } , c _ { 2 } ) ) \stackrel { - } { = } \sigma ( \mathtt { M L P } _ { 3 } ( \hat { \mu } _ { c _ { 1 } } , \hat { \mu } _ { c _ { 2 } } , r ; \pmb { \theta } _ { 3 } ) )$ , where $\begin{array} { r } { \sigma ( \cdot ) = \frac { 1 } { 1 + \exp ( - \cdot ) } } \end{array}$ . The number of parameters in $\pmb { \theta } _ { 3 }$ is $O ( d + k )$ .
131
+
132
+ In summary, ExpressGNN can be viewed as a two-level encoding of the entities: the compact GNN assigns similar embeddings to similar entities in the knowledge graph, while the expressive tunable embeddings provide additional model capacity to encode entityspecific information beyond graph structures. The overall number of trainable parameters in ExpressGNN is $O ( d ^ { 2 } + k M )$ . By tuning the embedding size $d$ and $k$ , ExpressGNN can trade-off between the model compactness and expressiveness. For large-scale problems with a large number of entities ( $M$ is large), ExpressGNN can save a lot of parameters by reducing $k$ .
133
+
134
+ # Algorithm 1: GNN()
135
+
136
+ Initialize entity node: $\mu _ { c } ^ { ( 0 ) } = \mu _ { 0 }$ , $\forall c \in { \mathcal { C } }$ for $t = 0$ to $T - 1$ do . Compute message $\forall r ( c , c ^ { \prime } ) \in \mathcal { O }$ $m _ { c ^ { \prime } \to c } ^ { ( t ) } = \mathtt { M L P } _ { 1 } ( \mu _ { c ^ { \prime } } ^ { ( t ) } , r ; \pmb { \theta } _ { 1 } )$ $\forall c \in { \mathcal { C } }$ $m _ { c } ^ { ( t + 1 ) } = \mathtt { A G G } ( \{ m _ { c ^ { \prime } c } ^ { ( t ) } \} _ { c ^ { \prime } : r ( c , c ^ { \prime } ) \in \mathcal { O } } )$ . Update embedding ∀c ∈ C $\boldsymbol { \mu } _ { c } ^ { ( t + 1 ) } = \mathtt { M L P } _ { 2 } ( \boldsymbol { \mu } _ { c } ^ { ( t ) } , m _ { c } ^ { ( t + 1 ) } ; \boldsymbol { \theta } _ { 2 } )$
137
+
138
+ return embeddings $\{ \mu _ { c } ^ { ( T ) } \}$
139
+
140
+ # 5.1 EXPRESSIVE POWER OF GNN AS INFERENCE NETWORK
141
+
142
+ The combination of GNN and tunable embeddings makes the model sufficiently expressive to approximate the true posterior distributions. Here we provide theoretical analysis on the expressive power of GNN in the mean-field inference problem, and discuss the benefit of combining GNN and tunable embeddings in ExpressGNN.
143
+
144
+ Recent studies (Shervashidze et al., 2011; Xu et al., 2018) show that the vanilla GNN embeddings can represent the results of graph coloring, but fail to represent the results of the more strict graph isomorphism check, i.e., GNN produces the same embedding for some nodes that should be distinguished.
145
+
146
+ We first demonstrate this problem by a simple example:
147
+
148
+ Example. Fig. 3 involves four entities (A, B, E, F), two predicates (Friend: $\operatorname { F } ( \cdot , \cdot )$ , Like: $\mathbb { L } ( \cdot , \cdot ) ,$ ), and one formula $( \operatorname { F } ( c , c ^ { \prime } ) \Rightarrow$ $\mathbb { L } ( c , c ^ { \prime } ) )$ . In this example, MLN variables have different posteriors, but GNN embeddings result in the same posterior representation. More specifically,
149
+
150
+ • Entity $A$ and $B$ have opposite relations with $E$ , i.e., $\operatorname { F } ( A , E ) =$ 1 versus $\mathtt { F } ( B , E ) = 0$ in the knowledge graph, but running GNN on the knowledge graph will always produce the same embeddings for $A$ and $B$ , i.e., $\mu _ { A } = \mu _ { B }$ .
151
+
152
+ ![](images/ba7c599f7f9942edc01cd2e093ab9aabe857074b5391d2f375d3d892115d2627.jpg)
153
+ Figure 3: Bottom: A knowledge base with 0-1-0-1 loop. Top: MLN.
154
+
155
+ • $\mathbb { L } ( A , E )$ and $\mathbb { L } ( B , E )$ apparently have different posteriors. However, using GNN embeddings, $Q _ { \theta } ( \mathtt { L } ( A , E ) ) \ : = \ : \sigma \left( \mathtt { M L P } _ { 3 } ( \mu _ { A } , \mu _ { E } , \mathtt { L } ) \right)$ is always identical to $Q _ { \theta } ( \mathtt { L } ( B , E ) ) = \sigma \left( \mathtt { M L P } _ { 3 } ( \mu _ { B } , \mu _ { E } , \mathtt { L } ) \right)$ .
156
+
157
+ We can formally prove that solving the problem in the above example requires the graph embeddings to distinguish any non-isomorphic nodes in the knowledge graph. A formal statement is provided below (see Appendix E for the proof).
158
+
159
+ Definition 5.1. Two ordered sequences of nodes $\left( c _ { 1 } , \ldots , c _ { n } \right)$ and $( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ are isomorphic in a graph $\mathcal { G } _ { K }$ if there exists an isomorphism $\pi : \mathcal G _ { K } \mathcal G _ { K }$ such that $\pi ( c _ { 1 } ) = c _ { 1 } ^ { \prime } , \ldots , \pi ( c _ { n } ) = c _ { n } ^ { \prime }$ .
160
+
161
+ Theorem 5.1. Two latent variables $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ have the same posterior distribution in any MLN if and only if the nodes $\left( c _ { 1 } , \cdots , c _ { n } \right)$ and $( c _ { 1 } ^ { \prime } , \cdots , c _ { n } ^ { \prime } )$ are isomorphic in the knowledge graph $\mathcal { G } _ { K }$ .
162
+
163
+ Implied by the theorem, to obtain an expressive enough representation for the posterior, we need a more powerful GNN variant. A recent work has proposed a powerful GNN variant (Maron et al., 2019), which can handle small graphs such as chemical compounds and protein structures, but it is computationally expensive due to the usage of high-dimensional tensors. As a simple yet effective solution, ExpressGNN augments the vanilla GNN with additional tunable embeddings, which is a trade-off between the compactness and expressiveness of the model.
164
+
165
+ In summary, ExpressGNN has the following nice properties:
166
+
167
+ • Efficiency: ExpressGNN directly works on the knowledge graph, instead of the huge MLN grounding graph, making it much more efficient than the existing MLN inference methods.
168
+ • Compactness: The compact GNN model with shared parameters can be very memory efficient, making ExpressGNN possible to handle industry-scale problems.
169
+ • Expressiveness: The GNN model can capture structure knowledge encoded in the knowledge graph. Meanwhile, the tunable embeddings can encode entity-specific information, which compensates for GNN’s deficiency in distinguishing non-isomorphic nodes.
170
+ Generalizability: With the GNN embeddings, ExpressGNN may generalize to new entities or even different but related knowledge graphs unseen during training time without the need for retraining.
171
+
172
+ # 6 EXPERIMENTS
173
+
174
+ Benchmark datasets. We evaluate ExpressGNN and other baseline methods on four benchmark datasets: UW-CSE (Richardson & Domingos, 2006), Cora (Singla & Domingos, 2005), synthetic Kinship datasets, and FB15K-237 (Toutanova & Chen, 2015) constructed from Freebase (Bollacker et al., 2008). Details and full statistics of the benchmark datasets are provided in Appendix B.
175
+
176
+ General settings. We conduct all the experiments on a GPU-enabled (Nvidia RTX 2080 Ti) Linux machine powered by Intel Xeon Silver 4116 processors at 2.10GHz with 256GB RAM. We implement ExpressGNN using PyTorch and train it with Adam optimizer (Kingma & Ba, 2014). To ensure a fair comparison, we allocate the same computational resources (CPU, GPU and memory) for all the experiments. We use the default tuned hyperparameters for competitor methods, which can reproduce the experimental results reported in their original works.
177
+
178
+ Model hyperparameters. For ExpressGNN, we use 0.0005 as the initial learning rate, and decay it by half for every 10 epochs without improvement of validation loss. For Kinship, UW-CSE and Cora, we run ExpressGNN with a fixed number of iterations, and use the smallest subset from the original split for hyperparameter tuning. For FB15K-237, we use the original validation set to tune the hyperparameters. We use a two-layer MLP with ReLU activation function as the nonlinear transformation for each embedding update step in the GNN model. We learn different MLP parameters for different steps. To increase the model capacity of ExpressGNN, we also use different MLP parameters for different edge type, and for a different direction of embedding aggregation. For each dataset, we search the configuration of ExpressGNN on either the validation set or the smallest subset. The configuration we search includes the embedding size, the split point of tunable embeddings and GNN embeddings, the number of embedding update steps, and the sampling batch size. For the inference experiments, the weights for all the logic formulae are fixed as 1. For the learning experiments, the weights are initialized as 1. For the choice of $\lambda$ in the combined objective $L _ { \theta }$ in Eq. 6, we set $\lambda = 0$ for the inference experiments, since the query predicates are never seen in the training data and no supervision is available. For the learning experiments, we set $\lambda = 1$ .
179
+
180
+ Table 1: Inference accuracy (AUC-PR) of different methods on three benchmark datasets.
181
+
182
+ <table><tr><td rowspan="2">Method</td><td colspan="5">Kinship</td><td colspan="5">UW-CSE</td><td colspan="2">Cora</td></tr><tr><td>S1</td><td>S2</td><td>S3</td><td>S4</td><td>S5</td><td>AI</td><td>Graphics</td><td></td><td>Language</td><td>Systems</td><td>Theory</td><td>(avg)</td></tr><tr><td>MCMC</td><td>0.53</td><td>1</td><td>-</td><td>-</td><td>=</td><td>1</td><td></td><td></td><td></td><td>-</td><td>-</td><td>-</td></tr><tr><td>BP /Lifted BP</td><td>0.53</td><td>0.58</td><td>0.55</td><td>0.55</td><td>0.56</td><td>0.01</td><td></td><td>0.01</td><td>0.01</td><td>0.01</td><td>0.01</td><td>1</td></tr><tr><td>MC-SAT</td><td>0.54</td><td>0.60</td><td>0.55</td><td>0.55</td><td>-</td><td></td><td>0.03</td><td>0.05</td><td>0.06</td><td>0.02</td><td>0.02</td><td>-</td></tr><tr><td>HL-MRF</td><td>1.00</td><td>1.00</td><td>1.00</td><td>1.00</td><td>-</td><td></td><td>0.06</td><td>0.06</td><td>0.02</td><td>0.04</td><td>0.03</td><td>-</td></tr><tr><td>ExpressGNN-E</td><td>0.97</td><td>0.97</td><td>0.99</td><td>0.99</td><td>0.99</td><td></td><td>0.09</td><td>0.19</td><td>0.14</td><td>0.06</td><td>0.09</td><td>0.64</td></tr></table>
183
+
184
+ # 6.1 COMPARISON TO MLN INFERENCE METHODS AND ABLATION STUDY
185
+
186
+ We first evaluate the inference accuracy and efficiency of ExpressGNN. We compare our method with several strong MLN inference methods on UW-CSE, Cora and Kinship datasets. We also conduct ablation study to explore the trade-off between GNN and tunable embeddings.
187
+
188
+ Experiment settings. For the inference experiments, we fix the weights of all logic rules as 1. A key advantage of MLN is that it can handle open-world setting in a consistent probabilistic framework. Therefore, we adopt open-world setting for all the experiments, as opposed to closed-world setting where unobserved facts (except the query predicates) are assumed to be false. We also report the performance under closed-world setting in Appendix C.
189
+
190
+ Prediction tasks. The deductive logic inference task is to answer queries that typically involve single predicate. For example in UW-CSE, the task is to predict the AdvisedBy $( c , c ^ { \prime } )$ relation for all persons in the set. In Cora, the task is to de-duplicate entities, and one of the query predicates is SameAuthor $( c , c ^ { \prime } )$ . As for Kinship, the task is to predict whether a person is male or female, i.e., Male(c). For each possible substitution of the query predicate with different entities, the model is tasked to predict whether it’s true or not.
191
+
192
+ Evaluation metrics. Following existing studies (Richardson & Domingos, 2006; Singla & Domingos, 2005), we use area under the precision-recall curve (AUC-PR) to evaluate the inference accuracy. To evaluate the inference efficiency, we use wall-clock running time in minutes.
193
+
194
+ Competitor methods. We compare our method with several strong MLN inference algorithms, including MCMC (Gibbs Sampling; Gilks et al. (1995); Richardson & Domingos (2006)), Belief Propagation (BP; Yedidia et al. (2001)), Lifted Belief Propagation (Lifted BP; Singla & Domingos (2008)), MC-SAT (Poon & Domingos, 2006) and Hinge-Loss Markov Random Field (HL-MRF; Bach et al. (2015); Srinivasan et al. (2019)).
195
+
196
+ Inference accuracy. The results of inference accuracy on three benchmark datasets are reported in Table 1. A hyphen in the entry indicates that it is either out of memory or exceeds the time limit (24 hours). We denote our method as ExpressGNN-E since only the E-step is needed for the inference experiments. Note that since the lifted BP is guaranteed to get identical results as BP (Singla & Domingos, 2008), the results of these two methods are merged into one row. For these experiments, ExpressGNN-E uses 64-dim GNN embeddings and 64-dim tunable embeddings. On Cora, all the baseline methods fail to handle the data scale under open-world setting, and ExpressGNN-E achieves good inference accuracy. On UW-CSE, ExpressGNN-E consistently outperforms all baselines. The Kinship dataset is synthesized and noise-free, and the number of entities increases linearly on the five sets S1–S5. HL-MRF achieves perfect accuracy for S1–S4, but is infeasible on the largest set S5. ExpressGNN-E yields similar but not perfect results, which is presumably caused by the stochastic nature of our sampling and optimization procedure.
197
+
198
+ Inference efficiency. The inference time corresponding to the experiments in Table 1 is summarized in Fig. 4. On UW-CSE (left table), ExpressGNN-E uses much shorter time for inference compared to all the baseline methods, and meanwhile ExpressGNN-E achieves the best inference performance. On Kinship (right figure), as the data size grows linearly from S1 to S5, the inference time of most baseline methods grows exponentially, while ExpressGNN-E maintains a nearly constant time cost, demonstrating its nice scalability. Some baseline methods such as MCMC and MC-SAT become infeasible for larger sets. HL-MRF maintains a comparatively short inference time, however, it has a huge increase of memory cost and is not able to handle the largest set S5.
199
+
200
+ Figure 4: Left / Right: Inference time on UW-CSE / Kinship respectively. N/A indicates the method is infeasible.
201
+
202
+ <table><tr><td rowspan="2">Method</td><td colspan="5">Inference Time (minutes)</td></tr><tr><td>AI</td><td>Graphics</td><td>Language</td><td>Systems</td><td>Theory</td></tr><tr><td>MCMC</td><td>&gt;24h</td><td>&gt;24h</td><td>&gt;24h</td><td>&gt;24h</td><td>&gt;24h</td></tr><tr><td>BP</td><td>408</td><td>352</td><td>37</td><td>457</td><td>190</td></tr><tr><td>Lifted BP</td><td>321</td><td>270</td><td>32</td><td>525</td><td>243</td></tr><tr><td>MC-SAT</td><td>172</td><td>147</td><td>14</td><td>196</td><td>86</td></tr><tr><td>HL-MRF</td><td>135</td><td>132</td><td>18</td><td>178</td><td>72</td></tr><tr><td>ExpressGNN-E</td><td>14</td><td>20</td><td>5</td><td>7</td><td>13</td></tr></table>
203
+
204
+ ![](images/f2e7a127c5d56324c1762970f8303198968d78bd2520c5480f466bacc204fd23.jpg)
205
+
206
+ Ablation study. ExpressGNN can trade-off the compactness and expressiveness of model by tuning the dimensionality of GNN and tunable embeddings. We perform ablation study on the Cora dataset to investigate how this trade-off affects the inference accuracy. Results of different configurations of ExpressGNN-E are shown in Table 2. It is observed that GNN64+Tune4 has comparable performance with Tune64, but is consistently better than GNN64. Note that the number of parameters in $\mathrm { G N N } 6 4 { + } \mathrm { T u n e } 4$ is $O ( 6 4 ^ { 2 } + 4 | \mathcal { C } | )$ , while that in Tune64 is $O ( 6 4 | \mathcal { C } | )$ . When the number of entities is large, $\mathrm { G N N } 6 4 +$ Tune4 has much less parameters to train. This is consistent with our theoretical analysis result: As a compact model, GNN saves a lot of parameters, but GNN alone is not expressive enough. A similar conclusion is observed for $\mathrm { G N N } 6 4 \mathrm { + T u n e } 6 4$ and Tune128. Therefore, ExpressGNN seeks a combination of two types of embeddings to possess the advantage of both: having a compact model and being expressive. The best configuration of their embedding sizes can be varied on different tasks, and determined by the goal: getting a portable model or better performance.
207
+
208
+ Table 2: AUC-PR for different combinations of GNN and tunable embeddings. Tune $d$ stands for $d$ -dim tunable embeddings and GNN $d$ stands for $d$ -dim GNN embeddings.
209
+
210
+ <table><tr><td rowspan="3">Configuration</td><td colspan="5">Cora</td></tr><tr><td>S1</td><td>S2</td><td>S3</td><td>S4</td><td>S5</td></tr><tr><td>Tune64</td><td>0.57 0.74</td><td>0.34</td><td>0.55 0.54</td><td>0.70 0.53</td></tr><tr><td>GNN64 GNN64+Tune4</td><td>0.57 0.61</td><td>0.58 0.75</td><td>0.38 0.39 0.54</td><td>0.70</td></tr><tr><td>Tune128</td><td>0.62 0.76</td><td>0.42</td><td>0.60</td><td>0.73</td></tr><tr><td>GNN128</td><td>0.60</td><td>0.59</td><td>0.45 0.55</td><td>0.61</td></tr><tr><td>GNN64+Tune64 0.62</td><td></td><td>0.79 0.46</td><td>0.57</td><td>0.75</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
211
+
212
+ # .2 COMPARISON TO KNOWLEDGE BASE COMPLETION METHODS
213
+
214
+ We evaluate ExpressGNN in the knowledge base completion task on the FB15K-237 dataset, and compare it with state-of-the-art knowledge base completion methods.
215
+
216
+ Experiment settings. To generate logic rules, we use Neural LP (Yang et al., 2017) on the training set and pick up the candidates with top confidence scores. See Appendix D for examples of selected logic rules. We evaluate both inference-only and inference-and-learning version of ExpressGNN, denoted as ExpressGNN-E and ExpressGNN-EM, respectively.
217
+
218
+ Prediction task. For each test query $\boldsymbol { r } ( \boldsymbol { c } , \boldsymbol { c } ^ { \prime } )$ with respect to relation $r$ , the model is tasked to generate a rank list over all possible instantiations of $r$ and sort them according to the model’s confidence on how likely this instantiation is true.
219
+
220
+ Evaluation metrics. Following existing studies (Bordes et al., 2013; Sun et al., 2019), we use filtered ranking where the test triples are ranked against all the candidate triples not appearing in the dataset. Candidate triples are generated by corrupting the subject or object of a query $\boldsymbol { r } ( \boldsymbol { c } , \boldsymbol { c } ^ { \prime } )$ . For evaluation, we compute the Mean Reciprocal Ranks (MRR), which is the average of the reciprocal rank of all the truth queries, and Hits $@ 1 0$ , which is the percentage of truth queries that are ranked among the top 10.
221
+
222
+ Competitor methods. Since none of the aforementioned MLN inference methods can scale up to this dataset, we compare ExpressGNN with a number of state-of-the-art methods for knowledge base completion, including Neural Tensor Network (NTN; Socher et al. (2013)), Neural LP (Yang et al., 2017), DistMult (Kadlec et al., 2017), ComplEx (Trouillon et al., 2016), TransE (Bordes et al., 2013), RotatE (Sun et al., 2019) and pLogicNet (Qu & Tang, 2019). The results of MLN and pLogicNet are directly taken from the paper Qu & Tang (2019). For all the other baseline methods, we use publicly available code with the provided best hyperparameters to run the experiments.
223
+
224
+ Table 3: Performance on FB15K-237 with varied training set size.
225
+
226
+ <table><tr><td rowspan="2">Model</td><td colspan="6">MRR</td><td colspan="5">Hits @10</td></tr><tr><td>0%</td><td>5%</td><td></td><td>10% 20%</td><td></td><td>100%</td><td>0%</td><td>5%</td><td></td><td>10% 20%</td><td>100%</td></tr><tr><td>MLN</td><td>■</td><td></td><td></td><td></td><td></td><td>0.10</td><td>=</td><td>=</td><td>■</td><td>=</td><td>16.0</td></tr><tr><td>NTN</td><td>0.09</td><td>0.10</td><td>0.10</td><td></td><td>0.11</td><td>0.13</td><td>17.9</td><td>19.3</td><td>19.1</td><td>19.6</td><td>23.9</td></tr><tr><td>Neural LP</td><td>0.01</td><td>0.13</td><td>0.15</td><td></td><td>0.16</td><td>0.24</td><td>1.5</td><td>23.2</td><td>24.7</td><td>26.4</td><td>36.2</td></tr><tr><td>DistMult</td><td>0.23</td><td>0.24</td><td>0.24</td><td></td><td>0.24</td><td>0.31</td><td>40.0</td><td>40.4</td><td>40.7</td><td>41.4</td><td>48.5</td></tr><tr><td>ComplEx</td><td>0.24</td><td>0.24</td><td>0.24</td><td></td><td>0.25</td><td>0.32</td><td>41.1</td><td>41.3</td><td>41.9</td><td>42.5</td><td>51.1</td></tr><tr><td>TransE</td><td>0.24 0.25</td><td></td><td>0.25</td><td></td><td>0.25</td><td>0.33</td><td>42.7</td><td>43.1</td><td>43.4</td><td>43.9</td><td>52.7</td></tr><tr><td>RotatE</td><td>0.25</td><td>0.25</td><td>0.25</td><td></td><td>0.26</td><td>0.34</td><td>42.6 43.0</td><td></td><td>43.5</td><td>44.1</td><td>53.1</td></tr><tr><td>pLogicNet</td><td>=</td><td>=</td><td>=</td><td></td><td></td><td>0.33</td><td>-</td><td></td><td>=</td><td>-</td><td>52.8</td></tr><tr><td>ExpressGNN-E</td><td>0.42 0.42</td><td></td><td>0.42</td><td>20.44</td><td></td><td>0.45</td><td>53.1</td><td>53.1</td><td>53.3</td><td>55.2</td><td>57.3</td></tr><tr><td>ExpressGNN-EM 0.42 0.42</td><td></td><td></td><td></td><td>0.43 0.45</td><td></td><td>0.49</td><td>53.8 54.6 55.3 55.6</td><td></td><td></td><td></td><td>60.8</td></tr></table>
227
+
228
+ Table 4: Zero-shot learning performance on FB15K-237.
229
+
230
+ <table><tr><td>Model</td><td>MRR</td><td>Hits@10</td></tr><tr><td>NTN</td><td>0.001</td><td>0.0</td></tr><tr><td>Neural LP</td><td>0.010</td><td>2.7</td></tr><tr><td>DistMult</td><td>0.004</td><td>0.8</td></tr><tr><td>ComplEx</td><td>0.013</td><td>2.2</td></tr><tr><td>TransE</td><td>0.003</td><td>0.5</td></tr><tr><td>RotatE</td><td>0.006</td><td>1.5</td></tr><tr><td>ExpressGNN-E</td><td>0.181</td><td>29.3</td></tr><tr><td>ExpressGNN-EM</td><td>0.185</td><td>29.6</td></tr></table>
231
+
232
+ Performance analysis. The experimental results on the full training data are reported in Table 3 ( $100 \%$ columns). Both ExpressGNN-E and ExpressGNN-EM significantly outperform all the baseline methods. With learning the weights of logic rules, ExpressGNN-EM achieves the best performance. Compared to MLN, ExpressGNN achieves much better performance since MLN only relies on the logic rules while ExpressGNN can also leverage the labeled data as additional supervision. Compared to knowledge graph embedding methods such as TransE and RotatE, ExpressGNN can leverage the prior knowledge in logic rules and outperform these purely data-driven methods.
233
+
234
+ Data efficiency. We investigate the data efficiency of ExpressGNN and compare it with baseline methods. Following (Yang et al., 2017), we split the knowledge base into facts / training / validation / testing sets, and vary the size of the training set from $0 \%$ to $100 \%$ to feed the model with complete facts set for training. From Table 3, we see that ExpressGNN performs significantly better than the baselines on smaller training data. With more training data as supervision, data-driven baseline methods start to close the gap with ExpressGNN. This clearly shows the benefit of leveraging the knowledge encoded in logic rules when there data is insufficient for supervised learning.
235
+
236
+ Zero-shot relational learning. In practical scenarios, a large portion of the relations in the knowledge base are long-tail, i.e., most relations may have only a few facts (Xiong et al., 2018). Therefore, it is important to investigate the model performance on relations with insufficient training data. We construct a zero-shot learning dataset based on FB15K-237 by forcing the training and testing data to have disjoint sets of relations. Table 4 shows the results. As expected, the performance of all the supervised relational learning methods drop to almost zero. This shows the limitation of such methods when coping with sparse long-tail relations. Neural LP is designed to handle new entities in the test set (Yang et al., 2017), but still struggles to perform well in zero-shot learning. In contrast, ExpressGNN leverages both the prior knowledge in logic rules and the neural relational embeddings for reasoning, which is much less affected by the scarcity of data on long-tail relations. Both variants of our framework (ExpressGNN-E and ExpressGNN-EM) achieve significantly better performance.
237
+
238
+ # 7 CONCLUSION
239
+
240
+ This paper studies the probabilistic logic reasoning problem, and proposes ExpressGNN to combine the advantages of Markov Logic Networks in logic reasoning and graph neural networks in graph representation learning. ExpressGNN addresses the scalability issue of Markov Logic Networks with efficient stochastic training in the variational EM framework. ExpressGNN employs GNNs to capture the structure knowledge that is implicitly encoded in the knowledge graph, which serves as supplement to the knowledge from logic formulae. ExpressGNN is a general framework that can trade-off the model compactness and expressiveness by tuning the dimensionality of the GNN and the embedding part.
241
+
242
+ # ACKNOWLEDGEMENTS
243
+
244
+ We acknowledge grants from NSF IIS-1218749, NIH BIGDATA 1R01GM108341, NSF CAREER IIS-1350983, NSF IIS-1639792 EAGER, NSF IIS-1841351 EA-GER, NSF CNS-1704701, ONR N00014-15-1-2340, Intel ISTC, Nvidia, Google, Amazon AWS and Siemens. We thank Hyunsu Park for his insightful discussions and help on experiments. We thank the anonymous reviewers for their helpful and thoughtful comments. Yuyu Zhang is supported by the Siemens FutureMaker Fellowship.
245
+
246
+ # REFERENCES
247
+
248
+ Stephen H Bach, Matthias Broecheler, Bert Huang, and Lise Getoor. Hinge-loss markov random fields and probabilistic soft logic. arXiv preprint arXiv:1505.04406, 2015.
249
+
250
+ Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
251
+
252
+ Kurt Bollacker, Colin Evans, Praveen Paritosh, Tim Sturge, and Jamie Taylor. Freebase: a collaboratively created graph database for structuring human knowledge. In Proceedings of the 2008 ACM SIGMOD international conference on Management of data, pp. 1247–1250. AcM, 2008.
253
+
254
+ Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In Advances in neural information processing systems, pp. 2787–2795, 2013.
255
+
256
+ Hanjun Dai, Bo Dai, and Le Song. Discriminative embeddings of latent variable models for structured data. In International conference on machine learning, pp. 2702–2711, 2016.
257
+
258
+ Woodrow W Denham. The detection of patterns in Alyawara nonverbal behavior. PhD thesis, University of Washington, Seattle., 1973.
259
+
260
+ Zoubin Ghahramani, Matthew J Beal, et al. Graphical models and variational methods. Advanced mean field methods-theory and practice. MIT Press, 2000.
261
+
262
+ Walter R Gilks, Sylvia Richardson, and David Spiegelhalter. Markov chain Monte Carlo in practice. Chapman and Hall/CRC, 1995.
263
+
264
+ Matthew D Hoffman, David M Blei, Chong Wang, and John Paisley. Stochastic variational inference. The Journal of Machine Learning Research, 14(1):1303–1347, 2013.
265
+
266
+ James Ignizio. Introduction to expert systems, volume 21. 1991.
267
+
268
+ Rudolf Kadlec, Ondrej Bajgar, and Jan Kleindienst. Knowledge base completion: Baselines strike back. arXiv preprint arXiv:1705.10744, 2017.
269
+
270
+ Tushar Khot, Sriraam Natarajan, Kristian Kersting, and Jude Shavlik. Learning markov logic networks via functional gradient boosting. In 2011 IEEE 11th International Conference on Data Mining, pp. 320–329. IEEE, 2011.
271
+
272
+ Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
273
+
274
+ Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
275
+
276
+ Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In ICLR, 2016.
277
+
278
+ Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. arXiv preprint arXiv:1905.11136, 2019.
279
+
280
+ Lilyana Mihalkova and Raymond J Mooney. Bottom-up learning of markov logic network structure. In Proceedings of the 24th international conference on Machine learning, pp. 625–632. ACM, 2007.
281
+
282
+ Stephen Muggleton and Luc De Raedt. Inductive logic programming: Theory and methods. The Journal of Logic Programming, 19:629–679, 1994.
283
+
284
+ Hoifung Poon and Pedro Domingos. Sound and efficient inference with probabilistic and deterministic dependencies. In AAAI, volume 6, pp. 458–463, 2006.
285
+
286
+ Hoifung Poon and Pedro Domingos. Joint inference in information extraction. In AAAI, volume 7, pp. 913–918, 2007.
287
+
288
+ Meng Qu and Jian Tang. Probabilistic logic neural networks for reasoning. arXiv preprint arXiv:1906.08495, 2019.
289
+
290
+ Meng Qu, Yoshua Bengio, and Jian Tang. GMNN: Graph Markov neural networks. In Proceedings of the 36th International Conference on Machine Learning, pp. 5241–5250, Long Beach, California, USA, 09–15 Jun 2019. PMLR.
291
+
292
+ Matthew Richardson and Pedro Domingos. Markov logic networks. Machine learning, 62(1-2): 107–136, 2006.
293
+
294
+ Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In European Semantic Web Conference, pp. 593–607. Springer, 2018.
295
+
296
+ Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(Sep): 2539–2561, 2011.
297
+
298
+ Parag Singla and Pedro Domingos. Discriminative training of markov logic networks. In AAAI, volume 5, pp. 868–873, 2005.
299
+
300
+ Parag Singla and Pedro Domingos. Entity resolution with markov logic. In Data Mining, 2006. ICDM’06. Sixth International Conference on, pp. 572–582. IEEE, 2006a.
301
+
302
+ Parag Singla and Pedro Domingos. Memory-efficient inference in relational domains. In AAAI, volume 6, pp. 488–493, 2006b.
303
+
304
+ Parag Singla and Pedro M Domingos. Lifted first-order belief propagation. In AAAI, volume 8, pp. 1094–1099, 2008.
305
+
306
+ Richard Socher, Danqi Chen, Christopher D Manning, and Andrew Ng. Reasoning with neural tensor networks for knowledge base completion. In Advances in neural information processing systems, pp. 926–934, 2013.
307
+
308
+ Sriram Srinivasan, Behrouz Babaki, Golnoosh Farnadi, and Lise Getoor. Lifted hinge-loss markov random fields. AAAI, 2019.
309
+
310
+ Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. Rotate: Knowledge graph embedding by relational rotation in complex space. arXiv preprint arXiv:1902.10197, 2019.
311
+
312
+ Ben Taskar, Pieter Abbeel, Ming-Fai Wong, and Daphne Koller. Relational markov networks. Introduction to statistical relational learning, pp. 175–200, 2007.
313
+
314
+ Kristina Toutanova and Danqi Chen. Observed versus latent features for knowledge base and text inference. In Proceedings of the 3rd Workshop on Continuous Vector Space Models and their Compositionality, pp. 57–66, 2015.
315
+
316
+ Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Complex embeddings for simple link prediction. In International Conference on Machine Learning, pp. 2071–2080, 2016.
317
+
318
+ Wenhan Xiong, Mo Yu, Shiyu Chang, Xiaoxiao Guo, and William Yang Wang. One-shot relational learning for knowledge graphs. arXiv preprint arXiv:1808.09040, 2018.
319
+
320
+ Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.
321
+
322
+ Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base completion. CoRR, abs/1702.08367, 2017.
323
+
324
+ Jonathan S Yedidia, William T Freeman, and Yair Weiss. Generalized belief propagation. In Advances in neural information processing systems, pp. 689–695, 2001.
325
+
326
+ Weizhe Zhang, Xiaoqiang Li, Hui He, and Xing Wang. Identifying network public opinion leaders based on markov logic networks. The scientific world journal, 2014, 2014.
327
+
328
+ # Appendix
329
+
330
+ A COUNTER EXAMPLES
331
+
332
+ We provide more examples in this section to show that it is more than a rare case that GNN embeddings alone are not expressive enough.
333
+
334
+ ![](images/98af0827d1552adfb150be19a84c7d0dd9bba9b5d579a46216a1fc4f7766ac59.jpg)
335
+ A.1 EXAMPLE 1
336
+ Figure 5: Example 1. Top: Knowledge base. Bottom: MLN
337
+
338
+ Unlike the example shown in main text, where $\mathtt { A }$ and B have OPPOSITE relation with E, Fig. 5 shows a very simple example where $\mathtt { A }$ and $_ \mathrm { B }$ have exactly the same structure which makes A and B indistinguishable and isomorphic. However, since (A,E) and (B,E) are not isomorphic, it can be easily seen that $\mathbb { L } ( \mathbb { A } , \mathbb { E } )$ has different posterior from $\mathbb { L } ( \mathtt { B } , \mathtt { E } )$ .
339
+
340
+ A.2 EXAMPLE 2
341
+
342
+ ![](images/5334a8775e5e0c6e56b9c0e814108c556df7071648e6417d75b21162cd2b459a.jpg)
343
+ Figure 6: The same example as in Fig. 3. Top: Knowledge base. Bottom: MLN
344
+
345
+ Fig. 6 shows an example which is the same as in Fig. 3. However, in this example, it is already revealed in the knowledge base that $\left( \mathbb { A } , \mathbb { E } \right)$ and $\left( \mathtt { B } , \mathtt { E } \right)$ have different local structures as they are connected by different observations. That is, $\left( \mathbb { A } , \left[ \mathrm { F } \left( \mathbb { A } , \mathbb { E } \right) = 1 \right] , \mathbb { E } \right)$ ) and ( $\mathrm { B } , [ \mathrm { F } ( \mathrm { B } , \mathrm { E } ) = 0 ] , \mathrm { E } )$ can be distinguished by GNN.
346
+
347
+ Now, we use another example in Fig. 7 to show that even when the local structures are the same, the posteriors can still be different, which is caused by the formulae.
348
+
349
+ ![](images/36541a654c6e99a04114ed1acb8c6f3d65b634f8c2a86ac8d6e1ccc8118bc35f.jpg)
350
+ Figure 7: Example 2. Top: Knowledge base. Bottom: MLN
351
+
352
+ In Fig. 7, $\left( \mathbb { A } , \mathbb { E } \right)$ and $( \mathsf C , \mathsf H )$ have the same local structure, so that the tuple $( \mathbb { A } , [ \operatorname { F } ( \mathbb { A } , \operatorname { E } ) = 1 ] , \operatorname { E } )$ ) and (C, $[ \mathrm { F } ( \mathrm { C } , \mathrm { H } ) = 1 ] , \mathrm { H }$ ) can NOT be distingushed by GNN. However, we can make use of subgraph $\left( \mathbb { A } , \mathbb { E } , \mathbb { B } , \mathbb { E } \right)$ to define a formula, and then the resulting MLN gives different posterior to $\mathbb { L } ( \mathbb { A } , \mathbb { E } )$ and $\mathbb { L } ( \mathrm { C } , \mathbb { H } )$ , as can be seen from the figure. Note that this construction of MLN is the same as the construction steps stated in the proof in Sec. E.
353
+
354
+ Table 5: Complete statistics of the benchmark datasets.
355
+
356
+ <table><tr><td>Dataset</td><td>#entity</td><td># relation</td><td># fact # query</td><td></td><td># ground predicate</td><td># ground formula</td></tr><tr><td>FB15K-237</td><td>15K</td><td>237</td><td>272K</td><td>20K</td><td>50M</td><td>679B</td></tr><tr><td>Kinship-S1</td><td>62</td><td>15</td><td>187</td><td>38</td><td>50K</td><td>550K</td></tr><tr><td>Kinship-S2</td><td>110</td><td>15</td><td>307</td><td>62</td><td>158K</td><td>3M</td></tr><tr><td>Kinship-S3</td><td>160</td><td>15</td><td>482</td><td>102</td><td>333K</td><td>9M</td></tr><tr><td>Kinship-S4</td><td>221</td><td>15</td><td>723</td><td>150</td><td>635K</td><td>23M</td></tr><tr><td>Kinship-S5</td><td>266</td><td>15</td><td>885</td><td>183</td><td>920K</td><td>39M</td></tr><tr><td>UW-CSE-AI</td><td>300</td><td>22</td><td>731</td><td>4K</td><td>95K</td><td>73M</td></tr><tr><td>UW-CSE-Graphics</td><td>195</td><td>22</td><td>449</td><td>4K</td><td>70K</td><td>64M</td></tr><tr><td>UW-CSE-Language</td><td>82</td><td>22</td><td>182</td><td>1K</td><td>15K</td><td>9M</td></tr><tr><td>UW-CSE-Systems</td><td>277</td><td>22</td><td>733</td><td>5K</td><td>95K</td><td>121M</td></tr><tr><td>UW-CSE-Theory</td><td>174</td><td>22</td><td>465</td><td>2K</td><td>51K</td><td>54M</td></tr><tr><td>Cora-S1</td><td>670</td><td>10</td><td>11K</td><td>2K</td><td>175K</td><td>621B</td></tr><tr><td>Cora-S2</td><td>602</td><td>10</td><td>9K</td><td>2K</td><td>156K</td><td>431B</td></tr><tr><td>Cora-S3</td><td>607</td><td>10</td><td>18K</td><td>3K</td><td>156K</td><td>438B</td></tr><tr><td>Cora-S4</td><td>600</td><td>10</td><td>12K</td><td>2K</td><td>160K</td><td>435B</td></tr><tr><td>Cora-S5</td><td>600</td><td>10</td><td>11K</td><td>2K</td><td>140K</td><td>339B</td></tr></table>
357
+
358
+ # B DATASET DETAILS
359
+
360
+ For our experiments, we use the following benchmark datasets:
361
+
362
+ • The social network dataset UW-CSE (Richardson & Domingos, 2006) contains publicly available information of students and professors in the CSE department of UW. The dataset is split into five sets according to the home department of the entities.
363
+ • The entity resolution dataset Cora (Singla & Domingos, 2005) consists of a collection of citations to computer science research papers. The dataset is also split into five subsets according to the field of research.
364
+ We introduce a synthetic dataset that resembles the popular Kinship dataset (Denham, 1973). The original dataset contains kinship relationships (e.g., Father, Brother) among family members in the Alyawarra tribe from Central Australia. The synthetic dataset closely resembles the original Kinship dataset but with a controllable number of entities. To generate a dataset with $n$ entities, we randomly split $n$ entities into two groups which represent the first and second generation respectively. Within each group, entities are grouped into a few sub-groups representing the sisterand brother-hood. Finally, entities from different sub-groups in the first generation are randomly coupled and a sub-group in the second generation is assigned to them as their children. To generate the knowledge base, we traverse this family tree, and record all kinship relations for each entity. We generate five kinship datasets (Kinship S1–S5) by linearly increasing the number of entities.
365
+ The knowledge base completion benchmark FB15K-237 (Toutanova & Chen, 2015) is a generic knowledge base constructed from Freebase (Bollacker et al., 2008), which is designed to a more challenging variant of FB15K. More specifically, FB15K-237 is constructed by removing nearduplicate and inverse relations from FB15K. The dataset is split into training / validation / testing and we use the same split of facts from training as in prior work (Yang et al., 2017).
366
+
367
+ The complete statistics of these datasets are shown in Table 5. Examples of logic formulae used in four benchmark datasets are listed in Table 7.
368
+
369
+ # C INFERENCE WITH CLOSED-WORLD SEMANTICS FOR BASELINE METHODS
370
+
371
+ In Sec. 6.1 we compare ExpressGNN with five probabilistic inference methods under open-world semantics. This is different from the original works, where they generally adopt the closed-world setting due to the scalability issues. More specifically, the original works assume that the predicates (except the ones in the query) observed in the knowledge base is closed, meaning for all instantiations of these predicates that do not appear in the knowledge base are considered false. Note that only the query predicates remain open-world in this setting.
372
+
373
+ Table 6: Inference performance of competitors and our method under the closed-world semantics.
374
+
375
+ <table><tr><td rowspan="2">Method</td><td colspan="5">Cora</td><td colspan="5">UW-CSE</td></tr><tr><td>S1</td><td>S2</td><td>S3</td><td>S4</td><td>S5</td><td>AI</td><td>Graphics</td><td>Language</td><td>Systems</td><td>Theory</td></tr><tr><td>MCMC</td><td>0.43</td><td>0.63</td><td>0.24</td><td>0.46</td><td>0.56</td><td>0.19</td><td>0.04</td><td>0.03</td><td>0.15</td><td>0.08</td></tr><tr><td>BP /Lifted BP</td><td>0.44</td><td>0.62</td><td>0.24</td><td>0.45</td><td>0.57</td><td>0.21</td><td>0.04</td><td>0.01</td><td>0.14</td><td>0.05</td></tr><tr><td>MC-SAT</td><td>0.43</td><td>0.63</td><td>0.24</td><td>0.46</td><td>0.57</td><td>0.13</td><td>0.04</td><td>0.03</td><td>0.11</td><td>0.08</td></tr><tr><td>HL-MRF</td><td>0.60</td><td>0.78</td><td>0.52</td><td>0.70</td><td>0.81</td><td>0.26</td><td>0.18</td><td>0.06</td><td>0.27</td><td>0.19</td></tr></table>
376
+
377
+ For sanity checking, we also conduct these experiments with a closed-world setting. We found the results summarized in Table 6 are close to those reported in the original works. This shows that we have a fair setup (including memory size, hyperparameters, etc.) for those competitor methods. Additionally, one can find that the AUC-PR scores compared to those (Table 1) under open-world setting are actually better. This is due to the way the datasets were originally collected and evaluated generally complies with the closed-world assumption. But this is very unlikely to be true for realworld and large-scale knowledge base such as Freebase and WordNet, where many true facts between entities are not observed. Therefore, in general, the open-world setting is much more reasonable, which we follow throughout this paper.
378
+
379
+ # D LOGIC FORMULAE
380
+
381
+ We list some examples of logic formulae used in four benchmark datasets in Table 7. The full list of logic formulae is available in our source code repository. Note that these formulae are not necessarily as clean as being always true, but are typically true.
382
+
383
+ For UW-CSE and Cora, we use the logic formulae provided in the original dataset. UW-CSE provides 94 hand-coded logic formulae, and Cora provides 46 hand-coded rules. For Kinship, we hand-code 22 first-order logic formulae. For FB15K-237, we first use Neural LP (Yang et al., 2017) on the full data to generate candidate rules. Then we select the ones that have confidence scores higher than $90 \%$ of the highest scored formulae sharing the same target predicate. We also de-duplicate redundant rules that can be reduced to other rules by switching the logic variables. Finally, we have generated 509 logic formulae for FB15K-237.
384
+
385
+ Table 7: Examples of logic formulae used in four benchmark datasets.
386
+
387
+ <table><tr><td>Dataset</td><td>First-order Logic Formulae</td></tr><tr><td rowspan="5"></td><td>Father(X,Z)∧Mother(Y,Z)→ Husband(X,Y)</td></tr><tr><td>Father(X,Z)∧Husband(X,Y) =Mother(Y,Z)</td></tr><tr><td>Husband(X,Y)=Wife(Y,X)</td></tr><tr><td>Son(Y,X)=Father(X,Y)VMother(X,Y)</td></tr><tr><td>Daughter(Y,X)=Father(X,Y)VMother(X,Y)</td></tr><tr><td rowspan="5">UW-CSE</td><td>taughtBy(c,p,q) ∧courseLevel(c,Level500)⇒professor(p)</td></tr><tr><td>tempAdvisedBy(p,s)⇒professor(p)</td></tr><tr><td>advisedBy(p,s)⇒ student(s)</td></tr><tr><td>tempAdvisedBy(p,s)= student(s)</td></tr><tr><td>professor(p)∧hasPosition(p,Faculty)⇒taughtBy(c,p,q)</td></tr><tr><td rowspan="5">Cora</td><td>SameBib(b1,b2)∧SameBib(b2,b3)= SameBib(b1,b3)</td></tr><tr><td>SameTitle(tl,t2)^SameTitle(t2,t3)⇒SameTitle(t1,t3)</td></tr><tr><td>Author(bcl,al)^Author(bc2,a2)^SameAuthor(al,a2) ⇒ SameBib(bcl,bc2)</td></tr><tr><td>HasWordVenue(al,+w)^ HasWordVenue(a2,+w) ⇒ SameVenue(al,a2)</td></tr><tr><td>Title(bcl,t1)^ Title(bc2,t2)^SameTitle(t1,t2) ⇒ SameBib(bcl,bc2)</td></tr><tr><td rowspan="4">FB15K-237</td><td>position(B,A)∧position(C,B)⇒position(C,A) ceremony(B,A)^ceremony(C,B)⇒categoryOf(C,A)</td></tr><tr><td>film(B,A)∧film(C,B)⇒participant(A,C)</td></tr><tr><td>storyBy(A,B)=participant(A,B)</td></tr><tr><td>adjoins(A,B)∧country(B,C) = serviceLocation(A,C)</td></tr></table>
388
+
389
+ # E PROOF OF THEOREM
390
+
391
+ First, we re-state the definition and theorem in a more mathematical form:
392
+
393
+ Definition. [Isomorphic Nodes] Two ordered sequences of nodes $\left( c _ { 1 } , \ldots , c _ { n } \right)$ and $( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ are isomorphic in a graph $\mathcal { G } _ { K }$ if there exists an isomorphism from $\mathcal { G } _ { \kappa } = ( \mathcal { C } , \mathcal { O } , \mathcal { E } )$ to itself, i.e., $\pi : \mathcal { C } \cup \mathcal { O } \mathcal { C } \cup \mathcal { O }$ , such that $\pi ( c _ { 1 } ) = c _ { 1 } ^ { \prime } , \ldots , \pi ( c _ { n } ) = { \overset { \prime } { c } } _ { n } ^ { \prime }$ . Further, we use the following notation $\left( c _ { 1 } , \cdots , c _ { n } \right) { \overset { \mathscr { G } _ { \kappa } } { \longleftrightarrow } } \left( c _ { 1 } ^ { \prime } , \cdots , c _ { n } ^ { \prime } \right) : \left( c _ { 1 } , \cdots , c _ { n } \right)$ and $( c _ { 1 } ^ { \prime } , \cdots , c _ { n } ^ { \prime } )$ are isomorphic in $\mathcal { G } _ { K }$
394
+
395
+ Theorem. Consider a knowledge base $\boldsymbol { \mathcal { K } } = ( \mathcal { C } , \mathcal { R } , \mathcal { O } )$ and any $r \in \mathcal { R }$ . Two latent random variables $X : = r ( c _ { 1 } , \ldots , c _ { n } )$ and $X ^ { \prime } : = \bar { r } ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ have the same posterior distribution in any MLN if and only if $( c _ { 1 } , \cdot \cdot \cdot , c _ { n } ) \overset { { \mathcal { G } } _ { \kappa } } { \longleftrightarrow } ( c _ { 1 } ^ { \prime } , \cdot \cdot \cdot , c _ { n } ^ { \prime } )$ .
396
+
397
+ Then we give the proof as follows.
398
+
399
+ Proof. A graph isomorphism from $G$ to itself is called automorphism, so in this proof, we will use the terminology - automorphism - to indicate such a self-bijection.
400
+
401
+ $( \Longleftarrow )$ We first prove the sufficient condition:
402
+
403
+ If ∃ automorphism $\pi$ on the graph $\mathcal { G } _ { K }$ such that $\pi ( c _ { i } ) = c _ { i } ^ { \prime } , \forall i = 1 , . . . , n .$ , then for any $r \in \mathcal { R }$ , $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ have the same posterior in any ML
404
+
405
+ MLN is a graphical model that can also be represented by a factor graph $\mathbf { M L N } = ( \mathcal { O } \cup \mathcal { H } , \mathcal { F } _ { g } , \mathcal { E } )$ where ground predicates (random variables) and ground formulae (potential) are connected. We will show that $\exists$ an automorphism $\phi$ on MLN such that $\phi \left( r ( c _ { 1 } , \ldots , \bar { c _ { n } } ) \right) = r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ . Then the sufficient condition is true. This automorphism $\phi$ is easy to construct using the automorphism $\pi$ on $\mathcal { G } _ { K }$ . More precisely, we define $\phi : ( \mathcal { O } \cup \mathcal { H } , \mathcal { F } _ { g } ) ( \mathcal { O } \cup \mathcal { H } , \mathcal { F } _ { g } )$ as
406
+
407
+ for any predicate $r \in \mathcal { R }$ , any assignments $a _ { r }$ to its arguments, any formula $f \in { \mathcal { F } }$ , and any assignments $a _ { f }$ to its arguments. It is easy to see $\phi$ is an automorphism:
408
+
409
+ 1. Since $\pi$ is a bijection, apparently $\phi$ is also a bijection.
410
+ 2. The above definition preserves the biding of the arguments. $r ( a _ { r } )$ and $f ( a _ { f } )$ are connected if and only if $\phi ( r ( a _ { r } ) )$ and $f ( \pi ( a _ { f } ) )$ are connected.
411
+ 3. Given the definition of $\pi$ , we know that $r ( a _ { r } )$ and $r ( \pi ( a _ { r } ) )$ have the same observation value. Therefore, in MLN, $\mathtt { N o d e T y p e } ( r ( a _ { r } ) ) = \mathtt { N o d e T y p e } ( \phi ( r ( a _ { r } ) ) )$ .
412
+
413
+ This completes the proof of the sufficient condition.
414
+
415
+ $( \Longrightarrow )$ ) To prove the necessary condition, it is equivalent to show the following assumption
416
+
417
+ (A 1): there is no automorphism $\pi$ on the graph $\mathcal { G } _ { K }$ such that $\pi ( c _ { i } ) = c _ { i } ^ { \prime } , \forall i = 1 , . . . , n $ , can imply:
418
+
419
+ there must exists a MLN and a predicate $r$ in it such that $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ have different posterior.
420
+
421
+ Before showing this, let us first introduce the factor graph representation of a single logic formula $f$ .
422
+
423
+ A logic formula $f$ can be represented as a factor graph, $\bar { \mathcal { G } _ { f } } = ( \mathcal { C } _ { f } , \mathcal { R } _ { f } , \mathcal { E } _ { f } )$ , where nodes on one side of the graph is the set of distinct constants $\mathcal { C } _ { f }$ needed in the formula, while nodes on the other side is the set of predicates $\mathcal { R } _ { f }$ used to define the formula. The set of edges, $\mathcal { E } _ { f }$ , will connect constants to predicates or predicate negation. That is, an edge
424
+
425
+ $\begin{array} { r l r } { e } & { { } = } & { \left( c , r , i \right) } \end{array}$ between node $c$ and predicate $r$ exists, if the predicate $r$ use constant $c$ in its $i$ -th argument.
426
+
427
+ We note that the set of distinctive constants used in the definition of logic formula are templates where actual constant can be instantiated from $\mathcal { C }$ . An illustration of logic formula factor graph can be found in Fig. 8. Similar to the factor graph for the knowledge base, we also differentiate the type of edges by the position of the argument.
428
+
429
+ ![](images/c6a9b737fa165a78df40a262bf409727e79afb733514ef3349866fc026d12ce0.jpg)
430
+ Figure 8: An example of the factor graph for the logic formula ¬Husband(X,Y) ∨ ¬Mother(Y,Z) ∨ Daughter(Z,X).
431
+
432
+ Therefore, every single formula can be represented by a factor graph. We will construct a factor graph representation to define a particular formula, and show that the MLN induced by this formula will result in different posteriors for $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ . The factor graph for the formula is constructed in the following way (see Fig. 7 as an example of the resulting formula constructed using the following steps):
433
+
434
+ (i) Given the above assumption (A 1), we claim that:
435
+
436
+ ∃ a subgraph $\mathcal { G } _ { c _ { 1 : n } } ^ { * } = ( \mathcal { C } _ { c } ^ { * } , \mathcal { O } _ { c } ^ { * } , \mathcal { E } _ { c } ^ { * } ) \subseteq \mathcal { G } _ { K }$ such that all subgraphs $\mathcal { G } _ { c _ { 1 : n } ^ { \prime } } = ( \mathcal { C } _ { c ^ { \prime } } , \mathcal { O } _ { c ^ { \prime } } , \mathcal { E } _ { c ^ { \prime } } ) \subseteq \mathcal { G } _ { K }$ satisfy:
437
+
438
+ (Condition) if there exists an isomorphism $\phi : \mathcal { G } _ { c _ { 1 : n } } ^ { * } \ \to \ \mathcal { G } _ { c _ { 1 : n } ^ { \prime } }$ satisfying $\phi ( c _ { i } ) =$ $c _ { i } ^ { \prime } , \forall i = 1 , \ldots , n$ after the observation values are IGNORED (that is, $[ r _ { j } ( \cdots ) = 0 ]$ and $[ r _ { j } ( \cdots ) = 1 ]$ are treated as the SAME type of nodes), then the set of fact nodes (observations) in these two graphs are different (that is, $\mathcal { O } _ { c } ^ { * } \neq \mathcal { O } _ { c ^ { \prime } }$ ).
439
+
440
+ The proof of this claim is given at the end of this proof.
441
+
442
+ (ii) Next, we use $\mathcal { G } _ { c _ { 1 : n } } ^ { * }$ to define a formula $f$ . We first initialize the definition of the formula value as
443
+
444
+ $$
445
+ f ( c _ { 1 } , \dots , c _ { n } , \tilde { c } _ { 1 } , \dots , \tilde { c } _ { n } ) = \big ( \wedge \left\{ \tilde { r } ( a _ { \tilde { r } } ) : \tilde { r } ( a _ { \tilde { r } } ) \in \mathcal { G } _ { c _ { 1 : n } } ^ { * } \right\} \big ) \Rightarrow r ( c _ { 1 } , \dots , c _ { n } ) .
446
+ $$
447
+
448
+ Then, we change $\tilde { r } ( a _ { \tilde { r } } )$ in this formula to the negation $\neg \tilde { r } ( a _ { \tilde { r } } )$ if the observed value of $\tilde { r } ( a _ { \tilde { r } } )$ is $_ 0$ in G ∗c1:n .
449
+
450
+ We have defined a formula $f$ using the above two steps. Suppose the MLN only contains this formula $f$ . Then
451
+
452
+ the two nodes $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ in this MLN must be distinguishable.
453
+
454
+ The reason is, in MLN, $r ( c _ { 1 } , \ldots , c _ { n } )$ is connected to a ground formula $f ( c _ { 1 } , \ldots , c _ { n } , \tilde { c } _ { 1 } , \ldots , \tilde { c } _ { n } )$ 1whose factor graph representation is $\mathcal { G } _ { c _ { 1 } : n } ^ { * } \cup r ( c _ { 1 } , . . . , c _ { n } )$ 1 n 1 n . In this formula, all variables are observed in the knowledge base $\kappa$ except for $r ( \ddot { c } _ { 1 } , \ldots , c _ { n } )$ and and the observation set is ${ \mathcal { O } } _ { c } ^ { * }$ . The formula value is
455
+
456
+ $$
457
+ f ( c _ { 1 } , \dots , c _ { n } , \tilde { c } _ { 1 } , \dots , \tilde { c } _ { n } ) = ( 1 \Rightarrow r ( c _ { 1 } , \dots , c _ { n } ) ) .
458
+ $$
459
+
460
+ Clarification: Eq. 10 is used to define a formula and $c _ { i }$ in this equation can be replaced by other constants, while Eq. 11 represents a ground formula whose arguments are exactly $c _ { 1 } , \ldots , c _ { n } , { \tilde { c } } _ { 1 } , \ldots , { \tilde { c } } _ { n }$ . Based on (Condition), there is NO formula $f ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } , \bar { c } _ { 1 } ^ { \prime } , \ldots , \tilde { c } _ { n } ^ { \prime } )$ that contains $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ has
461
+
462
+ an observation set the same as ${ \mathcal { O } } _ { c } ^ { * }$ . Therefore, $r ( c _ { 1 } , \ldots , c _ { n } )$ and $r ( c _ { 1 } ^ { \prime } , \ldots , c _ { n } ^ { \prime } )$ are distinguishable in this MLN.
463
+
464
+ # Proof of claim:
465
+
466
+ We show the existence by constructing the subgraph $\mathcal { G } _ { c _ { 1 : n } } ^ { * } \subseteq \mathcal { G } _ { K }$ in the following way:
467
+
468
+ (i) First, we initialize the subgraph as $\mathcal { G } _ { c _ { 1 : n } } ^ { * } : = \mathcal { G } _ { K }$ . Given assumption (A 1) stated above, it is clear that
469
+
470
+ $( \mathbf { S } \mathbf { \delta } \mathbf { 1 } ) \forall$ subgraph ${ \mathcal { G } } ^ { \prime } \subseteq { \mathcal { G } } _ { \kappa }$ , there is no isomorphism $\pi : \mathcal { G } _ { c _ { 1 : n } } ^ { * } \mathcal { G } ^ { \prime }$ satisfying $\pi ( c _ { i } ) =$ $c _ { i } ^ { \prime } , \forall i = 1 , \ldots , n$ .
471
+
472
+ (ii) Second, we need to check wether the following case occurs:
473
+
474
+ (C 1) ∃ a subgraph $\mathcal { G } ^ { \prime } = ( \mathcal { C } ^ { \prime } , \mathcal { O } ^ { \prime } , \mathcal { E } ^ { \prime } )$ such that (1) there EXISTS an isomorphism $\phi$ : G ∗c1:n $\mathcal { G } _ { c _ { 1 : n } } ^ { * } \to \mathcal { G } ^ { \prime }$ satisfying $\phi ( c _ { i } ) = c _ { i } ^ { \prime } , \forall i = 1 , . . . , n$ after the observation values are IGNORED (that is, $[ r _ { j } ( \cdots ) = 0 ]$ and $[ r _ { j } ( \cdots ) = 1 ]$ are treated as the same type of nodes); and (2) the set of factor nodes (observations) in these two graphs are the same (that is, ${ \mathcal { O } } _ { c } ^ { * } = { \mathcal { O } } ^ { \prime }$ ).
475
+
476
+ (iii) Third, we need to modify the subgraph if the case (C 1) is observed. Since $\left| \mathcal { G } _ { c _ { 1 : n } } ^ { * } \right| \geq | \mathcal { G } ^ { \prime } |$ , the only subgraph that will lead to the case (C1) is the maximal subgraph $\mathcal { G } _ { c _ { 1 : n } } ^ { * }$ . The isomorphism $\phi$ is defined by ignoring the observation values, while the isomorphism $\pi$ in $( \mathbf { \dot { S } } \mathbf { 1 } )$ is not ignoring them. Thus,
477
+
478
+ (S 1) and $( \mathbf { C _ { \lambda } } \mathbf { 1 } ) \Longrightarrow \exists$ a set of nodes $S : = \left\{ \left[ r _ { j } ( a ^ { ( 1 ) } ) = 0 \right] , \ldots , \left[ r _ { j } ( a ^ { ( n ) } ) = 0 \right] \right\}$ such that for any isomorphism $\phi$ satisfying the conditions in $( \mathbf { C 1 } )$ , the range $\phi ( S )$ contains at least one node $[ r _ { j } ( \cdot ) = 1 ]$ which has observation value 1.
479
+
480
+ Otherwise, it is easy to see a contradiction to statement (S 1).
481
+
482
+ (M 1) Modify the subgraph by $\mathcal { G } _ { c _ { 1 : n } } ^ { * } \mathcal { G } _ { c _ { 1 : n } } ^ { * } \setminus S$ . The nodes (and also their edges) in the set $S : = \left\{ \left[ r _ { j } ( a ^ { ( 1 ) } ) = 0 \right] , \ldots , \left[ r _ { j } ( a ^ { ( n ) } ) = 0 \right] \right\}$ are removed.
483
+
484
+ For the new subgraph $\mathcal { G } _ { c _ { 1 : n } } ^ { * }$ after the modification (M 1), the case (C 1) will not occur. Thus, we’ve obtained a subgraph that satisfies the conditions stated in the claim. Finally, we can remove the nodes that are not connected with $\{ c _ { 1 } , \ldots , c _ { n } \}$ (that is, there is no path between this node and any one of $\{ c _ { 1 } , \ldots , c _ { n } \} )$ . The remaining graph is connected to $\{ c _ { 1 } , \ldots , c _ { n } \}$ and still satisfies the conditions that we need.
parse/train/rJg76kStwH/rJg76kStwH_content_list.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/rJg76kStwH/rJg76kStwH_middle.json ADDED
The diff for this file is too large to render. See raw diff
 
parse/train/rJg76kStwH/rJg76kStwH_model.json ADDED
The diff for this file is too large to render. See raw diff