Add files using upload-large-folder tool

parse/train/6RB77-6-_oI/6RB77-6-_oI.md

@@ -0,0 +1,242 @@
+# How Powerful are Performance Predictors in Neural Architecture Search?
+
+Colin White1∗, Arber $\mathbf { Z e l a ^ { 2 } }$ , Binxin $\mathbf { R } \mathbf { u } ^ { 3 }$ , Yang $\mathbf { L i u } ^ { 1 }$ , Frank Hutter2,4 1 Abacus.AI, 2 University of Freiburg, 3 University of Oxford, 4 Bosch Center for Artificial Intelligence
+
+# Abstract
+
+Early methods in the rapidly developing field of neural architecture search (NAS) required fully training thousands of neural networks. To reduce this extreme computational cost, dozens of techniques have since been proposed to predict the final performance of neural architectures. Despite the success of such performance prediction methods, it is not well-understood how different families of techniques compare to one another, due to the lack of an agreed-upon evaluation metric and optimization for different constraints on the initialization time and query time. In this work, we give the first large-scale study of performance predictors by analyzing 31 techniques ranging from learning curve extrapolation, to weight-sharing, to supervised learning, to zero-cost proxies. We test a number of correlation- and rank-based performance measures in a variety of settings, as well as the ability of each technique to speed up predictor-based NAS frameworks. Our results act as recommendations for the best predictors to use in different settings, and we show that certain families of predictors can be combined to achieve even better predictive power, opening up promising research directions. Our code, featuring a library of 31 performance predictors, is available at https://github.com/automl/naslib.
+
+# 1 Introduction
+
+Neural architecture search (NAS) is a popular area of machine learning, which aims to automate the process of developing neural architectures for a given dataset. Since 2017, a wide variety of NAS techniques have been proposed [78, 45, 32, 49]. While the first NAS techniques trained thousands of architectures to completion and then evaluated the performance using the final validation accuracy [78], modern algorithms use more efficient strategies to estimate the performance of partially-trained or even untrained neural networks [11, 2, 54, 34, 38].
+
+Recently, many performance prediction methods have been proposed based on training a model to predict the final validation accuracy of an architecture just from an encoding of the architecture. Popular choices for these models include Gaussian processes [60, 17, 51], neural networks [36, 54, 65, 69], tree-based methods [33, 55], and so on. However, these methods often require hundreds of fully-trained architectures to be used as training data, thus incurring high initialization time. In contrast, learning curve extrapolation methods [11, 2, 20] need little or no initialization time, but each individual prediction requires partially training the architecture, incurring high query time. Very recently, a few techniques have been introduced which are fast both in query time and initialization time [38, 1], computing predictions based on a single minibatch of data. Finally, using shared weights [45, 4, 32] is a popular paradigm for NAS [73, 25], although the effectiveness of these methods in ranking architectures is disputed [53, 74, 76].
+
+Despite the widespread use of performance predictors, it is not known how methods from different families compare to one another. While there have been some analyses on the best predictors within each class [41, 72], for many predictors, the only evaluation is from the original work that proposed the method. Furthermore, no work has previously compared the predictors across different families of performance predictors. This leads to two natural questions: how do zero-cost methods, model-based methods, learning curve extrapolation methods, and weight sharing methods compare to one another across different constraints on initialization time and query time? Furthermore, can predictors from different families be combined to achieve even better performance?
+
+![](images/8ef65ff2a4bcf9b65d26fffcc3b0e9d5d7feb603c89effe903da6194e6e8e872.jpg)  
+Figure 1: Categories of performance predictors (left). Kendall Tau rank correlation for performance predictors with respect to initialization time and query time (right). Each type of predictor is plotted differently based on whether it allows variable initialization time and/or variable query time. For example, the sixteen model-based predictors have a fixed query time and variable initialization time, so they are plotted as curves parallel to the X-Z plane.
+
+In this work, we answer the above questions by giving the first large-scale study of performance predictors for NAS. We study 31 predictors across four popular search spaces and four datasets: NAS-Bench-201 [13] with CIFAR-10, CIFAR-100, and ImageNet16-120, NAS-Bench-101 [71] and DARTS [32] with CIFAR-10, and NAS-Bench-NLP [21] with Penn TreeBank. In order to give a fair comparison among different classes of predictors, we run a full portfolio of experiments, measuring the Pearson correlation and rank correlation metrics (Spearman, Kendall Tau, and sparse Kendall Tau), across a variety of initialization time and query time budgets. We run experiments using a training and test set of architectures generated both uniformly at random, as well as by mutating the highest-performing architectures (the latter potentially more closely resembling distributions encountered during an actual NAS run). Finally, we test the ability of each predictor to speed up NAS algorithms, namely Bayesian optimization [36, 54, 69, 51] and predictor-guided evolution [66, 59].
+
+Since many predictors so far had only been evaluated on one search space, our work shows which predictors have consistent performance across search spaces. Furthermore, by conducting a study with three axes of comparison (see Figure 1), and by comparing various types of predictors, we see a more complete view of the state of performance predictor techniques that leads to interesting insights. Notably, we show that the performance of predictors from different families are complementary and can be combined to achieve significantly higher performance. The success of these experiments opens up promising avenues for future work.
+
+Overall, our experiments bridge multiple areas of NAS research and act as recommendations for the best predictors to use under different runtime constraints. Our code, based on the NASLib library [52], can be used as a testing ground for future performance prediction techniques. In order to ensure reproducibility of the original results, we created a table to clarify which of the 31 predictors had previously published results on a NAS-Bench search space, and how these published results compared to our results (Table 7). We also adhere to the NeurIPS 2021 checklist along with the specialized NAS best practices checklist [31].
+
+Our contributions. We summarize our main contributions below.
+
+• We conduct the first large-scale study of performance predictors for neural architecture search by comparing model-based methods, learning curve extrapolation methods, zero-cost methods, and weight sharing methods across a variety of settings.   
+• We release a comprehensive library of 31 performance predictors on four different search spaces.   
+• We show that different families of performance predictors can be combined to achieve substantially better predictive power than any single predictor.
+
+# 2 Related Work
+
+NAS has been studied since at least the 1990s [19, 58], and has been revitalized in the last few years [78]. While initial techniques focused on reinforcement learning [78, 45] and evolutionary search [37, 49], one-shot NAS algorithms [32, 12, 4] and predictor-based NAS algorithms [65, 54, 69] have recently become popular. We give a brief survey of performance prediction techniques in Section 3. For a survey on NAS, see [15]. The most widely used type of search space in prior work is the cell-based search space [79], where the architecture search is over a relatively small directed acyclic graph representing an architecture.
+
+A few recent works have compared different performance predictors on popular cell-based search spaces for NAS. Siems et al. [55] studied graph neural networks and tree-based methods, and found that gradient-boosted trees and graph isomorphism networks performed the best. However, the comparison was only on a single search space and dataset, and the explicit goal was to achieve maximum performance given a training set of around 60 000 architectures. Another recent paper [41] studied various aspects of supernetwork training, and separately compared four model-based methods: random forest, MLP, LSTM, and GATES [42]. However, the comparisons were again on a single search space and dataset and did not compare between multiple families of performance predictors. Other papers have proposed new model-based predictors and compared the new predictors to other model-based baselines [34, 65, 54, 69]. Finally, a recent paper analyzed training heuristics to make weight-sharing more effective at ranking architectures [72]. To the best of our knowledge, no prior work has conducted comparisons across multiple families of performance predictors.
+
+# 3 Performance Prediction Methods for NAS
+
+In NAS, given a search space $\mathcal { A }$ , the goal is to find $a ^ { * } = \operatorname * { a r g m i n } _ { a \in { \mathcal { A } } } f ( a )$ , where $f$ denotes the validation error of architecture $a$ after training on a fixed dataset for a fixed number of epochs $E$ . Since evaluating $f ( a )$ typically takes hours (as it requires training a neural network from scratch), many NAS algorithms make use of performance predictors to speed up this process. A performance predictor $f ^ { \prime }$ is defined generally as any function which predicts the final accuracy or ranking of architectures, without fully training the architectures. That is, evaluating $f ^ { \prime }$ should take less time than evaluating $f$ , and $\{ f ^ { \prime } ( a ) \mid a \in \mathcal { A } \}$ should ideally have high correlation or rank correlation with $\{ f ( a ) \mid a \in { \bar { \mathcal { A } } } \}$ .
+
+Each performance predictor is defined by two main routines: an initialization routine which performs general pre-computation, and a query routine which performs the final architecture-specific computation: it takes as input an architecture specification, and outputs its predicted accuracy. For example, one of the simplest performance predictors is early stopping: for any query $( a )$ , train $a$ for $E / 2$ epochs instead of $E$ [77]. In this case, there is no general pre-computation, so initialization time is zero. On the other hand, the query time for each input architecture is high because it involves training the architecture for $E / 2$ epochs. In fact, the runtime of the initialization and query routines varies substantially based on the type of predictor. In the context of NAS algorithms, the initialization routine is typically performed once at the start of the algorithm, and the query routine is typically performed many times throughout the NAS algorithm. Some performance predictors also make use of an update routine, when part of the computation from initialization needs to be updated without running the full procedure again (for example, in a NAS algorithm, a model may be updated periodically based on newly trained architectures). Now we give an overview of the main families of predictors. See Figure 1 (left) for a taxonomy of performance predictors.
+
+Model-based (trainable) methods. The most common type of predictor, the model-based predictor, is based on supervised learning. The initialization routine consists of fully training many architectures (i.e., evaluating $f ( a )$ for many architectures $a \in { \mathcal { A } }$ ) to build a training set of datapoints $\{ a , f ( a ) \}$ . Then a model $f ^ { \prime }$ is trained to predict $f ( a )$ given $a$ . While the initialization time for model-based predictors is very high, the query time typically takes less than a second, which allows thousands of predictions to be made throughout a NAS algorithm. The model is also updated regularly based on the new datapoints. These predictors are typically used within BO frameworks [36, 54], evolutionary frameworks [66], or by themselves [67], to perform NAS. Popular choices for the model include tree-based methods (where the features are the adjacency matrix representation of the architectures) [33, 55], graph neural networks [36, 54], Gaussian processes [47, 51], and neural networks based on specialized encodings of the architecture [69, 42].
+
+Learning curve-based methods. Another family predicts the final performance of architectures using only a partially trained network, by extrapolating the learning curve. This is accomplished by fitting the partial learning curve to an ensemble of parametric models [11], or by simply summing the training losses observed so far [50]. Early stopping as described earlier is also a learning curve-based method. Learning curve methods do not require any initialization time, yet the query time typically takes minutes or hours, which is orders of magnitude slower than the query time in model-based methods. Learning curve-based methods can be used in conjunction with multi-fidelty algorithms, such as Hyperband or BOHB [27, 16, 24].
+
+Hybrid methods. Some predictors are hybrids between learning curve and model-based methods. These predictors train a model at initialization time to predict $f ( a )$ given both $a$ and a partial learning curve of $a$ as features. Models in prior work include an SVR [2], or a Bayesian neural network [20]. Although the query time and initialization time are both high, hybrid predictors tend to have strong performance.
+
+Zero-cost methods. Another class of predictors have no initialization time and very short query times (so-called “zero-cost” methods). These predictors compute statistics from just a single forward/backward propagation pass for a single minibatch of data, by computing the correlation of activations within a network [38], or by adapting saliency metrics proposed in pruning-at-initialization literatures [23, 1]. Similar to learning curve-based methods, since the only computation is specific to each architecture, the initialization time is zero. Zero-cost methods have recently been used to warm start NAS algorithms [1].
+
+Weight sharing methods. Weight sharing [45] is a popular approach to substantially speed up NAS, especially in conjunction with a one-shot algorithm [32, 12]. In this approach, all architectures in the search space are combined to form a single over-parameterized supernetwork. By training the weights of the supernetwork, all architectures in the search space can be evaluated quickly using this set of weights. To this end, the supernetwork can be used as a performance predictor. This results in NAS algorithms [32, 28] which are significantly faster than sequential NAS algorithms, such as evolution or Bayesian optimization. Recent work has shown that although the shared weights are sometimes not effective at ranking architectures [53, 74, 76], one-shot NAS techniques using shared weights still achieve strong performance [73, 25].
+
+Tradeoff between intialization and query time. The main families mentioned above all have different initialization and query times. The tradeoffs between initialization time, query time, and performance depend on a few factors such as the type of NAS algorithm and its total runtime budget, and different settings are needed in different situations. For example, if there are many architectures whose performance we want to estimate, then we should have a low query time, and if we have a high total runtime budget, then we can afford a high initialization time. We may also change our runtime budget throughout the run of a single NAS algorithm. For example, at the start of a NAS algorithm, we may want to have coarse estimates of a large number of architectures (low initialization time, low query time such as zero-cost predictors). As the NAS algorithm progresses, it is more desirable to receive higher-fidelity predictions on a smaller set of architectures (model-based or hybrid predictors). The exact budgets depend on the type of NAS algorithm.
+
+Choice of performance predictors. We analyze 31 performance predictors defined in prior work: BANANAS [69], Bayesian Linear Regression [6], BOHAMIANN [57], BONAS [54], DNGO [56], Early Stopping with Val. Acc. (e.g. [77, 27, 16, 79]) Early Stopping with Val. Loss. [50], Fisher [1], Gaussian Process (GP) [48], GCN [75], Grad Norm [1], Grasp [64], Jacobian Covariance [38], LCE [11], LCE-m [20], LcSVR [2], LGBoost/GBDT [33], MLP [69], NAO [35], NGBoost [55], OneShot [73], Random Forest (RF) [55], Random Search with Weight Sharing (RSWS) [26], SemiNAS [34], SNIP [23], SoTL [50], SoTL-E [50], Sparse GP [3], SynFlow [61], Variational Sparse GP [63], and XGBoost [55]. For any method that did not have an architecture encoding already defined (such as the tree-based methods, GP-based methods, and Bayesian Linear Regression), we use the standard adjacency matrix encoding, which consists of the adjacency matrix of the architecture along with a one-hot list of the operations [71, 68]. By open-sourcing our code, we encourage implementing more (existing and future) performance predictors which can then be compared to the 31 which we focus on in this work. In Section B.1, we give descriptions and detailed implementation details for each performance predictor. In Section D, we give a table that describes for which predictors we were able to reproduce published results, and for which predictors it is not possible (e.g., since some predictors were released before the creation of NAS benchmarks).
+
+![](images/cac2d076145d762a60a6f0cf6b3b21b22efe01ee2cac10389179b735bb57d3b9.jpg)  
+Figure 2: The performance predictors with the highest Kendall Tau values for all initialization time and query time budgets on NAS-Bench-201, NAS-Bench-101, NAS-Bench-NLP and DARTS. For example, on NAS-Bench-201 CIFAR-10 (left) with an initialization time of $1 0 ^ { 6 }$ seconds and query time of 10 seconds, XGBoost achieves a Kendall Tau value of .73 which is the highest value out of the 31 predictors that we tested at that budget.
+
+# 4 Experiments
+
+We now discuss our experimental setup and results. We discuss reproducibility in Sections A and D, and our code (based on the NASLib library [52]) is available at https://github.com/automl/ naslib. We split up our experiments into two categories: evaluating the performance of each predictor with respect to various correlation metrics (Section 4.1), and evaluating the ability of each predictor to speed up predictor-based NAS algorithms (Section 4.2). We start by describing the four NAS benchmarks used in our experiments.
+
+NAS benchmark datasets. NAS-Bench-101 [71] consists of over 423 000 unique neural architectures with precomputed training, validation, and test accuracies after training for 4, 12, 36, and 108 epochs on CIFAR-10 [71]. The cell-based search space consists of five nodes which can take on any directed acyclic graph (DAG) structure, and each node can be one of three operations. Since learning curve information is only available at four epochs, it is not possible to run most learning curve extrapolation methods on NAS-Bench-101. NAS-Bench-201 [13] consists of 15 625 architectures (out of which 6 466 are unique after removing isomorphisms [13]). Each architecture has full learning curve information for training, validation, and test losses/accuracies for 200 epochs on CIFAR-10 [22], CIFAR-100, and ImageNet-16-120 [10]. The search space consists of a cell which is a complete DAG with 4 nodes. Each edge can take one of five different operations. The DARTS search space [32] is significantly larger with roughly $1 0 ^ { 1 8 }$ architectures. The search space consists of two cells, each with seven nodes. The first two nodes are inputs from previous layers, and the intermediate four nodes can take on any DAG structure such that each node has two incident edges. The last node is the output node. Each edge can take one of eight operations. In our experiments, we make use of the training data from NAS-Bench-301 [55], which consists of 23 000 architectures drawn uniformly at random and trained on CIFAR-10 for 100 epochs. Finally, the NAS-Bench-NLP search space [21] is even larger, at $1 0 ^ { 5 3 }$ LSTM-like cells, each with at most 25 nodes in any DAG structure. Each cell can take one of seven operations. In our experiments, we use the NAS-Bench-NLP dataset, which consists of 14 000 architectures drawn uniformly at random and trained on Penn Tree Bank [40] for 50 epochs.
+
+Hyperparameter tuning. Although we used the code directly from the original repositories (sometimes making changes when necessary to adapt to NAS-Bench search spaces), the predictors had significantly different levels of hyperparameter tuning. For example, some of the predictors had undergone heavy hyperparameter tuning on the DARTS search space (used in NAS-Bench-301), while other predictors (particularly those from 2017 or earlier) had never been run on cell-based search spaces. Furthermore, most predictor-based NAS algorithms can utilize cross-validation to tune the predictor periodically throughout the NAS algorithm. This is because the bottleneck for predictorbased NAS algorithms is typically the training of architectures, not fitting the predictor [56, 30, 16]. Therefore, it is fairer and also more informative to compare performance predictors which have had the same level of hyperparameter tuning through cross-validation. For each search space, we run random search on each performance predictor for 5000 iterations, with a maximum total runtime of 15 minutes. The final evaluation uses a separate test set. The hyperparameter value ranges for each predictor can be found in Section B.2.
+
+# 4.1 Performance Predictor Evaluation
+
+We evaluate each predictor based on three axes of comparison: initialization time, query time, and performance. We measured performance with respect to several different metrics: Pearson correlation and three different rank correlation metrics (Spearman, Kendall Tau, and sparse Kendall Tau [72, 55]). The experimental setup is as follows: the predictors are tested with 11 different initialization time budgets and 14 different query time budgets, leading to a total of 154 settings. On NAS-Bench-201 CIFAR-10, the 11 initialization time budgets are spaced logarithmically from 1 second to $1 . 8 \times 1 0 ^ { 7 }$ seconds on a $1 0 8 0 \mathrm { T i }$ GPU (which corresponds to training 1000 random architectures on average) which is consistent with experiments conducted in prior work [65, 69, 34]. For other search spaces, these times are adjusted based on the average time to train 1000 architectures. The 14 query time budgets are spaced logarithmically from 1 second to $1 . 8 \times 1 0 ^ { 4 }$ seconds (which corresponds to training an architecture for 199 epochs). These times are adjusted for other search spaces based on the training time and different number of epochs. Once the predictor is initialized, we draw a test set of 200 architectures uniformly at random from the search space. For each architecture in the test set, the predictor uses the specified query time budget to make a prediction. We then evaluate the quality of the predictions using the metrics described above. We average the results over 100 trials for each (initialization time, query time) pair.
+
+Results and discussion. Figure 1 shows a full three-dimensional plot for NAS-Bench-201 on CIFAR-10 over initialization time, query time, and Kendall Tau rank correlation. Of the 31 predictors we tested, we found that just seven of them are Pareto-optimal with respect to Kendall Tau, initialization time, and query time. That is, only seven algorithms have the highest Kendall Tau value for at least one of the 154 query time/initialization time budgets on NAS-Bench-201 CIFAR-10. This can be seen more clearly in Figure 2 (left), which is a view from above Figure 1: each lattice point displays the predictor with the highest Kendall Tau value for the corresponding budget. In Figure 2 (right), we plot the Pareto-optimal predictors for five different dataset/search space combinations. In Section B.3, we give the full 3D plots and report the variance across trials for each method. In Figure 4 (left), we also plot the Pearson and Spearman correlation coefficients for NAS-Bench-201 CIFAR-10. The trends between these measures are largely the same, although we see that SemiNAS performs better on the rank-based metrics. For the rest of this section, we focus on the popular Kendall Tau metric, giving the full results for the other metrics in Section B.3.
+
+We see similar trends across DARTS and the two NAS-Bench-201 datasets. NAS-Bench-NLP also has fairly similar trends, although early stopping performs comparatively stronger. NAS-Bench-101 is different from the other search spaces both in terms of the topology and the benchmark itself, which we discuss later in this section.
+
+In the low initialization time, low query time region, Jacobian covariance or SynFlow perform well across NAS-Bench-101 and NAS-Bench-201. However, none of the six zero-cost methods perform well on the larger DARTS search space. Weight sharing (which also has low initialization and low query time, as seen in Figure 1), did not yield high Kendall Tau values for these search spaces, either, which is consistent with recent work [53, 74, 76]. However, rank correlation is not as crucial to one-shot NAS algorithms as it is for black box predictor-based methods, as demonstrated by prior one-shot NAS methods that do perform well [25, 73, 32, 28, 12]. In the low initialization time, high query time region, sum of training losses (SoTL-E) consistently performed the best, outperforming other learning-curve based methods.
+
+![](images/1a336b83714b502dfa447d28dd46ecffcc5c4c07832f5707486bd7c0c8470d68.jpg)  
+Figure 3: Percentage of OMNI’s Kendall Tau value compared to the next-best predictors for each budget constraint.
+
+The high initialization time, low query time region (especially the bottom row of the plots, corresponding to a query time of 1 second) is by far the most competitive region in the recent NAS literature. Sixteen of the 31 predictors had query times under one second, because many NAS algorithms are designed to initialize (and continually update) performance predictors that are used to quickly query thousands of candidate architectures. GCN and SemiNAS, the specialized GCN/semi-supervised methods, perform especially well in the first half of this critical region, when the initialization time is relatively low. However, boosted tree methods actually performed best in the second half of the critical region where the initialization time is high, which is consistent with prior work [33, 55]. Recall that for model-based methods, the initialization time corresponds to training architectures to be used as training data for the performance predictor. Therefore, our results suggest that techniques which can extract better latent features of the architectures can make up for a small training dataset, but methods based purely on performance data work better when there is enough such data.
+
+Perhaps the most interesting finding is that on NAS-Bench-101/201, SynFlow and Jacobian covariance, which take three seconds each to compute, both outperform all model-based methods even after $3 0$ hours of initialization. Put another way, NAS algorithms that make use of model-based predictors may be able to see substantial improvements by using Jacobian covariance instead of a model-based predictor in the early iterations.
+
+The Omnipotent Predictor. One conclusion from Figure 2 is that different types of predictors are specialized for specific initialization time and query time constraints. A natural follow-up question is whether different families are complementary and can be combined to achieve stronger performance. In this section, we run a proof-of-concept to answer this question. We combine the best-performing predictors from three different families in a simple way: the best learning curve method (SoTL-E), and the best zero-cost method (Jacobian covariance), are used as additional input features for a model-based predictor (we separately test SemiNAS and NGBoost). We call this method OMNI, the omnipotent predictor. We give results in Figure 3 and pseudo-code as well as additional experiments in Section B.4. In contrast to all other predictors, the performance of OMNI is strong across almost all budget constraints and search spaces. In some settings, OMNI achieves a Kendall Tau value $30 \%$ higher than the next-best predictors.
+
+The success of OMNI verifies that the information learned by different families of predictors are complementary: the information learned by extrapolating a learning curve, by computing a zero-cost proxy, and by encoding the architecture, all improve performance. We further confirm this by running an ablation study for OMNI in Section B.4. We can hypothesize that each predictor type measures distinct quantities: SOTL-E measures the training speed, zero-cost predictors measure the covariance between activations on different datapoints, and model-based predictors simply learn patterns between the architecture encodings and the validation accuracies. Finally, while we showed a proof-of-concept, there are several promising areas for future work such as creating ensembles of the model-based approaches, combining zero-cost methods with model-based methods in more sophisticated ways, and giving a full quantification of the correlation among different families of predictors.
+
+![](images/db818d6a83efa7fb904fdc04c428ec375353f40a9141d13d9b6146e28a4e0d71.jpg)  
+Figure 4: The best predictors on NAS-Bench-201 CIFAR-10 with respect to Pearson (left) and Spearman (middle). Kendall Tau values from a mutation-based training and test set (right).
+
+NAS-Bench-101: a more complex search space. In Figure 2, the plot for NAS-Bench-101 looks significantly different than the plots for the other search spaces, for two reasons. The first reason is a technical one: the NAS-Bench-101 API only gives the validation accuracy at four epochs, and does not give the training loss for any epochs. Therefore, we could not implement SoTL or any learning curve extrapolation method. However, all sixteen of the model-based predictors were implemented on NAS-Bench-101. In this case, BANANAS significantly outperformed the next-best predictors (GCN and SemiNAS) across every initialization time. One explanation is due to the complexity of the NAS-Bench-101 search space: while all NAS-Bench-201 architectures have the same graph topology and DARTS architectures’ nodes have exactly two incoming edges, the NAS-Bench-101 search space is much more diverse with architectures ranging from a single node and no edges, to five nodes with nine connecting edges. In fact, the architecture encoding used in BANANAS, the path encoding, was designed specifically to deal with the complexity of the NAS-Bench-101 search space (replacing the standard adjacency matrix encoding). To test this explanation, in Appendix B we run several of the simpler tree-based and GP-based predictors using the path encoding, and we see that these methods now surpass BANANAS in performance.
+
+A mutation-based test set. The results from Figure 2 used a test set drawn uniformly at random from the search space (and the training set used by model-based predictors was also drawn uniformly at random). However, neighborhood-based NAS algorithms such as local search, regularized evolution, and some versions of Bayesian optimization consider architectures which are local perturbations of the architectures encountered so far. Therefore, the predictors used in these NAS algorithms must be able to distinguish architectures which are local mutations of a small set of seed architectures.
+
+We run an experiment in which the test set is created by mutating architectures from an initial set of seed architectures. Specifically, we draw a set of 50 random architectures and choose the five with the highest validation accuracy as seed architectures. Then we create a set of 200 test architectures by randomly mutating up to three attributes of the seed architectures. Therefore, all architectures in the test set are at most an edit distance of three from a seed architecture, where two architectures are a single edit distance away if they differ by one operation or edge.
+
+We create the training set by randomly choosing architectures from the test set and mutating one random attribute. As in all of our experiments, we ensure that the training set and test set are disjoint. In Figure 4 (right), we plot the correlation results for NAS-Bench-201 CIFAR-10. While the zero-cost and learning curve-based approaches have similar performance, the model-based approaches have significantly worse performance compared to the uniform random setting. This is because the average edit distance between architectures in the test set is low, making it significantly harder for model-based predictors to distinguish the performance of these architectures, even when using a training set that is based on mutations of the test set. In fact, interestingly, the performance of many model-based approaches starts to perform worse after $1 0 ^ { 6 }$ seconds. SemiNAS in particular performs much worse in this setting, and boosted trees have comparatively stronger performance in this setting.
+
+![](images/c15699c76c80aa1243fa92c24047ed5b53dff1845e874054c71f1e142d0b0327.jpg)  
+Figure 5: Validation error vs. runtime for the predictor-guided evolution framework and the Bayesian optimization $^ +$ predictor framework using different predictors.
+
+# 4.2 Predictor-Based NAS Experiments
+
+Now we evaluate the ability of each model-based performance predictor to speed up NAS. We use two popular predictor-based NAS methods: the predictor-guided evolution framework [66, 59], and the Bayesian optimization $^ +$ predictor framework [17, 36, 54]. The predictor-guided evolution framework is an iterative procedure in which the best architectures in the current population are mutated to create a set of candidate architectures. A predictor (trained on the entire population) chooses $k$ architectures which are then evaluated. In our experiments, the candidate pool is created by mutating the top five architectures 40 times each, and we set $k = 2 0$ . For each predictor, we run predictor-guided evolution for 25 iterations and average the results over 100 trials. The $\mathrm { B O + }$ predictor framework is similar to the evolution framework, but an ensemble of three performance predictors are used so that uncertainty estimates for each prediction can be computed. In each iteration, the candidate architectures whose predictions maximize an acquisition function are then evaluated. Similar to prior work, we use independent Thompson sampling [69], as the acquisition function, and an ensemble is created by using a different ordering of the training set and different random weight initializations (if applicable) of the same predictor. In each iteration, the top 20 architectures are chosen from a randomly sampled pool of 200 architectures.
+
+In Figure 5, we present results for both NAS frameworks on NAS-Bench-201 CIFAR-10 and ImageNet16-120 for the 16 model-based predictors. We also test OMNI, using its lowest query time setting (consisting of NGBoost $^ +$ Jacobian covariance), and another version of OMNI that replaces NGBoost with SemiNAS. Our results show that the model-based predictors with the top Kendall Tau rank correlations in the low query time region from Figure 2 also roughly achieve the best performance when applied for NAS: SemiNAS and NAO perform the best for shorter runtime, and boosted trees perform best for longer runtime. OMNI(NGBoost) consistently outperforms NGBoost, and OMNI(SemiNAS) often achieves top performance. This suggests that using zero-cost methods in conjunction with model-based methods is a promising direction for future study.
+
+# 4.3 So, how powerful are performance predictors?
+
+Throughout Section 4, we tested performance predictors in a variety of settings, by varying the search spaces, datasets, runtime budgets, and training/test distributions. We saw largely the same trends among all of our experiments. Interesting findings included the success of zero-cost predictors even when compared to model-based predictors and learning curve extrapolation predictors with longer runtime budgets, and the fact that information from different families of predictors are complementary. When choosing a performance predictor for new applications, we recommend deciding on a target initialization time and query time budget, consulting Figures 2 and 6, and then combining the best predictors from the desired runtime setting, similar to OMNI. For example, if a performance predictor with medium initialization time and low runtime is desired for a search space similar to NAS-Bench201 or DARTS, we recommend using NGBoost with Jacobian covariance and SynFlow as additional features.
+
+# 5 Societal Impact
+
+Our hope is that our work will have a positive impact on the AutoML community by making it quicker and easier to develop and fairly compare performance predictors. For example, AutoML practitioners can consult our experiments to more easily decide on the performance prediction methods best suited to their application, rather than conducting computationally intensive experiments of their own [43]. Furthermore, AutoML researchers can use our library to develop new performance prediction techniques and compare new methods to 31 other algorithms across four search spaces. Since the topic of this work is AutoML, it is a level of abstraction away from real applications. This work may be used to improve deep learning applications, both beneficial (e.g. reducing $\mathrm { C O _ { 2 } }$ emissions), or harmful (e.g. creating language models with heavy bias) to society.
+
+# 6 Conclusions and Limitations
+
+In this work, we gave the first large-scale study of performance predictors for neural architecture search. We compared 31 different performance predictors, including learning curve extrapolation methods, weight sharing methods, zero-cost methods, and model-based methods. We tested the performance of the predictors in a variety of settings and with respect to different metrics. Although we ran experiments on four different search spaces, it will be interesting to extend our experiments to even more machine learning tasks beyond image classification and language modeling.
+
+Our new predictor, OMNI, is the first predictor to combine complementary information from three families of performance preditors, leading to substantially improved performance. While the simplicity of OMNI is appealing, it also opens up new directions for future work by combining different predictors in more sophisticated ways. To facilitate follow-up work, we release our code featuring a library of performance predictors. Our goal is for our repository to grow over time as it is used by the community, so that experiments in our library can be even more comprehensive.
+
+# Acknowledgments and Disclosure of Funding
+
+This work was done while CW and YL were employed at Abacus.AI. AZ and FH acknowledge support by the European Research Council (ERC) under the European Union Horizon 2020 research and innovation programme through grant no. 716721, and by BMBF grant DeToL. BR was supported by the Clarendon Fund of University of Oxford.
+
+References   
+[1] Mohamed S Abdelfattah, Abhinav Mehrotra, Łukasz Dudziak, and Nicholas Donald Lane. Zero-cost proxies for lightweight nas. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   
+[2] Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. arXiv preprint arXiv:1705.10823, 2017.   
+[3] Matthias Bauer, Mark van der Wilk, and Carl Edward Rasmussen. Understanding probabilistic sparse gaussian process approximations. arXiv preprint arXiv:1606.04820, 2016.   
+[4] Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In Proceedings of the International Conference on Machine Learning (ICML), pages 550–559, 2018.   
+[5] Eli Bingham, Jonathan P Chen, Martin Jankowiak, Fritz Obermeyer, Neeraj Pradhan, Theofanis Karaletsos, Rohit Singh, Paul Szerlip, Paul Horsfall, and Noah D Goodman. Pyro: Deep universal probabilistic programming. The Journal of Machine Learning Research, 20(1):973– 978, 2019.   
+[6] Christopher M Bishop. Pattern recognition and machine learning. springer, 2006.   
+[7] Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. Proceedings of the International Conference on Learning Representations (ICLR), 2019.   
+[8] Akshay Chandrashekaran and Ian R Lane. Speeding up hyper-parameter optimization by extrapolation of learning curves using previous builds. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 477–492. Springer, 2017.   
+[9] Tianqi Chen and Carlos Guestrin. Xgboost: A scalable tree boosting system. In Proceedings of the 22nd acm sigkdd international conference on knowledge discovery and data mining, pages 785–794, 2016.   
+[10] Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the CIFAR datasets. CoRR, abs/1707.08819, 2017.   
+[11] Tobias Domhan, Jost Tobias Springenberg, and Frank Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. In Twenty-Fourth International Joint Conference on Artificial Intelligence, 2015.   
+[12] Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proceedings of the IEEE Conference on computer vision and pattern recognition, pages 1761–1770, 2019.   
+[13] Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   
+[14] Tony Duan, Avati Anand, Daisy Yi Ding, Khanh K Thai, Sanjay Basu, Andrew Ng, and Alejandro Schuler. Ngboost: Natural gradient boosting for probabilistic prediction. In International Conference on Machine Learning, pages 2690–2700. PMLR, 2020.   
+[15] Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018.   
+[16] Stefan Falkner, Aaron Klein, and Frank Hutter. Bohb: Robust and efficient hyperparameter optimization at scale. In Proceedings of the International Conference on Machine Learning (ICML), 2018.   
+[17] Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with Bayesian optimisation and optimal transport. In Advances in Neural Information Processing Systems, pages 2016–2025, 2018.   
+[18] Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, and Tie-Yan Liu. Lightgbm: A highly efficient gradient boosting decision tree. Advances in neural information processing systems, 30:3146–3154, 2017.   
+[19] Hiroaki Kitano. Designing neural networks using genetic algorithms with graph generation system. Complex systems, 4(4):461–476, 1990.   
+[20] Aaron Klein, Stefan Falkner, Jost Tobias Springenberg, and Frank Hutter. Learning curve prediction with Bayesian neural networks. ICLR 2017, 2017.   
+[21] Nikita Klyuchnikov, Ilya Trofimov, Ekaterina Artemova, Mikhail Salnikov, Maxim Fedorov, and Evgeny Burnaev. Nas-bench-nlp: neural architecture search benchmark for natural language processing. arXiv preprint arXiv:2006.07116, 2020.   
+[22] Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   
+[23] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip Torr. SNIP: Single-shot network pruning based on connection sensitivity. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   
+[24] Liam Li, Kevin Jamieson, Afshin Rostamizadeh, Ekaterina Gonina, Moritz Hardt, Benjamin Recht, and Ameet Talwalkar. A system for massively parallel hyperparameter tuning. In Proceedings of the Conference on Machine Learning Systems, 2020.   
+[25] Liam Li, Mikhail Khodak, Maria-Florina Balcan, and Ameet Talwalkar. Geometry-aware gradient algorithms for neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   
+[26] Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. arXiv preprint arXiv:1902.07638, 2019.   
+[27] Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. arXiv preprint arXiv:1603.06560, 2016.   
+[28] Hanwen Liang, Shifeng Zhang, Jiacheng Sun, Xingqiu He, Weiran Huang, Kechen Zhuang, and Zhenguo Li. Darts+: Improved differentiable architecture search with early stopping. arXiv preprint arXiv:1909.06035, 2019.   
+[29] Andy Liaw, Matthew Wiener, et al. Classification and regression by randomforest. R news, 2(3):18–22, 2002.   
+[30] Marius Lindauer, Katharina Eggensperger, Matthias Feurer, Stefan Falkner, André Biedenkapp, and Frank Hutter. Smac v3: Algorithm configuration in python. URL https://github. com/automl/SMAC3, 2017.   
+[31] Marius Lindauer and Frank Hutter. Best practices for scientific research on neural architecture search. arXiv preprint arXiv:1909.02453, 2019.   
+[32] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018.   
+[33] Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture search with gbdt. arXiv preprint arXiv:2007.04785, 2020.   
+[34] Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Enhong Chen, and Tie-Yan Liu. Semi-supervised neural architecture search. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2020.   
+[35] Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2018.   
+[36] Lizheng Ma, Jiaxu Cui, and Bo Yang. Deep neural architecture search with deep graph Bayesian optimization. In 2019 IEEE/WIC/ACM International Conference on Web Intelligence (WI), pages 500–507. IEEE, 2019.   
+[37] Krzysztof Maziarz, Andrey Khorlin, Quentin de Laroussilhe, and Andrea Gesmundo. Evolutionary-neural hybrid agents for architecture search. arXiv preprint arXiv:1811.09828, 2018.   
+[38] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J Crowley. Neural architecture search without training. arXiv preprint arXiv:2006.04647, 2020.   
+[39] Szymon Jakub Mikler. Snip: Single-shot network pruning based on connection sensitivity. GitHub repository gahaalt/SNIP-pruning, 2019.   
+[40] Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan Cernock ˇ y, and Sanjeev Khudanpur. Recur- \` rent neural network based language model. In Annual conference of the international speech communication association, 2010.   
+[41] Xuefei Ning, Wenshuo Li, Zixuan Zhou, Tianchen Zhao, Yin Zheng, Shuang Liang, Huazhong Yang, and Yu Wang. A surgery of the neural architecture evaluators. arXiv preprint arXiv:2008.03064, 2020.   
+[42] Xuefei Ning, Yin Zheng, Tianchen Zhao, Yu Wang, and Huazhong Yang. A generic graph-based neural architecture encoding scheme for predictor-based nas. arXiv preprint arXiv:2004.01899, 2020.   
+[43] David Patterson, Joseph Gonzalez, Quoc Le, Chen Liang, Lluis-Miquel Munguia, Daniel Rothchild, David So, Maud Texier, and Jeff Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   
+[44] Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. Scikitlearn: Machine learning in python. the Journal of machine Learning research, 12:2825–2830, 2011.   
+[45] Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.   
+[46] Joaquin Quiñonero Candela and Carl Edward Rasmussen. A unifying view of sparse approximate gaussian process regression. J. Mach. Learn. Res., 6:1939–1959, December 2005.   
+[47] Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer School on Machine Learning, pages 63–71. Springer, 2003.   
+[48] Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer School on Machine Learning, pages 63–71. Springer, 2003.   
+[49] Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intelligence, volume 33, pages 4780–4789, 2019.   
+[50] Binxin Ru, Clare Lyle, Lisa Schut, Mark van der Wilk, and Yarin Gal. Revisiting the train loss: an efficient performance estimator for neural architecture search. arXiv preprint arXiv:2006.04492, 2020.   
+[51] Binxin Ru, Xingchen Wan, Xiaowen Dong, and Michael Osborne. Neural architecture search using Bayesian optimisation with weisfeiler-lehman kernel. arXiv preprint arXiv:2006.07556, 2020.   
+[52] Michael Ruchte, Arber Zela, Julien Siems, Josif Grabocka, and Frank Hutter. Naslib: a modular and flexible neural architecture search library, 2020.   
+[53] Christian Sciuto, Kaicheng Yu, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. arXiv preprint arXiv:1902.08142, 2019.   
+[54] Han Shi, Renjie Pi, Hang Xu, Zhenguo Li, James Kwok, and Tong Zhang. Bridging the gap between sample-based and one-shot neural architecture search with bonas. Advances in Neural Information Processing Systems, 33, 2020.   
+[55] Julien Siems, Lucas Zimmer, Arber Zela, Jovita Lukasik, Margret Keuper, and Frank Hutter. Nas-bench-301 and the case for surrogate benchmarks for neural architecture search. arXiv preprint arXiv:2008.09777, 2020.   
+[56] Jasper Snoek, Oren Rippel, Kevin Swersky, Ryan Kiros, Nadathur Satish, Narayanan Sundaram, Mostofa Patwary, Mr Prabhat, and Ryan Adams. Scalable Bayesian optimization using deep neural networks. In International conference on machine learning, pages 2171–2180, 2015.   
+[57] Jost Tobias Springenberg, Aaron Klein, Stefan Falkner, and Frank Hutter. Bayesian optimization with robust Bayesian neural networks. In Advances in Neural Information Processing Systems, pages 4134–4142, 2016.   
+[58] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.   
+[59] Yanan Sun, Xian Sun, Yuhan Fang, and Gary Yen. A new training protocol for performance predictors of evolutionary neural architecture search algorithms. arXiv preprint arXiv:2008.13187, 2020.   
+[60] Kevin Swersky, David Duvenaud, Jasper Snoek, Frank Hutter, and Michael Osborne. Raiders of the lost architecture: Kernels for Bayesian optimization in conditional parameter spaces. In NIPS workshop on Bayesian Optimization in Theory and Practice, December 2013.   
+[61] Hidenori Tanaka, Daniel Kunin, Daniel LK Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. arXiv preprint arXiv:2006.05467, 2020.   
+[62] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018.   
+[63] Michalis Titsias. Variational learning of inducing variables in sparse gaussian processes. In Artificial Intelligence and Statistics, pages 567–574, 2009.   
+[64] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   
+[65] Linnan Wang, Yiyang Zhao, Yuu Jinnai, and Rodrigo Fonseca. Alphax: exploring neural architectures with deep neural networks and monte carlo tree search. arXiv preprint arXiv:1805.07440, 2018.   
+[66] Chen Wei, Chuang Niu, Yiping Tang, and Jimin Liang. Npenas: Neural predictor guided evolution for neural architecture search. arXiv preprint arXiv:2003.12857, 2020.   
+[67] Wei Wen, Hanxiao Liu, Hai Li, Yiran Chen, Gabriel Bender, and Pieter-Jan Kindermans. Neural predictor for neural architecture search. arXiv preprint arXiv:1912.00848, 2019.   
+[68] Colin White, Willie Neiswanger, Sam Nolen, and Yash Savani. A study on encodings for neural architecture search. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2020.   
+[69] Colin White, Willie Neiswanger, and Yash Savani. Bananas: Bayesian optimization with neural architectures for neural architecture search. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.   
+[70] Antoine Yang, Pedro M Esperança, and Fabio M Carlucci. Nas evaluation is frustratingly hard. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   
+[71] Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. arXiv preprint arXiv:1902.09635, 2019.   
+[72] Kaicheng Yu, Rene Ranftl, and Mathieu Salzmann. How to train your super-net: An analysis of training heuristics in weight-sharing nas. arXiv preprint arXiv:2003.04276, 2020.   
+[73] Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   
+[74] Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one-shot neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   
+[75] Yuge Zhang. Neural predictor for neural architecture search. GitHub repository ultmaster/neuralpredictor.pytorch, 2020.   
+[76] Yuge Zhang, Zejun Lin, Junyang Jiang, Quanlu Zhang, Yujing Wang, Hui Xue, Chen Zhang, and Yaming Yang. Deeper insights into weight sharing in neural architecture search. arXiv preprint arXiv:2001.01431, 2020.   
+[77] Dongzhan Zhou, Xinchi Zhou, Wenwei Zhang, Chen Change Loy, Shuai Yi, Xuesen Zhang, and Wanli Ouyang. Econas: Finding proxies for economical neural architecture search. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11396–11404, 2020.   
+[78] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.   
+[79] Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 8697–8710, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] Our abstract and introduction accurately reflect our paper.   
+(b) Did you describe the limitations of your work? [Yes] See Section 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 5.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We discuss the ethics guidelines in Section 5.
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] We did not include theoretical results.   
+(b) Did you include complete proofs of all theoretical results? [N/A] We did not include theoretical results.
+
+3. If you ran experiments...
+
+(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)? [Yes] We included all code, data, and instructions in the supplementary material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] All training details are specified in the supplementary material.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We ran 100 trials for all experiments. Our plots that are performance vs. runtime (e.g. Figure 5) have error bars. For our Pareto-optimality plots (e.g. Figure 7), see the supplementary material for the error bars for all 31 predictors.   
+(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] We report the compute time and resources used in Section 4 and in the supplementary material.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We cite the creators of all code, data, and models used.   
+(b) Did you mention the license of the assets? [Yes] We mention the licenses in the supplementary material.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] We do not include new assets.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We did not use or release any datasets with personal data.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] The data we are using does not contain personal information or offensive content.
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] We did not run experiments with human subjects.   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] We did not run experiments with human subjects.   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] We did not run experiments with human subjects.

parse/train/6RB77-6-_oI/6RB77-6-_oI_content_list.json

@@ -0,0 +1,937 @@
+[
+    {
+        "type": "text",
+        "text": "How Powerful are Performance Predictors in Neural Architecture Search? ",
+        "text_level": 1,
+        "bbox": [
+            241,
+            122,
+            756,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Colin White1∗, Arber $\\mathbf { Z e l a ^ { 2 } }$ , Binxin $\\mathbf { R } \\mathbf { u } ^ { 3 }$ , Yang $\\mathbf { L i u } ^ { 1 }$ , Frank Hutter2,4 1 Abacus.AI, 2 University of Freiburg, 3 University of Oxford, 4 Bosch Center for Artificial Intelligence ",
+        "bbox": [
+            259,
+            219,
+            736,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            300,
+            535,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Early methods in the rapidly developing field of neural architecture search (NAS) required fully training thousands of neural networks. To reduce this extreme computational cost, dozens of techniques have since been proposed to predict the final performance of neural architectures. Despite the success of such performance prediction methods, it is not well-understood how different families of techniques compare to one another, due to the lack of an agreed-upon evaluation metric and optimization for different constraints on the initialization time and query time. In this work, we give the first large-scale study of performance predictors by analyzing 31 techniques ranging from learning curve extrapolation, to weight-sharing, to supervised learning, to zero-cost proxies. We test a number of correlation- and rank-based performance measures in a variety of settings, as well as the ability of each technique to speed up predictor-based NAS frameworks. Our results act as recommendations for the best predictors to use in different settings, and we show that certain families of predictors can be combined to achieve even better predictive power, opening up promising research directions. Our code, featuring a library of 31 performance predictors, is available at https://github.com/automl/naslib. ",
+        "bbox": [
+            233,
+            332,
+            766,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            574,
+            310,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture search (NAS) is a popular area of machine learning, which aims to automate the process of developing neural architectures for a given dataset. Since 2017, a wide variety of NAS techniques have been proposed [78, 45, 32, 49]. While the first NAS techniques trained thousands of architectures to completion and then evaluated the performance using the final validation accuracy [78], modern algorithms use more efficient strategies to estimate the performance of partially-trained or even untrained neural networks [11, 2, 54, 34, 38]. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, many performance prediction methods have been proposed based on training a model to predict the final validation accuracy of an architecture just from an encoding of the architecture. Popular choices for these models include Gaussian processes [60, 17, 51], neural networks [36, 54, 65, 69], tree-based methods [33, 55], and so on. However, these methods often require hundreds of fully-trained architectures to be used as training data, thus incurring high initialization time. In contrast, learning curve extrapolation methods [11, 2, 20] need little or no initialization time, but each individual prediction requires partially training the architecture, incurring high query time. Very recently, a few techniques have been introduced which are fast both in query time and initialization time [38, 1], computing predictions based on a single minibatch of data. Finally, using shared weights [45, 4, 32] is a popular paradigm for NAS [73, 25], although the effectiveness of these methods in ranking architectures is disputed [53, 74, 76]. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the widespread use of performance predictors, it is not known how methods from different families compare to one another. While there have been some analyses on the best predictors within each class [41, 72], for many predictors, the only evaluation is from the original work that proposed the method. Furthermore, no work has previously compared the predictors across different families of performance predictors. This leads to two natural questions: how do zero-cost methods, model-based methods, learning curve extrapolation methods, and weight sharing methods compare to one another across different constraints on initialization time and query time? Furthermore, can predictors from different families be combined to achieve even better performance? ",
+        "bbox": [
+            176,
+            853,
+            821,
+            882
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ef65ff2a4bcf9b65d26fffcc3b0e9d5d7feb603c89effe903da6194e6e8e872.jpg",
+        "image_caption": [
+            "Figure 1: Categories of performance predictors (left). Kendall Tau rank correlation for performance predictors with respect to initialization time and query time (right). Each type of predictor is plotted differently based on whether it allows variable initialization time and/or variable query time. For example, the sixteen model-based predictors have a fixed query time and variable initialization time, so they are plotted as curves parallel to the X-Z plane. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            820,
+            236
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            344,
+            825,
+            428
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we answer the above questions by giving the first large-scale study of performance predictors for NAS. We study 31 predictors across four popular search spaces and four datasets: NAS-Bench-201 [13] with CIFAR-10, CIFAR-100, and ImageNet16-120, NAS-Bench-101 [71] and DARTS [32] with CIFAR-10, and NAS-Bench-NLP [21] with Penn TreeBank. In order to give a fair comparison among different classes of predictors, we run a full portfolio of experiments, measuring the Pearson correlation and rank correlation metrics (Spearman, Kendall Tau, and sparse Kendall Tau), across a variety of initialization time and query time budgets. We run experiments using a training and test set of architectures generated both uniformly at random, as well as by mutating the highest-performing architectures (the latter potentially more closely resembling distributions encountered during an actual NAS run). Finally, we test the ability of each predictor to speed up NAS algorithms, namely Bayesian optimization [36, 54, 69, 51] and predictor-guided evolution [66, 59]. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since many predictors so far had only been evaluated on one search space, our work shows which predictors have consistent performance across search spaces. Furthermore, by conducting a study with three axes of comparison (see Figure 1), and by comparing various types of predictors, we see a more complete view of the state of performance predictor techniques that leads to interesting insights. Notably, we show that the performance of predictors from different families are complementary and can be combined to achieve significantly higher performance. The success of these experiments opens up promising avenues for future work. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Overall, our experiments bridge multiple areas of NAS research and act as recommendations for the best predictors to use under different runtime constraints. Our code, based on the NASLib library [52], can be used as a testing ground for future performance prediction techniques. In order to ensure reproducibility of the original results, we created a table to clarify which of the 31 predictors had previously published results on a NAS-Bench search space, and how these published results compared to our results (Table 7). We also adhere to the NeurIPS 2021 checklist along with the specialized NAS best practices checklist [31]. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions. We summarize our main contributions below. ",
+        "bbox": [
+            176,
+            799,
+            606,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We conduct the first large-scale study of performance predictors for neural architecture search by comparing model-based methods, learning curve extrapolation methods, zero-cost methods, and weight sharing methods across a variety of settings.   \n• We release a comprehensive library of 31 performance predictors on four different search spaces.   \n• We show that different families of performance predictors can be combined to achieve substantially better predictive power than any single predictor. ",
+        "bbox": [
+            183,
+            820,
+            826,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "NAS has been studied since at least the 1990s [19, 58], and has been revitalized in the last few years [78]. While initial techniques focused on reinforcement learning [78, 45] and evolutionary search [37, 49], one-shot NAS algorithms [32, 12, 4] and predictor-based NAS algorithms [65, 54, 69] have recently become popular. We give a brief survey of performance prediction techniques in Section 3. For a survey on NAS, see [15]. The most widely used type of search space in prior work is the cell-based search space [79], where the architecture search is over a relatively small directed acyclic graph representing an architecture. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A few recent works have compared different performance predictors on popular cell-based search spaces for NAS. Siems et al. [55] studied graph neural networks and tree-based methods, and found that gradient-boosted trees and graph isomorphism networks performed the best. However, the comparison was only on a single search space and dataset, and the explicit goal was to achieve maximum performance given a training set of around 60 000 architectures. Another recent paper [41] studied various aspects of supernetwork training, and separately compared four model-based methods: random forest, MLP, LSTM, and GATES [42]. However, the comparisons were again on a single search space and dataset and did not compare between multiple families of performance predictors. Other papers have proposed new model-based predictors and compared the new predictors to other model-based baselines [34, 65, 54, 69]. Finally, a recent paper analyzed training heuristics to make weight-sharing more effective at ranking architectures [72]. To the best of our knowledge, no prior work has conducted comparisons across multiple families of performance predictors. ",
+        "bbox": [
+            173,
+            228,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Performance Prediction Methods for NAS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            419,
+            555,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In NAS, given a search space $\\mathcal { A }$ , the goal is to find $a ^ { * } = \\operatorname * { a r g m i n } _ { a \\in { \\mathcal { A } } } f ( a )$ , where $f$ denotes the validation error of architecture $a$ after training on a fixed dataset for a fixed number of epochs $E$ . Since evaluating $f ( a )$ typically takes hours (as it requires training a neural network from scratch), many NAS algorithms make use of performance predictors to speed up this process. A performance predictor $f ^ { \\prime }$ is defined generally as any function which predicts the final accuracy or ranking of architectures, without fully training the architectures. That is, evaluating $f ^ { \\prime }$ should take less time than evaluating $f$ , and $\\{ f ^ { \\prime } ( a ) \\mid a \\in \\mathcal { A } \\}$ should ideally have high correlation or rank correlation with $\\{ f ( a ) \\mid a \\in { \\bar { \\mathcal { A } } } \\}$ . ",
+        "bbox": [
+            173,
+            454,
+            825,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each performance predictor is defined by two main routines: an initialization routine which performs general pre-computation, and a query routine which performs the final architecture-specific computation: it takes as input an architecture specification, and outputs its predicted accuracy. For example, one of the simplest performance predictors is early stopping: for any query $( a )$ , train $a$ for $E / 2$ epochs instead of $E$ [77]. In this case, there is no general pre-computation, so initialization time is zero. On the other hand, the query time for each input architecture is high because it involves training the architecture for $E / 2$ epochs. In fact, the runtime of the initialization and query routines varies substantially based on the type of predictor. In the context of NAS algorithms, the initialization routine is typically performed once at the start of the algorithm, and the query routine is typically performed many times throughout the NAS algorithm. Some performance predictors also make use of an update routine, when part of the computation from initialization needs to be updated without running the full procedure again (for example, in a NAS algorithm, a model may be updated periodically based on newly trained architectures). Now we give an overview of the main families of predictors. See Figure 1 (left) for a taxonomy of performance predictors. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model-based (trainable) methods. The most common type of predictor, the model-based predictor, is based on supervised learning. The initialization routine consists of fully training many architectures (i.e., evaluating $f ( a )$ for many architectures $a \\in { \\mathcal { A } }$ ) to build a training set of datapoints $\\{ a , f ( a ) \\}$ . Then a model $f ^ { \\prime }$ is trained to predict $f ( a )$ given $a$ . While the initialization time for model-based predictors is very high, the query time typically takes less than a second, which allows thousands of predictions to be made throughout a NAS algorithm. The model is also updated regularly based on the new datapoints. These predictors are typically used within BO frameworks [36, 54], evolutionary frameworks [66], or by themselves [67], to perform NAS. Popular choices for the model include tree-based methods (where the features are the adjacency matrix representation of the architectures) [33, 55], graph neural networks [36, 54], Gaussian processes [47, 51], and neural networks based on specialized encodings of the architecture [69, 42]. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Learning curve-based methods. Another family predicts the final performance of architectures using only a partially trained network, by extrapolating the learning curve. This is accomplished by fitting the partial learning curve to an ensemble of parametric models [11], or by simply summing the training losses observed so far [50]. Early stopping as described earlier is also a learning curve-based method. Learning curve methods do not require any initialization time, yet the query time typically takes minutes or hours, which is orders of magnitude slower than the query time in model-based methods. Learning curve-based methods can be used in conjunction with multi-fidelty algorithms, such as Hyperband or BOHB [27, 16, 24]. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hybrid methods. Some predictors are hybrids between learning curve and model-based methods. These predictors train a model at initialization time to predict $f ( a )$ given both $a$ and a partial learning curve of $a$ as features. Models in prior work include an SVR [2], or a Bayesian neural network [20]. Although the query time and initialization time are both high, hybrid predictors tend to have strong performance. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            328
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Zero-cost methods. Another class of predictors have no initialization time and very short query times (so-called “zero-cost” methods). These predictors compute statistics from just a single forward/backward propagation pass for a single minibatch of data, by computing the correlation of activations within a network [38], or by adapting saliency metrics proposed in pruning-at-initialization literatures [23, 1]. Similar to learning curve-based methods, since the only computation is specific to each architecture, the initialization time is zero. Zero-cost methods have recently been used to warm start NAS algorithms [1]. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            440
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Weight sharing methods. Weight sharing [45] is a popular approach to substantially speed up NAS, especially in conjunction with a one-shot algorithm [32, 12]. In this approach, all architectures in the search space are combined to form a single over-parameterized supernetwork. By training the weights of the supernetwork, all architectures in the search space can be evaluated quickly using this set of weights. To this end, the supernetwork can be used as a performance predictor. This results in NAS algorithms [32, 28] which are significantly faster than sequential NAS algorithms, such as evolution or Bayesian optimization. Recent work has shown that although the shared weights are sometimes not effective at ranking architectures [53, 74, 76], one-shot NAS techniques using shared weights still achieve strong performance [73, 25]. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tradeoff between intialization and query time. The main families mentioned above all have different initialization and query times. The tradeoffs between initialization time, query time, and performance depend on a few factors such as the type of NAS algorithm and its total runtime budget, and different settings are needed in different situations. For example, if there are many architectures whose performance we want to estimate, then we should have a low query time, and if we have a high total runtime budget, then we can afford a high initialization time. We may also change our runtime budget throughout the run of a single NAS algorithm. For example, at the start of a NAS algorithm, we may want to have coarse estimates of a large number of architectures (low initialization time, low query time such as zero-cost predictors). As the NAS algorithm progresses, it is more desirable to receive higher-fidelity predictions on a smaller set of architectures (model-based or hybrid predictors). The exact budgets depend on the type of NAS algorithm. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Choice of performance predictors. We analyze 31 performance predictors defined in prior work: BANANAS [69], Bayesian Linear Regression [6], BOHAMIANN [57], BONAS [54], DNGO [56], Early Stopping with Val. Acc. (e.g. [77, 27, 16, 79]) Early Stopping with Val. Loss. [50], Fisher [1], Gaussian Process (GP) [48], GCN [75], Grad Norm [1], Grasp [64], Jacobian Covariance [38], LCE [11], LCE-m [20], LcSVR [2], LGBoost/GBDT [33], MLP [69], NAO [35], NGBoost [55], OneShot [73], Random Forest (RF) [55], Random Search with Weight Sharing (RSWS) [26], SemiNAS [34], SNIP [23], SoTL [50], SoTL-E [50], Sparse GP [3], SynFlow [61], Variational Sparse GP [63], and XGBoost [55]. For any method that did not have an architecture encoding already defined (such as the tree-based methods, GP-based methods, and Bayesian Linear Regression), we use the standard adjacency matrix encoding, which consists of the adjacency matrix of the architecture along with a one-hot list of the operations [71, 68]. By open-sourcing our code, we encourage implementing more (existing and future) performance predictors which can then be compared to the 31 which we focus on in this work. In Section B.1, we give descriptions and detailed implementation details for each performance predictor. In Section D, we give a table that describes for which predictors we were able to reproduce published results, and for which predictors it is not possible (e.g., since some predictors were released before the creation of NAS benchmarks). ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/cac2d076145d762a60a6f0cf6b3b21b22efe01ee2cac10389179b735bb57d3b9.jpg",
+        "image_caption": [
+            "Figure 2: The performance predictors with the highest Kendall Tau values for all initialization time and query time budgets on NAS-Bench-201, NAS-Bench-101, NAS-Bench-NLP and DARTS. For example, on NAS-Bench-201 CIFAR-10 (left) with an initialization time of $1 0 ^ { 6 }$ seconds and query time of 10 seconds, XGBoost achieves a Kendall Tau value of .73 which is the highest value out of the 31 predictors that we tested at that budget. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            92,
+            828,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            312,
+            577
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now discuss our experimental setup and results. We discuss reproducibility in Sections A and D, and our code (based on the NASLib library [52]) is available at https://github.com/automl/ naslib. We split up our experiments into two categories: evaluating the performance of each predictor with respect to various correlation metrics (Section 4.1), and evaluating the ability of each predictor to speed up predictor-based NAS algorithms (Section 4.2). We start by describing the four NAS benchmarks used in our experiments. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "NAS benchmark datasets. NAS-Bench-101 [71] consists of over 423 000 unique neural architectures with precomputed training, validation, and test accuracies after training for 4, 12, 36, and 108 epochs on CIFAR-10 [71]. The cell-based search space consists of five nodes which can take on any directed acyclic graph (DAG) structure, and each node can be one of three operations. Since learning curve information is only available at four epochs, it is not possible to run most learning curve extrapolation methods on NAS-Bench-101. NAS-Bench-201 [13] consists of 15 625 architectures (out of which 6 466 are unique after removing isomorphisms [13]). Each architecture has full learning curve information for training, validation, and test losses/accuracies for 200 epochs on CIFAR-10 [22], CIFAR-100, and ImageNet-16-120 [10]. The search space consists of a cell which is a complete DAG with 4 nodes. Each edge can take one of five different operations. The DARTS search space [32] is significantly larger with roughly $1 0 ^ { 1 8 }$ architectures. The search space consists of two cells, each with seven nodes. The first two nodes are inputs from previous layers, and the intermediate four nodes can take on any DAG structure such that each node has two incident edges. The last node is the output node. Each edge can take one of eight operations. In our experiments, we make use of the training data from NAS-Bench-301 [55], which consists of 23 000 architectures drawn uniformly at random and trained on CIFAR-10 for 100 epochs. Finally, the NAS-Bench-NLP search space [21] is even larger, at $1 0 ^ { 5 3 }$ LSTM-like cells, each with at most 25 nodes in any DAG structure. Each cell can take one of seven operations. In our experiments, we use the NAS-Bench-NLP dataset, which consists of 14 000 architectures drawn uniformly at random and trained on Penn Tree Bank [40] for 50 epochs. ",
+        "bbox": [
+            174,
+            689,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            825,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter tuning. Although we used the code directly from the original repositories (sometimes making changes when necessary to adapt to NAS-Bench search spaces), the predictors had significantly different levels of hyperparameter tuning. For example, some of the predictors had undergone heavy hyperparameter tuning on the DARTS search space (used in NAS-Bench-301), while other predictors (particularly those from 2017 or earlier) had never been run on cell-based search spaces. Furthermore, most predictor-based NAS algorithms can utilize cross-validation to tune the predictor periodically throughout the NAS algorithm. This is because the bottleneck for predictorbased NAS algorithms is typically the training of architectures, not fitting the predictor [56, 30, 16]. Therefore, it is fairer and also more informative to compare performance predictors which have had the same level of hyperparameter tuning through cross-validation. For each search space, we run random search on each performance predictor for 5000 iterations, with a maximum total runtime of 15 minutes. The final evaluation uses a separate test set. The hyperparameter value ranges for each predictor can be found in Section B.2. ",
+        "bbox": [
+            174,
+            148,
+            826,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Performance Predictor Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            345,
+            452,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate each predictor based on three axes of comparison: initialization time, query time, and performance. We measured performance with respect to several different metrics: Pearson correlation and three different rank correlation metrics (Spearman, Kendall Tau, and sparse Kendall Tau [72, 55]). The experimental setup is as follows: the predictors are tested with 11 different initialization time budgets and 14 different query time budgets, leading to a total of 154 settings. On NAS-Bench-201 CIFAR-10, the 11 initialization time budgets are spaced logarithmically from 1 second to $1 . 8 \\times 1 0 ^ { 7 }$ seconds on a $1 0 8 0 \\mathrm { T i }$ GPU (which corresponds to training 1000 random architectures on average) which is consistent with experiments conducted in prior work [65, 69, 34]. For other search spaces, these times are adjusted based on the average time to train 1000 architectures. The 14 query time budgets are spaced logarithmically from 1 second to $1 . 8 \\times 1 0 ^ { 4 }$ seconds (which corresponds to training an architecture for 199 epochs). These times are adjusted for other search spaces based on the training time and different number of epochs. Once the predictor is initialized, we draw a test set of 200 architectures uniformly at random from the search space. For each architecture in the test set, the predictor uses the specified query time budget to make a prediction. We then evaluate the quality of the predictions using the metrics described above. We average the results over 100 trials for each (initialization time, query time) pair. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results and discussion. Figure 1 shows a full three-dimensional plot for NAS-Bench-201 on CIFAR-10 over initialization time, query time, and Kendall Tau rank correlation. Of the 31 predictors we tested, we found that just seven of them are Pareto-optimal with respect to Kendall Tau, initialization time, and query time. That is, only seven algorithms have the highest Kendall Tau value for at least one of the 154 query time/initialization time budgets on NAS-Bench-201 CIFAR-10. This can be seen more clearly in Figure 2 (left), which is a view from above Figure 1: each lattice point displays the predictor with the highest Kendall Tau value for the corresponding budget. In Figure 2 (right), we plot the Pareto-optimal predictors for five different dataset/search space combinations. In Section B.3, we give the full 3D plots and report the variance across trials for each method. In Figure 4 (left), we also plot the Pearson and Spearman correlation coefficients for NAS-Bench-201 CIFAR-10. The trends between these measures are largely the same, although we see that SemiNAS performs better on the rank-based metrics. For the rest of this section, we focus on the popular Kendall Tau metric, giving the full results for the other metrics in Section B.3. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            786
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We see similar trends across DARTS and the two NAS-Bench-201 datasets. NAS-Bench-NLP also has fairly similar trends, although early stopping performs comparatively stronger. NAS-Bench-101 is different from the other search spaces both in terms of the topology and the benchmark itself, which we discuss later in this section. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the low initialization time, low query time region, Jacobian covariance or SynFlow perform well across NAS-Bench-101 and NAS-Bench-201. However, none of the six zero-cost methods perform well on the larger DARTS search space. Weight sharing (which also has low initialization and low query time, as seen in Figure 1), did not yield high Kendall Tau values for these search spaces, either, which is consistent with recent work [53, 74, 76]. However, rank correlation is not as crucial to one-shot NAS algorithms as it is for black box predictor-based methods, as demonstrated by prior one-shot NAS methods that do perform well [25, 73, 32, 28, 12]. In the low initialization time, high query time region, sum of training losses (SoTL-E) consistently performed the best, outperforming other learning-curve based methods. ",
+        "bbox": [
+            176,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/1a336b83714b502dfa447d28dd46ecffcc5c4c07832f5707486bd7c0c8470d68.jpg",
+        "image_caption": [
+            "Figure 3: Percentage of OMNI’s Kendall Tau value compared to the next-best predictors for each budget constraint. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            89,
+            815,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            277,
+            825,
+            347
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The high initialization time, low query time region (especially the bottom row of the plots, corresponding to a query time of 1 second) is by far the most competitive region in the recent NAS literature. Sixteen of the 31 predictors had query times under one second, because many NAS algorithms are designed to initialize (and continually update) performance predictors that are used to quickly query thousands of candidate architectures. GCN and SemiNAS, the specialized GCN/semi-supervised methods, perform especially well in the first half of this critical region, when the initialization time is relatively low. However, boosted tree methods actually performed best in the second half of the critical region where the initialization time is high, which is consistent with prior work [33, 55]. Recall that for model-based methods, the initialization time corresponds to training architectures to be used as training data for the performance predictor. Therefore, our results suggest that techniques which can extract better latent features of the architectures can make up for a small training dataset, but methods based purely on performance data work better when there is enough such data. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Perhaps the most interesting finding is that on NAS-Bench-101/201, SynFlow and Jacobian covariance, which take three seconds each to compute, both outperform all model-based methods even after $3 0$ hours of initialization. Put another way, NAS algorithms that make use of model-based predictors may be able to see substantial improvements by using Jacobian covariance instead of a model-based predictor in the early iterations. ",
+        "bbox": [
+            173,
+            526,
+            825,
+            595
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The Omnipotent Predictor. One conclusion from Figure 2 is that different types of predictors are specialized for specific initialization time and query time constraints. A natural follow-up question is whether different families are complementary and can be combined to achieve stronger performance. In this section, we run a proof-of-concept to answer this question. We combine the best-performing predictors from three different families in a simple way: the best learning curve method (SoTL-E), and the best zero-cost method (Jacobian covariance), are used as additional input features for a model-based predictor (we separately test SemiNAS and NGBoost). We call this method OMNI, the omnipotent predictor. We give results in Figure 3 and pseudo-code as well as additional experiments in Section B.4. In contrast to all other predictors, the performance of OMNI is strong across almost all budget constraints and search spaces. In some settings, OMNI achieves a Kendall Tau value $30 \\%$ higher than the next-best predictors. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            766
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The success of OMNI verifies that the information learned by different families of predictors are complementary: the information learned by extrapolating a learning curve, by computing a zero-cost proxy, and by encoding the architecture, all improve performance. We further confirm this by running an ablation study for OMNI in Section B.4. We can hypothesize that each predictor type measures distinct quantities: SOTL-E measures the training speed, zero-cost predictors measure the covariance between activations on different datapoints, and model-based predictors simply learn patterns between the architecture encodings and the validation accuracies. Finally, while we showed a proof-of-concept, there are several promising areas for future work such as creating ensembles of the model-based approaches, combining zero-cost methods with model-based methods in more sophisticated ways, and giving a full quantification of the correlation among different families of predictors. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/db818d6a83efa7fb904fdc04c428ec375353f40a9141d13d9b6146e28a4e0d71.jpg",
+        "image_caption": [
+            "Figure 4: The best predictors on NAS-Bench-201 CIFAR-10 with respect to Pearson (left) and Spearman (middle). Kendall Tau values from a mutation-based training and test set (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            88,
+            803,
+            261
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "NAS-Bench-101: a more complex search space. In Figure 2, the plot for NAS-Bench-101 looks significantly different than the plots for the other search spaces, for two reasons. The first reason is a technical one: the NAS-Bench-101 API only gives the validation accuracy at four epochs, and does not give the training loss for any epochs. Therefore, we could not implement SoTL or any learning curve extrapolation method. However, all sixteen of the model-based predictors were implemented on NAS-Bench-101. In this case, BANANAS significantly outperformed the next-best predictors (GCN and SemiNAS) across every initialization time. One explanation is due to the complexity of the NAS-Bench-101 search space: while all NAS-Bench-201 architectures have the same graph topology and DARTS architectures’ nodes have exactly two incoming edges, the NAS-Bench-101 search space is much more diverse with architectures ranging from a single node and no edges, to five nodes with nine connecting edges. In fact, the architecture encoding used in BANANAS, the path encoding, was designed specifically to deal with the complexity of the NAS-Bench-101 search space (replacing the standard adjacency matrix encoding). To test this explanation, in Appendix B we run several of the simpler tree-based and GP-based predictors using the path encoding, and we see that these methods now surpass BANANAS in performance. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            554
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A mutation-based test set. The results from Figure 2 used a test set drawn uniformly at random from the search space (and the training set used by model-based predictors was also drawn uniformly at random). However, neighborhood-based NAS algorithms such as local search, regularized evolution, and some versions of Bayesian optimization consider architectures which are local perturbations of the architectures encountered so far. Therefore, the predictors used in these NAS algorithms must be able to distinguish architectures which are local mutations of a small set of seed architectures. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            676
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We run an experiment in which the test set is created by mutating architectures from an initial set of seed architectures. Specifically, we draw a set of 50 random architectures and choose the five with the highest validation accuracy as seed architectures. Then we create a set of 200 test architectures by randomly mutating up to three attributes of the seed architectures. Therefore, all architectures in the test set are at most an edit distance of three from a seed architecture, where two architectures are a single edit distance away if they differ by one operation or edge. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            767
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We create the training set by randomly choosing architectures from the test set and mutating one random attribute. As in all of our experiments, we ensure that the training set and test set are disjoint. In Figure 4 (right), we plot the correlation results for NAS-Bench-201 CIFAR-10. While the zero-cost and learning curve-based approaches have similar performance, the model-based approaches have significantly worse performance compared to the uniform random setting. This is because the average edit distance between architectures in the test set is low, making it significantly harder for model-based predictors to distinguish the performance of these architectures, even when using a training set that is based on mutations of the test set. In fact, interestingly, the performance of many model-based approaches starts to perform worse after $1 0 ^ { 6 }$ seconds. SemiNAS in particular performs much worse in this setting, and boosted trees have comparatively stronger performance in this setting. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c15699c76c80aa1243fa92c24047ed5b53dff1845e874054c71f1e142d0b0327.jpg",
+        "image_caption": [
+            "Figure 5: Validation error vs. runtime for the predictor-guided evolution framework and the Bayesian optimization $^ +$ predictor framework using different predictors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            90,
+            813,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Predictor-Based NAS Experiments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            454,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Now we evaluate the ability of each model-based performance predictor to speed up NAS. We use two popular predictor-based NAS methods: the predictor-guided evolution framework [66, 59], and the Bayesian optimization $^ +$ predictor framework [17, 36, 54]. The predictor-guided evolution framework is an iterative procedure in which the best architectures in the current population are mutated to create a set of candidate architectures. A predictor (trained on the entire population) chooses $k$ architectures which are then evaluated. In our experiments, the candidate pool is created by mutating the top five architectures 40 times each, and we set $k = 2 0$ . For each predictor, we run predictor-guided evolution for 25 iterations and average the results over 100 trials. The $\\mathrm { B O + }$ predictor framework is similar to the evolution framework, but an ensemble of three performance predictors are used so that uncertainty estimates for each prediction can be computed. In each iteration, the candidate architectures whose predictions maximize an acquisition function are then evaluated. Similar to prior work, we use independent Thompson sampling [69], as the acquisition function, and an ensemble is created by using a different ordering of the training set and different random weight initializations (if applicable) of the same predictor. In each iteration, the top 20 architectures are chosen from a randomly sampled pool of 200 architectures. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            641
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we present results for both NAS frameworks on NAS-Bench-201 CIFAR-10 and ImageNet16-120 for the 16 model-based predictors. We also test OMNI, using its lowest query time setting (consisting of NGBoost $^ +$ Jacobian covariance), and another version of OMNI that replaces NGBoost with SemiNAS. Our results show that the model-based predictors with the top Kendall Tau rank correlations in the low query time region from Figure 2 also roughly achieve the best performance when applied for NAS: SemiNAS and NAO perform the best for shorter runtime, and boosted trees perform best for longer runtime. OMNI(NGBoost) consistently outperforms NGBoost, and OMNI(SemiNAS) often achieves top performance. This suggests that using zero-cost methods in conjunction with model-based methods is a promising direction for future study. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 So, how powerful are performance predictors? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            535,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Throughout Section 4, we tested performance predictors in a variety of settings, by varying the search spaces, datasets, runtime budgets, and training/test distributions. We saw largely the same trends among all of our experiments. Interesting findings included the success of zero-cost predictors even when compared to model-based predictors and learning curve extrapolation predictors with longer runtime budgets, and the fact that information from different families of predictors are complementary. When choosing a performance predictor for new applications, we recommend deciding on a target initialization time and query time budget, consulting Figures 2 and 6, and then combining the best predictors from the desired runtime setting, similar to OMNI. For example, if a performance predictor with medium initialization time and low runtime is desired for a search space similar to NAS-Bench201 or DARTS, we recommend using NGBoost with Jacobian covariance and SynFlow as additional features. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Societal Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            334,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our hope is that our work will have a positive impact on the AutoML community by making it quicker and easier to develop and fairly compare performance predictors. For example, AutoML practitioners can consult our experiments to more easily decide on the performance prediction methods best suited to their application, rather than conducting computationally intensive experiments of their own [43]. Furthermore, AutoML researchers can use our library to develop new performance prediction techniques and compare new methods to 31 other algorithms across four search spaces. Since the topic of this work is AutoML, it is a level of abstraction away from real applications. This work may be used to improve deep learning applications, both beneficial (e.g. reducing $\\mathrm { C O _ { 2 } }$ emissions), or harmful (e.g. creating language models with heavy bias) to society. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            323
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            342,
+            444,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we gave the first large-scale study of performance predictors for neural architecture search. We compared 31 different performance predictors, including learning curve extrapolation methods, weight sharing methods, zero-cost methods, and model-based methods. We tested the performance of the predictors in a variety of settings and with respect to different metrics. Although we ran experiments on four different search spaces, it will be interesting to extend our experiments to even more machine learning tasks beyond image classification and language modeling. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            457
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our new predictor, OMNI, is the first predictor to combine complementary information from three families of performance preditors, leading to substantially improved performance. While the simplicity of OMNI is appealing, it also opens up new directions for future work by combining different predictors in more sophisticated ways. To facilitate follow-up work, we release our code featuring a library of performance predictors. Our goal is for our repository to grow over time as it is used by the community, so that experiments in our library can be even more comprehensive. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            546
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            553,
+            583
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was done while CW and YL were employed at Abacus.AI. AZ and FH acknowledge support by the European Research Council (ERC) under the European Union Horizon 2020 research and innovation programme through grant no. 716721, and by BMBF grant DeToL. BR was supported by the Clarendon Fund of University of Oxford. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            652
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Mohamed S Abdelfattah, Abhinav Mehrotra, Łukasz Dudziak, and Nicholas Donald Lane. Zero-cost proxies for lightweight nas. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   \n[2] Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. arXiv preprint arXiv:1705.10823, 2017.   \n[3] Matthias Bauer, Mark van der Wilk, and Carl Edward Rasmussen. Understanding probabilistic sparse gaussian process approximations. arXiv preprint arXiv:1606.04820, 2016.   \n[4] Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In Proceedings of the International Conference on Machine Learning (ICML), pages 550–559, 2018.   \n[5] Eli Bingham, Jonathan P Chen, Martin Jankowiak, Fritz Obermeyer, Neeraj Pradhan, Theofanis Karaletsos, Rohit Singh, Paul Szerlip, Paul Horsfall, and Noah D Goodman. Pyro: Deep universal probabilistic programming. The Journal of Machine Learning Research, 20(1):973– 978, 2019.   \n[6] Christopher M Bishop. Pattern recognition and machine learning. springer, 2006.   \n[7] Han Cai, Ligeng Zhu, and Song Han. Proxylessnas: Direct neural architecture search on target task and hardware. Proceedings of the International Conference on Learning Representations (ICLR), 2019.   \n[8] Akshay Chandrashekaran and Ian R Lane. Speeding up hyper-parameter optimization by extrapolation of learning curves using previous builds. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 477–492. Springer, 2017.   \n[9] Tianqi Chen and Carlos Guestrin. Xgboost: A scalable tree boosting system. In Proceedings of the 22nd acm sigkdd international conference on knowledge discovery and data mining, pages 785–794, 2016.   \n[10] Patryk Chrabaszcz, Ilya Loshchilov, and Frank Hutter. A downsampled variant of imagenet as an alternative to the CIFAR datasets. CoRR, abs/1707.08819, 2017.   \n[11] Tobias Domhan, Jost Tobias Springenberg, and Frank Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. In Twenty-Fourth International Joint Conference on Artificial Intelligence, 2015.   \n[12] Xuanyi Dong and Yi Yang. Searching for a robust neural architecture in four gpu hours. In Proceedings of the IEEE Conference on computer vision and pattern recognition, pages 1761–1770, 2019.   \n[13] Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   \n[14] Tony Duan, Avati Anand, Daisy Yi Ding, Khanh K Thai, Sanjay Basu, Andrew Ng, and Alejandro Schuler. Ngboost: Natural gradient boosting for probabilistic prediction. In International Conference on Machine Learning, pages 2690–2700. PMLR, 2020.   \n[15] Thomas Elsken, Jan Hendrik Metzen, and Frank Hutter. Neural architecture search: A survey. arXiv preprint arXiv:1808.05377, 2018.   \n[16] Stefan Falkner, Aaron Klein, and Frank Hutter. Bohb: Robust and efficient hyperparameter optimization at scale. In Proceedings of the International Conference on Machine Learning (ICML), 2018.   \n[17] Kirthevasan Kandasamy, Willie Neiswanger, Jeff Schneider, Barnabas Poczos, and Eric P Xing. Neural architecture search with Bayesian optimisation and optimal transport. In Advances in Neural Information Processing Systems, pages 2016–2025, 2018.   \n[18] Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, and Tie-Yan Liu. Lightgbm: A highly efficient gradient boosting decision tree. Advances in neural information processing systems, 30:3146–3154, 2017.   \n[19] Hiroaki Kitano. Designing neural networks using genetic algorithms with graph generation system. Complex systems, 4(4):461–476, 1990.   \n[20] Aaron Klein, Stefan Falkner, Jost Tobias Springenberg, and Frank Hutter. Learning curve prediction with Bayesian neural networks. ICLR 2017, 2017.   \n[21] Nikita Klyuchnikov, Ilya Trofimov, Ekaterina Artemova, Mikhail Salnikov, Maxim Fedorov, and Evgeny Burnaev. Nas-bench-nlp: neural architecture search benchmark for natural language processing. arXiv preprint arXiv:2006.07116, 2020.   \n[22] Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   \n[23] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip Torr. SNIP: Single-shot network pruning based on connection sensitivity. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   \n[24] Liam Li, Kevin Jamieson, Afshin Rostamizadeh, Ekaterina Gonina, Moritz Hardt, Benjamin Recht, and Ameet Talwalkar. A system for massively parallel hyperparameter tuning. In Proceedings of the Conference on Machine Learning Systems, 2020.   \n[25] Liam Li, Mikhail Khodak, Maria-Florina Balcan, and Ameet Talwalkar. Geometry-aware gradient algorithms for neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2021.   \n[26] Liam Li and Ameet Talwalkar. Random search and reproducibility for neural architecture search. arXiv preprint arXiv:1902.07638, 2019.   \n[27] Lisha Li, Kevin Jamieson, Giulia DeSalvo, Afshin Rostamizadeh, and Ameet Talwalkar. Hyperband: A novel bandit-based approach to hyperparameter optimization. arXiv preprint arXiv:1603.06560, 2016.   \n[28] Hanwen Liang, Shifeng Zhang, Jiacheng Sun, Xingqiu He, Weiran Huang, Kechen Zhuang, and Zhenguo Li. Darts+: Improved differentiable architecture search with early stopping. arXiv preprint arXiv:1909.06035, 2019.   \n[29] Andy Liaw, Matthew Wiener, et al. Classification and regression by randomforest. R news, 2(3):18–22, 2002.   \n[30] Marius Lindauer, Katharina Eggensperger, Matthias Feurer, Stefan Falkner, André Biedenkapp, and Frank Hutter. Smac v3: Algorithm configuration in python. URL https://github. com/automl/SMAC3, 2017.   \n[31] Marius Lindauer and Frank Hutter. Best practices for scientific research on neural architecture search. arXiv preprint arXiv:1909.02453, 2019.   \n[32] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018.   \n[33] Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture search with gbdt. arXiv preprint arXiv:2007.04785, 2020.   \n[34] Renqian Luo, Xu Tan, Rui Wang, Tao Qin, Enhong Chen, and Tie-Yan Liu. Semi-supervised neural architecture search. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2020.   \n[35] Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2018.   \n[36] Lizheng Ma, Jiaxu Cui, and Bo Yang. Deep neural architecture search with deep graph Bayesian optimization. In 2019 IEEE/WIC/ACM International Conference on Web Intelligence (WI), pages 500–507. IEEE, 2019.   \n[37] Krzysztof Maziarz, Andrey Khorlin, Quentin de Laroussilhe, and Andrea Gesmundo. Evolutionary-neural hybrid agents for architecture search. arXiv preprint arXiv:1811.09828, 2018.   \n[38] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J Crowley. Neural architecture search without training. arXiv preprint arXiv:2006.04647, 2020.   \n[39] Szymon Jakub Mikler. Snip: Single-shot network pruning based on connection sensitivity. GitHub repository gahaalt/SNIP-pruning, 2019.   \n[40] Tomáš Mikolov, Martin Karafiát, Lukáš Burget, Jan Cernock ˇ y, and Sanjeev Khudanpur. Recur- \\` rent neural network based language model. In Annual conference of the international speech communication association, 2010.   \n[41] Xuefei Ning, Wenshuo Li, Zixuan Zhou, Tianchen Zhao, Yin Zheng, Shuang Liang, Huazhong Yang, and Yu Wang. A surgery of the neural architecture evaluators. arXiv preprint arXiv:2008.03064, 2020.   \n[42] Xuefei Ning, Yin Zheng, Tianchen Zhao, Yu Wang, and Huazhong Yang. A generic graph-based neural architecture encoding scheme for predictor-based nas. arXiv preprint arXiv:2004.01899, 2020.   \n[43] David Patterson, Joseph Gonzalez, Quoc Le, Chen Liang, Lluis-Miquel Munguia, Daniel Rothchild, David So, Maud Texier, and Jeff Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   \n[44] Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel, Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer, Ron Weiss, Vincent Dubourg, et al. Scikitlearn: Machine learning in python. the Journal of machine Learning research, 12:2825–2830, 2011.   \n[45] Hieu Pham, Melody Y Guan, Barret Zoph, Quoc V Le, and Jeff Dean. Efficient neural architecture search via parameter sharing. arXiv preprint arXiv:1802.03268, 2018.   \n[46] Joaquin Quiñonero Candela and Carl Edward Rasmussen. A unifying view of sparse approximate gaussian process regression. J. Mach. Learn. Res., 6:1939–1959, December 2005.   \n[47] Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer School on Machine Learning, pages 63–71. Springer, 2003.   \n[48] Carl Edward Rasmussen. Gaussian processes in machine learning. In Summer School on Machine Learning, pages 63–71. Springer, 2003.   \n[49] Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intelligence, volume 33, pages 4780–4789, 2019.   \n[50] Binxin Ru, Clare Lyle, Lisa Schut, Mark van der Wilk, and Yarin Gal. Revisiting the train loss: an efficient performance estimator for neural architecture search. arXiv preprint arXiv:2006.04492, 2020.   \n[51] Binxin Ru, Xingchen Wan, Xiaowen Dong, and Michael Osborne. Neural architecture search using Bayesian optimisation with weisfeiler-lehman kernel. arXiv preprint arXiv:2006.07556, 2020.   \n[52] Michael Ruchte, Arber Zela, Julien Siems, Josif Grabocka, and Frank Hutter. Naslib: a modular and flexible neural architecture search library, 2020.   \n[53] Christian Sciuto, Kaicheng Yu, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. arXiv preprint arXiv:1902.08142, 2019.   \n[54] Han Shi, Renjie Pi, Hang Xu, Zhenguo Li, James Kwok, and Tong Zhang. Bridging the gap between sample-based and one-shot neural architecture search with bonas. Advances in Neural Information Processing Systems, 33, 2020.   \n[55] Julien Siems, Lucas Zimmer, Arber Zela, Jovita Lukasik, Margret Keuper, and Frank Hutter. Nas-bench-301 and the case for surrogate benchmarks for neural architecture search. arXiv preprint arXiv:2008.09777, 2020.   \n[56] Jasper Snoek, Oren Rippel, Kevin Swersky, Ryan Kiros, Nadathur Satish, Narayanan Sundaram, Mostofa Patwary, Mr Prabhat, and Ryan Adams. Scalable Bayesian optimization using deep neural networks. In International conference on machine learning, pages 2171–2180, 2015.   \n[57] Jost Tobias Springenberg, Aaron Klein, Stefan Falkner, and Frank Hutter. Bayesian optimization with robust Bayesian neural networks. In Advances in Neural Information Processing Systems, pages 4134–4142, 2016.   \n[58] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.   \n[59] Yanan Sun, Xian Sun, Yuhan Fang, and Gary Yen. A new training protocol for performance predictors of evolutionary neural architecture search algorithms. arXiv preprint arXiv:2008.13187, 2020.   \n[60] Kevin Swersky, David Duvenaud, Jasper Snoek, Frank Hutter, and Michael Osborne. Raiders of the lost architecture: Kernels for Bayesian optimization in conditional parameter spaces. In NIPS workshop on Bayesian Optimization in Theory and Practice, December 2013.   \n[61] Hidenori Tanaka, Daniel Kunin, Daniel LK Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. arXiv preprint arXiv:2006.05467, 2020.   \n[62] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018.   \n[63] Michalis Titsias. Variational learning of inducing variables in sparse gaussian processes. In Artificial Intelligence and Statistics, pages 567–574, 2009.   \n[64] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In Proceedings of the International Conference on Learning Representations (ICLR), 2019.   \n[65] Linnan Wang, Yiyang Zhao, Yuu Jinnai, and Rodrigo Fonseca. Alphax: exploring neural architectures with deep neural networks and monte carlo tree search. arXiv preprint arXiv:1805.07440, 2018.   \n[66] Chen Wei, Chuang Niu, Yiping Tang, and Jimin Liang. Npenas: Neural predictor guided evolution for neural architecture search. arXiv preprint arXiv:2003.12857, 2020.   \n[67] Wei Wen, Hanxiao Liu, Hai Li, Yiran Chen, Gabriel Bender, and Pieter-Jan Kindermans. Neural predictor for neural architecture search. arXiv preprint arXiv:1912.00848, 2019.   \n[68] Colin White, Willie Neiswanger, Sam Nolen, and Yash Savani. A study on encodings for neural architecture search. In Proceedings of the Annual Conference on Neural Information Processing Systems (NeurIPS), 2020.   \n[69] Colin White, Willie Neiswanger, and Yash Savani. Bananas: Bayesian optimization with neural architectures for neural architecture search. In Proceedings of the AAAI Conference on Artificial Intelligence, 2021.   \n[70] Antoine Yang, Pedro M Esperança, and Fabio M Carlucci. Nas evaluation is frustratingly hard. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   \n[71] Chris Ying, Aaron Klein, Esteban Real, Eric Christiansen, Kevin Murphy, and Frank Hutter. Nasbench-101: Towards reproducible neural architecture search. arXiv preprint arXiv:1902.09635, 2019.   \n[72] Kaicheng Yu, Rene Ranftl, and Mathieu Salzmann. How to train your super-net: An analysis of training heuristics in weight-sharing nas. arXiv preprint arXiv:2003.04276, 2020.   \n[73] Arber Zela, Thomas Elsken, Tonmoy Saikia, Yassine Marrakchi, Thomas Brox, and Frank Hutter. Understanding and robustifying differentiable architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   \n[74] Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one-shot neural architecture search. In Proceedings of the International Conference on Learning Representations (ICLR), 2020.   \n[75] Yuge Zhang. Neural predictor for neural architecture search. GitHub repository ultmaster/neuralpredictor.pytorch, 2020.   \n[76] Yuge Zhang, Zejun Lin, Junyang Jiang, Quanlu Zhang, Yujing Wang, Hui Xue, Chen Zhang, and Yaming Yang. Deeper insights into weight sharing in neural architecture search. arXiv preprint arXiv:2001.01431, 2020.   \n[77] Dongzhan Zhou, Xinchi Zhou, Wenwei Zhang, Chen Change Loy, Shuai Yi, Xuesen Zhang, and Wanli Ouyang. Econas: Finding proxies for economical neural architecture search. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11396–11404, 2020.   \n[78] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2017.   \n[79] Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 8697–8710, 2018. ",
+        "bbox": [
+            173,
+            71,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            915
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            66,
+            828,
+            919
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            911
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            465
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] Our abstract and introduction accurately reflect our paper.   \n(b) Did you describe the limitations of your work? [Yes] See Section 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 5.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We discuss the ethics guidelines in Section 5. ",
+        "bbox": [
+            238,
+            135,
+            825,
+            253
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            257,
+            493,
+            272
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] We did not include theoretical results.   \n(b) Did you include complete proofs of all theoretical results? [N/A] We did not include theoretical results. ",
+        "bbox": [
+            238,
+            276,
+            825,
+            334
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            339,
+            393,
+            354
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(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)? [Yes] We included all code, data, and instructions in the supplementary material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] All training details are specified in the supplementary material.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We ran 100 trials for all experiments. Our plots that are performance vs. runtime (e.g. Figure 5) have error bars. For our Pareto-optimality plots (e.g. Figure 7), see the supplementary material for the error bars for all 31 predictors.   \n(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] We report the compute time and resources used in Section 4 and in the supplementary material. ",
+        "bbox": [
+            238,
+            358,
+            825,
+            531
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            536,
+            823,
+            550
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We cite the creators of all code, data, and models used.   \n(b) Did you mention the license of the assets? [Yes] We mention the licenses in the supplementary material.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A] We do not include new assets.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We did not use or release any datasets with personal data.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] The data we are using does not contain personal information or offensive content. ",
+        "bbox": [
+            238,
+            555,
+            825,
+            717
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            720,
+            705,
+            736
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A] We did not run experiments with human subjects.   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A] We did not run experiments with human subjects.   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] We did not run experiments with human subjects. ",
+        "bbox": [
+            238,
+            739,
+            825,
+            856
+        ],
+        "page_idx": 15
+    }
+]

parse/train/9az9VKjOx00/9az9VKjOx00.md

@@ -0,0 +1,381 @@
+# TOPOTER: UNSUPERVISED LEARNING OF TOPOLOGY TRANSFORMATION EQUIVARIANT REPRESENTATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We present the Topology Transformation Equivariant Representation (TopoTER) learning, a general paradigm of unsupervised learning of node representations of graph data for the wide applicability to Graph Convolutional Neural Networks (GCNNs). We formalize the TopoTER from an information-theoretic perspective, by maximizing the mutual information between topology transformations and node representations before and after the transformations. We derive that maximizing such mutual information can be relaxed to minimizing the cross entropy between the applied topology transformation and its estimation from node representations. In particular, we seek to sample a subset of node pairs from the original graph and flip the edge connectivity between each pair to transform the graph topology. Then, we self-train a representation encoder to learn node representations by reconstructing the topology transformations from the feature representations of the original and transformed graphs. In experiments, we apply the TopoTER to the downstream node and graph classification tasks, and results show that the TopoTER outperforms the state-of-the-art unsupervised approaches.
+
+# 1 INTRODUCTION
+
+Graphs provide a natural and efficient representation for non-Euclidean data, such as brain networks, social networks, citation networks, and 3D point clouds. Graph Convolutional Neural Networks (GCNNs) (Bronstein et al., 2017) have been proposed to generalize the CNNs to learn representations from non-Euclidean data, which has made significant advances in various applications such as node classification (Kipf & Welling, 2017; Velickovi ˇ c et al., 2018; Xu et al., 2019a) and graph ´ classification (Xu et al., 2019b). However, most existing GCNNs are trained in a supervised fashion, requiring a large amount of labeled data for network training. This limits the applications of the GCNNs since it is often costly to collect adequately labeled data, especially on large-scale graphs. Hence, this motivates the proposed research to learn graph feature representations in an unsupervised fashion, which enables the discovery of intrinsic graph structures and thus adapts to various downstream tasks.
+
+Auto-Encoders (AEs) and Generative Adversarial Networks (GANs) are two most representative unsupervised learning methods. Based on the AEs and GANs, many approaches have sought to learn transformation equivariant representations (TERs) to further improve the quality of unsupervised representation learning. It assumes that the learned representations equivarying to transformations are able to encode the intrinsic structures of data such that the transformations can be reconstructed from the representations before and after transformations (Qi et al., 2019b). Learning TERs traces back to Hinton’s seminal work on learning transformation capsules (Hinton et al., 2011), and embodies a variety of methods developed for Euclidean data (Kivinen & Williams, 2011; Sohn & Lee, 2012; Schmidt & Roth, 2012; Skibbe, 2013; Lenc & Vedaldi, 2015; Gens & Domingos, 2014; Dieleman et al., 2015; 2016; Zhang et al., 2019; Qi et al., 2019a). Further, Gao et al. (2020) extend transformation equivariant representation learning to non-Euclidean domain, which formalizes Graph Transformation Equivariant Representation (GraphTER) learning by auto-encoding nodewise transformations in an unsupervised fashion. Nevertheless, only transformations on node features are explored, while the underlying graph may vary implicitly. The graph topology has not been fully explored yet, which however is crucial in unsupervised graph representation learning.
+
+To this end, we propose the Topology Transformation Equivariant Representation (TopoTER) learning to infer unsupervised graph feature representations by estimating topology transformations. Instead of transforming node features as in the GraphTER, the proposed TopoTER studies the transformation equivariant representation learning by transforming the graph topology, i.e., adding or removing edges to perturb the graph structure. Then the same input signals are attached to the resultant graph topologies, resulting in different graph representations. This provides an insight into how the same input signals associated with different graph topologies would lead to equivariant representations enabling the fusion of node feature and graph topology in GCNNs. Formally, we propose the TopoTER from an information-theoretic perspective, aiming to maximize the mutual information between topology transformations and feature representations with respect to the original and transformed graphs. We derive that maximizing such mutual information can be relaxed to the cross entropy minimization between the applied topology transformations and the estimation from the learned representations of graph data under the topological transformations.
+
+Specifically, given an input graph and its associated node features, we first sample a subset of node pairs from the graph and flip the edge connectivity between each pair at a perturbation rate, leading to a transformed graph with attached node features. Then, we design a graph-convolutional auto-encoder architecture, where the encoder learns the node-wise representations over the original and transformed graphs respectively, and the decoder predicts the topology transformations of edge connectivity from both representations by minimizing the cross entropy between the applied and estimated transformations. Experimental results demonstrate that the proposed TopoTER model outperforms the state-of-the-art unsupervised models, and even achieves comparable results to the (semi-)supervised approaches in node classification and graph classification tasks at times.
+
+Our main contributions are summarized as follows.
+
+• We propose the Topology Transformation Equivariant Representation (TopoTER) learning to infer expressive node feature representations in an unsupervised fashion, which can characterize the intrinsic structures of graphs and the associated features by exploring the graph transformations of connectivity topology. We formulate the TopoTER from an information-theoretic perspective, by maximizing the mutual information between feature representations and topology transformations, which can be relaxed to the cross entropy minimization between the applied transformations and the prediction in an end-to-end graph-convolutional auto-encoder architecture.   
+• Experiments demonstrate that the proposed TopoTER model outperforms the state-of-the-art unsupervised methods in both node classification and graph classification.
+
+# 2 RELATED WORK
+
+Graph Auto-Encoders. Graph Auto-Encoders (GAEs) are the most representative unsupervised methods. GAEs encode graph data into feature space via an encoder and reconstruct the input graph data from the encoded feature representations via a decoder. GAEs are often used to learn network embeddings and graph generative distributions (Wu et al., 2020). For network embedding learning, GAEs learn the feature representations of each node by reconstructing graph structural information, such as the graph adjacency matrix (Kipf & Welling, 2016) and the positive pointwise mutual information (PPMI) matrix (Cao et al., 2016; Wang et al., 2016). For graph generation, some methods generate nodes and edges of a graph alternately (You et al., 2018), while other methods output an entire graph (Simonovsky & Komodakis, 2018; Ma et al., 2018; De Cao & Kipf, 2018).
+
+Graph Contrastive Learning. An important paradigm called contrastive learning aims to train an encoder to be contrastive between the representations of positive samples and negative samples. Recent contrastive learning frameworks can be divided into two categories (Liu et al., 2020): context-instance contrast and context-context contrast. Context-instance contrast focuses on modeling the relationships between the local feature of a sample and its global context representation. Deep InfoMax (DIM) (Hjelm et al., 2018) first proposes to maximize the mutual information between a local patch and its global context through a contrastive learning task. Deep Graph InfoMax (DGI) (Velickovic et al., 2019) proposes to learn node-level feature representation by extending DIM to graph-structured data, while InfoGraph (Sun et al., 2020a) aims to use mutual information maximization for unsupervised representation learning on entire graphs. Peng et al. (2020) propose a Graphical Mutual Information (GMI) approach to maximize the mutual information of both features and edges between inputs and outputs. In contrast to context-instance methods, contextcontext contrast studies the relationships between the global representations of different samples. M3S (Sun et al., 2020b) adopts a self-supervised pre-training paradigm as in DeepCluster (Caron et al., 2018) for better semi-supervised prediction in GCNNs. Graph Contrastive Coding (GCC)
+
+![](images/cbc8db40326b530c55230ef423a1f620241001c32f6e5f21d94a80fd4281a98d.jpg)  
+Figure 1: An example of graphs before and after topology transformations.
+
+(Qiu et al., 2020) designs the pre-training task as subgraph instance discrimination in and across networks to empower graph neural networks to learn the intrinsic structural representations.
+
+Transformation Equivariant Representation Learning. Many approaches have sought to learn transformation equivariant representations. Learning transformation equivariant representations has been advocated in Hinton’s seminal work on learning transformation capsules. Following this, a variety of approaches have been proposed to learn transformation equivariant representations (Gens & Domingos, 2014; Dieleman et al., 2015; 2016; Cohen & Welling, 2016; Lenssen et al., 2018). To generalize to generic transformations, Zhang et al. (2019) propose to learn unsupervised feature representations via Auto-Encoding Transformations (AET) by estimating transformations from the learned feature representations of both the original and transformed images, while Qi et al. (2019a) extend AET from an information-theoretic perspective by maximizing the lower bound of mutual information between transformations and representations. Wang et al. (2020) extend the AET to Generative Adversarial Networks (GANs) for unsupervised image synthesis and representation learning. Gao et al. (2020) introduce the GraphTER model that extends AET to graph-structured data, which is formalized by auto-encoding node-wise transformations in an unsupervised manner. de Haan et al. (2020) propose Gauge Equivariant Mesh CNNs which generalize GCNNs to apply anisotropic gauge equivariant kernels. Fuchs et al. (2020) introduce a self-attention mechanism specifically for 3D point cloud data, which adheres to equivariance constraints, improving robustness to nuisance transformations.
+
+# 3 METHOD
+
+# 3.1 PRELIMINARY
+
+We consider an undirected graph $\mathcal { G } = \{ \mathcal { V } , \mathcal { E } , \mathbf { A } \}$ composed of a node set $\nu$ of cardinality $| \nu | = N$ , an edge set $\mathcal { E }$ connecting nodes of cardinality $| { \mathcal { E } } | = M$ . $\mathbf { A }$ is a real symmetric $N \times N$ matrix that encodes the graph structure, where $a _ { i , j } = 1$ if there exists an edge $( i , j )$ between nodes $i$ and $j$ , and $a _ { i , j } = 0$ otherwise. Graph signal refers to data that reside on the nodes of a graph $\mathcal { G }$ , denoted by $\mathbf { X } \in \mathbb { R } ^ { N \times C }$ with the $i$ -th row representing the $C$ -dimensional graph signal on the $i$ -th node of $\nu$ .
+
+# 3.2 TOPOLOGY TRANSFORMATION
+
+We define the topology transformation $\mathbf { t }$ as adding or removing edges from the original edge set $\mathcal { E }$ in graph $\mathcal { G }$ . This can be done by sampling, i.i.d., a switch parameter $\sigma _ { i , j }$ as in (Velickovic et al., 2019), which determines whether to modify edge $( i , j )$ in the adjacency matrix. Assuming a Bernoulli distribution $B ( p )$ , where $p$ denotes the probability of each edge being modified, we draw a random matrix $\Sigma = \{ \bar { \sigma _ { i , j } } \} _ { N \times N }$ from $B ( p )$ , i.e., $\Sigma \sim B ( p )$ . We then acquire the perturbed adjacency matrix as
+
+$$
+\widetilde { \mathbf { A } } = \mathbf { A } \oplus \Sigma ,
+$$
+
+where $\oplus$ is the exclusive OR (XOR) operation. This strategy produces a transformed graph through the topology transformation $\mathbf { t }$ , i.e., $\overset { \sim } { \mathbf { A } } = \mathbf { t } ( \mathbf { A } )$ . Here, the edge perturbation probability of $p = 0$ corresponds to a non-transformed adjacency matrix, which is a special case of an identity transformation to A.
+
+The transformed adjacency matrix $\widetilde { \bf A }$ can also be written as the sum of the original adjacency matrix A and a topology perturbation matrix $\Delta \mathbf { A }$ :
+
+$$
+\begin{array} { r } { \widetilde { \bf A } = { \bf A } + \Delta { \bf A } , } \end{array}
+$$
+
+where $\Delta \mathbf { A } = \{ \delta a _ { i , j } \} _ { N \times N }$ encodes the perturbation of edges, with $\delta a _ { i , j } \in \{ - 1 , 0 , 1 \}$ . As shown in Fig. 1, when $\delta a _ { i , j } = 0$ , the edge between node $i$ and node $j$ keeps unchanged (i.e., black solid lines); when $\delta a _ { i , j } = - 1$ or 1, it means removing (i.e., orange dotted lines) or adding (i.e., blue solid lines) the edge between node $i$ and node $j$ , respectively.
+
+# 3.3 THE FORMULATION OF TOPOTER
+
+Definition 1 Given a pair of graph signal and adjacency matrix $( \mathbf { X } , \mathbf { A } )$ , and a pair of graph signal and transformed adjacency matrix $( \mathbf { X } , { \widetilde { \mathbf { A } } } )$ by a topology transformation $\mathbf { t } ( \cdot )$ , a function $E ( \cdot )$ is transformation equivariant if it satisfies
+
+$$
+E ( \mathbf { X } , { \widetilde { \mathbf { A } } } ) = E \left( \mathbf { X } , \mathbf { t } ( \mathbf { A } ) \right) = \rho ( \mathbf { t } ) \left[ E ( \mathbf { X } , \mathbf { A } ) \right] ,
+$$
+
+where $\rho ( \mathbf t ) [ \cdot ]$ is a homomorphism of transformation t in the representation space.
+
+Let us denote $\mathbf { H } = E ( \mathbf { X } , \mathbf { A } )$ , and $\widetilde { \mathbf { H } } = E ( \mathbf { X } , \widetilde { \mathbf { A } } )$ . We seek to learn an encoder $E : ( { \bf X } , { \bf A } ) \mapsto$ $\mathbf { H } ; ( \mathbf { X } , \widetilde { \mathbf { A } } ) \mapsto \widetilde { \mathbf { H } }$ that maps both the original and transformed sample to representations $\{ \mathbf { H } , \widetilde { \mathbf { H } } \}$ equivariant to the sampled transformation $\mathbf { t }$ , whose information can thus be inferred from the representations via a decoder $D : ( \widetilde { \mathbf { H } } , \mathbf { H } ) \mapsto \widehat { \Delta \mathbf { A } }$ as much as possible. From an information-theoretic perspective, this requires $( \mathbf { H } , \Delta \mathbf { A } )$ should jointly contain all necessary information about $\widetilde { \bf H }$ .
+
+Then a natural choice to formalize the topology transformation equivariance is the mutual information $I ( \mathbf { H } , \Delta \mathbf { A } ; \widetilde { \mathbf { H } } )$ between $( \mathbf { H } , \Delta \mathbf { A } )$ and $\widetilde { \bf H }$ . The larger the mutual information is, the more knowledge about $\Delta \mathbf { A }$ can be inferred from the representations $\{ \mathbf { H } , \widetilde { \mathbf { H } } \}$ . Hence, we propose to maximize the mutual information to learn the topology transformation equivariant representations as follows:
+
+$$
+\operatorname* { m a x } _ { \theta } I ( \mathbf { H } , \Delta \mathbf { A } ; \widetilde { \mathbf { H } } ) ,
+$$
+
+where $\theta$ denotes the parameters of the auto-encoder network.
+
+Nevertheless, it is difficult to compute the mutual information directly. Instead, we derive that maximizing the mutual information can be relaxed to minimizing the cross entropy, as described in the following theorem.
+
+Theorem 1 The maximization of the mutual information $I ( \mathbf { H } , \Delta \mathbf { A } ; \widetilde { \mathbf { H } } )$ can be relaxed to the minimization of the cross entropy $H ( p \parallel q )$ between the probability distributions $p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } )$ and $q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } )$ :
+
+$$
+\operatorname* { m i n } _ { \theta } ~ H \left( p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) \parallel q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } ) \right) \triangleq - \underset { p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) } { \mathbb { E } } \log q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } ) .
+$$
+
+Proof By using the chain rule of mutual information, we have
+
+$$
+I ( \mathbf { H } , \Delta \mathbf { A } ; \widetilde { \mathbf { H } } ) = I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } ) + I ( \mathbf { H } ; \widetilde { \mathbf { H } } ) \ge I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } ) .
+$$
+
+Thus the mutual information $I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } )$ is the lower bound of the mutual information $I ( \mathbf { H } , \Delta \mathbf { A } ; \widetilde { \mathbf { H } } )$ that attains its minimum value when $I ( \mathbf { H } ; \widetilde { \mathbf { H } } ) = 0$ .
+
+Therefore, we relax the objective to maximizing the lower bound mutual information $I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } )$ between the transformed representation $\widetilde { \bf H }$ and the topology transformation $\Delta \mathbf { A }$ :
+
+$$
+I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } ) = H ( \Delta \mathbf { A } | \mathbf { H } ) - H ( \Delta \mathbf { A } | \widetilde { \mathbf { H } } , \mathbf { H } ) ,
+$$
+
+where $H ( \cdot )$ denotes the conditional entropy. Since $\Delta \mathbf { A }$ and $\mathbf { H }$ are independent, we have $H ( \Delta \mathbf { A } | \mathbf { H } ) = H ( \Delta \mathbf { A } )$ . Hence, maximizing $I ( \Delta \mathbf { A } ; \widetilde { \mathbf { H } } | \mathbf { H } )$ becomes
+
+$$
+\operatorname* { m i n } _ { \theta } \ H ( \Delta \mathbf { A } | \widetilde { \mathbf { H } } , \mathbf { H } ) .
+$$
+
+According to the chain rule of conditional entropy, we have
+
+$$
+H ( \Delta \mathbf { A } | \widetilde { \mathbf { H } } , \mathbf { H } ) = H ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) - H ( \widetilde { \mathbf { H } } , \mathbf { H } ) \leq H ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) ,
+$$
+
+![](images/d71ce9251b65e6c86f27cf303680468a96f1e7c79d30276ae320dce1ce6de06d.jpg)  
+Figure 2: The architecture of the proposed TopoTER.
+
+where the conditional entropy ${ \cal H } ( \Delta { \bf A } | \widetilde { \bf H } , { \bf H } )$ is upper bounded by the joint entropy $H ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } )$ . Thus, the minimization problem in Eq. (6) becomes
+
+$$
+\operatorname* { m i n } _ { \theta } \ H ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) .
+$$
+
+We next introduce a conditional probability distribution $q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } )$ to approximate the intractable posterior $\tilde { q } ( \Delta \mathbf { A } | \tilde { \mathbf { H } } , \mathbf { H } )$ with an estimated $\widehat { \Delta \mathbf { A } }$ . According to the definition of the Kullback-Leibler divergence, we have
+
+$$
+H ( \Delta \mathbf { A } , { \widetilde { \mathbf { H } } } , \mathbf { H } ) = H ( p ) = H ( p \parallel q ) - D _ { \mathrm { K L } } ( p \parallel q ) \leq H ( p \parallel q ) ,
+$$
+
+where $D _ { \mathrm { K L } } ( p \parallel q )$ denotes the Kullback-Leibler divergence of $p$ and $q$ that is non-negative, and $H ( p \parallel q )$ is the cross entropy between $p$ and $q$ . Thus, Eq. (6) is converted to minimizing the cross entropy as the upper bound:
+
+$$
+\operatorname* { m i n } _ { \theta } ~ H \left( p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) \parallel q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } ) \right) \triangleq - \underset { p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) } { \mathbb { E } } \log q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } ) .
+$$
+
+Hence, we relax the maximization problem in Eq. (4) to the optimization in Eq. (5).
+
+Based on Theorem 1, we train the decoder $D$ to learn the distribution $q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } )$ so as to estimate the topology transformation $\widehat { \Delta \mathbf { A } }$ from the encoded $\{ \widetilde { \mathbf { H } } , \mathbf { H } \}$ , where the input pairs of original and transformed graph representations $\{ \widetilde { \mathbf { H } } , \mathbf { H } \}$ as well as the ground truth target $\Delta \mathbf { A }$ can be sampled tractably from the factorization of $p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } ) \triangleq p ( \Delta \mathbf { A } ) p ( \mathbf { H } ) p ( \widetilde { \mathbf { H } } | \Delta \mathbf { A } , \mathbf { H } )$ . This allows us to minimize the cross entropy between $p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } )$ and $q ( \widehat { \Delta \mathbf { A } } | \widetilde { \mathbf { H } } , \mathbf { H } )$ as in (5) with the training triplets $( \widetilde { \mathbf { H } } , \mathbf { H } ; \Delta \mathbf { A } )$ drawn from the tractable factorization of $p ( \Delta \mathbf { A } , \widetilde { \mathbf { H } } , \mathbf { H } )$ . Hence, we formulate the TopoTER as the joint optimization of the representation encoder $E$ and the transformation decoder $D$ .
+
+# 3.4 THE ALGORITHM
+
+We design a graph-convolutional auto-encoder network for the TopoTER learning, as illustrated in Fig. 2. Given a graph signal $\mathbf { X }$ associated with a graph $\mathcal { G } = \{ \bar { \nu _ { , } } \mathcal { E } , \mathbf { A } \}$ , the proposed unsupervised learning algorithm for the TopoTER consists of three steps: 1) topology transformation, which samples and perturbs some edges from $\mathcal { E }$ to acquire a transformed adjacency matrix $\widetilde { \bf A }$ ; 2) representation encoding, which extracts the feature representations of graph signals before and after the topology transformation; 3) transformation decoding, which estimates the topology transformation parameters from the learned feature representations. We elaborate on the three steps as follows.
+
+Topology Transformation. We randomly sample a subset of edges from $\mathcal { E }$ for topology perturbation—adding or removing edges, which not only enables to characterize local graph structures at various scales, but also reduces the number of edge transformation parameters to estimate for computational efficiency. In practice, in each iteration of training, we sample all the node pairs with connected edges $\mathbf { S } _ { 1 }$ , and randomly sample a subset of disconnected node pairs $\mathbf { S } _ { 0 }$ , i.e.,
+
+$$
+\begin{array} { r } { \mathbf { S } _ { 0 } = \left\{ ( i , j ) \big | a _ { i , j } = 0 \right\} , \mathbf { S } _ { 1 } = \left\{ ( i , j ) \big | a _ { i , j } = 1 \right\} , } \end{array}
+$$
+
+where $| \mathbf { S } _ { 0 } | = | \mathbf { S } _ { 1 } | = M$ . Next, we randomly split $\mathbf { S } _ { 0 }$ and $\mathbf { S } _ { 1 }$ into two disjoint sets, respectively, i.e.,
+
+$$
+\mathbf { S } _ { i } = \left\{ \mathbf { S } _ { i } ^ { ( 1 ) } , \mathbf { S } _ { i } ^ { ( 2 ) } \ \big \vert \ \mathbf { S } _ { i } ^ { ( 1 ) } \cap \mathbf { S } _ { i } ^ { ( 2 ) } = \mathcal { Q } , \mathbf { S } _ { i } ^ { ( 1 ) } \cup \mathbf { S } _ { i } ^ { ( 2 ) } = \mathbf { S } _ { i } , \big \vert \mathbf { S } _ { i } ^ { ( 1 ) } \big \vert = r \cdot \big \vert \mathbf { S } _ { i } \big \vert \right\} , i \in \{ 0 , 1 \} ,
+$$
+
+where $r$ is the edge perturbation rate. Then, for each node pair $( i , j )$ in $\mathbf { S } _ { 0 } ^ { ( 1 ) }$ and $\mathbf { S } _ { 1 } ^ { ( 1 ) }$ , we flip the corresponding entry in the original graph adjacency matrix. That is, if $a _ { i , j } = 0$ , then we set $\tilde { a } _ { i , j } = 1$ ; otherwise, we set $\tilde { a } _ { i , j } = 0$ . For each node pair $( i , j )$ in $\mathbf { S } _ { 0 } ^ { ( 2 ) }$ and $\mathbf { S } _ { 1 } ^ { ( 2 ) }$ , we keep the original connectivities unchanged, i.e., $\tilde { a } _ { i , j } = a _ { i , j }$ .
+
+This leads to the transformed adjacency matrix $\widetilde { \bf A }$ , as well as the sampled transformation parameters by accessing $\Delta \mathbf { A }$ at position $( i , j )$ from $\mathbf { S } _ { 0 }$ and $\mathbf { S } _ { 1 }$ . Also, we can category the sampled topology transformation parameters into four types:
+
+1. add an edge to a disconnected node pair, i.e., $\{ \mathbf { t } : a _ { i , j } = 0 \mapsto \tilde { a } _ { i , j } = 1 , ( i , j ) \in \mathbf { S } _ { 0 } ^ { ( 1 ) } \} ;$ ;   
+2. delete the edge between a connected node pair, i.e., $\{ \mathbf { t } : a _ { i , j } = 1 \mapsto \tilde { a } _ { i , j } = 0 , ( i , j ) \in \mathbf { S } _ { 1 } ^ { ( 1 ) } \}$ ;   
+3. keep the disconnection between node pairs in $\mathbf { S } _ { 0 } ^ { ( 2 ) }$ , i.e., $\{ \mathbf { t } : a _ { i , j } = 0 \mapsto \tilde { a } _ { i , j } = 0 , ( i , j ) \in \mathbf { S } _ { 0 } ^ { ( 2 ) } \} ;$   
+4. keep the connection between node pairs in $\mathbf { S } _ { 1 } ^ { ( 2 ) }$ , i.e., $\{ \mathbf { t } : a _ { i , j } = 1 \mapsto \tilde { a } _ { i , j } = 1 , ( i , j ) \in \mathbf { S } _ { 1 } ^ { ( 2 ) } \}$ .
+
+Thus, we cast the problem of estimating transformation parameters in $\Delta \mathbf { A }$ from $( \widetilde { \mathbf { H } } , \mathbf { H } )$ as the classification problem of the transformation parameter types. The percentage of these four types is $r : r : ( 1 - r ) : ( 1 - r )$ .
+
+Representation Encoder. We train an encoder $E : ( \mathbf { X } , \mathbf { A } ) \mapsto E ( \mathbf { X } , \mathbf { A } )$ to encode the feature representations of each node in the graph. As demonstrated in Fig. 2, we leverage GCNNs with shared weights to extract feature representations of each node in the graph signal. Taking the GCN (Kipf & Welling, 2017) as an example, the graph convolution in the GCN is defined as
+
+$$
+\mathbf { H } = E ( \mathbf { X } , \mathbf { A } ) = \mathbf { D } ^ { - { \frac { 1 } { 2 } } } ( \mathbf { A } + \mathbf { I } ) \mathbf { D } ^ { - { \frac { 1 } { 2 } } } \mathbf { X } \mathbf { W } ,
+$$
+
+where $\mathbf { D }$ is the degree matrix of $\mathbf { A } + \mathbf { I }$ , $\mathbf { W } \in \mathbb { R } ^ { C \times F }$ is a learnable parameter matrix, and $\mathbf { H } =$ $[ \mathbf { h } _ { 1 } , . . . , \mathbf { h } _ { N } ] ^ { \top } \in \mathbb { R } ^ { \breve { N } \times F }$ denotes the node-wise feature matrix with $F$ output channels. Similarly, the node feature of the transformed counterpart is as follows with the shared weights $\mathbf { W }$ .
+
+$$
+\begin{array} { r } { \widetilde { \mathbf { H } } = E ( \mathbf { X } , \widetilde { \mathbf { A } } ) = \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } ( \widetilde { \mathbf { A } } + \mathbf { I } ) \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \mathbf { X } \mathbf { W } \quad } \\ { = \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } ( \mathbf { A } + \mathbf { I } ) \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \mathbf { X } \mathbf { W } + \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \Delta \mathbf { A } \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \mathbf { X } \mathbf { W } . } \end{array}
+$$
+
+We thus acquire the feature representations $\mathbf { H }$ and $\widetilde { \bf H }$ of graph signals before and after topology transformations.
+
+Transformation Decoder. Comparing Eq. (10) and Eq. (11), the prominent difference between $\widetilde { \bf H }$ and $\mathbf { H }$ lies in the second term of Eq. (11) featuring $\Delta \mathbf { A }$ . This enables us to train a decoder $D : ( \widetilde { \mathbf { H } } , \mathbf { H } ) \mapsto \widehat { \Delta \mathbf { A } }$ to estimate the topology transformation from the joint representations before and after transformation. We first take the difference between the extracted feature representations before and after transformations along the feature channel,
+
+$$
+\Delta { \bf H } = \widetilde { { \bf H } } - { \bf H } = [ \delta { \bf h } _ { 1 } , . . . , \delta { \bf h } _ { N } ] ^ { \top } \in \mathbb { R } ^ { N \times F } .
+$$
+
+Thus, we can predict the topology transformation between node $i$ and node $j$ through the node-wise feature difference $\Delta \mathbf { H }$ by constructing the edge representation as
+
+$$
+\mathbf { e } _ { i , j } = \frac { \exp \{ - ( \delta \mathbf { h } _ { i } - \delta \mathbf { h } _ { j } ) \odot ( \delta \mathbf { h } _ { i } - \delta \mathbf { h } _ { j } ) \} } { \lVert \exp \{ - ( \delta \mathbf { h } _ { i } - \delta \mathbf { h } _ { j } ) \odot ( \delta \mathbf { h } _ { i } - \delta \mathbf { h } _ { j } ) \} \rVert _ { 1 } } \in \mathbb { R } ^ { F } , \quad \forall ( i , j ) \in \mathbf { S } _ { 0 } \cup \mathbf { S } _ { 1 } ,
+$$
+
+where $\odot$ denotes the Hadamard product of two vectors to capture the feature representation, and $\| \cdot \| _ { 1 }$ is the $\ell _ { 1 }$ -norm of a vector for normalization. The edge representation $\mathbf { e } _ { i , j }$ of node $i$ and $j$ is then fed into several linear layers for the prediction of the topology transformation,
+
+$$
+\widehat { \mathbf { y } } _ { i , j } = \mathrm { s o f t m a x } \left( \mathrm { l i n e a r } ( \mathbf { e } _ { i , j } ) \right) , \quad \forall ( i , j ) \in \mathbf { S } _ { 0 } \cup \mathbf { S } _ { 1 } ,
+$$
+
+where softmax $( \cdot )$ is an activation function.
+
+According to Eq. (5), the entire auto-encoder network is trained by minimizing the cross entropy
+
+$$
+\mathcal { L } = - \underset { ( i , j ) \in { \bf S } _ { 0 } \cup { \bf S } _ { 1 } } { \mathbb { E } } \sum _ { f = 0 } ^ { 3 } { \bf y } _ { i , j } ^ { ( f ) } \log \widehat { \bf y } _ { i , j } ^ { ( f ) } ,
+$$
+
+where $f$ denotes the transformation type $( f \in \{ 0 , 1 , 2 , 3 \}$ ), and $\mathbf { y }$ is the ground-truth binary indicator (0 or 1) for each transformation parameter type.
+
+Table 1: Node classification accuracies (with standard deviation) in percentage on three datasets. X, A, Y denote the input data, adjacency matrix and labels respectively.   
+
+<table><tr><td>Method</td><td>TrainingData</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td colspan="5">Semi-SupervisedMethods</td></tr><tr><td>GCN(Kipf&amp;Welling,2017)</td><td>X,A,Y</td><td>81.5</td><td>70.3</td><td>79.0</td></tr><tr><td>MoNet (Monti et al.,2017)</td><td>X,A,Y</td><td>81.7 ± 0.5</td><td>-</td><td>78.8± 0.3</td></tr><tr><td>GAT(Velickovic et al.,2018)</td><td>X,A,Y</td><td>83.0 ±0.7</td><td>72.5±0.7</td><td>79.0±0.3</td></tr><tr><td>SGC (Wu et al., 2019)</td><td>X,A,Y</td><td>81.0 ±0.0</td><td>71.9 ± 0.1</td><td>78.9 ± 0.0</td></tr><tr><td>GWNN (Xu et al.,2019a)</td><td>X,A,Y</td><td>82.8</td><td>71.7</td><td>79.1</td></tr><tr><td>MixHop (Abu-El-Haija et al., 2019)</td><td>X,A,Y</td><td>81.9 ± 0.4</td><td>71.4 ± 0.8</td><td>80.8±0.6</td></tr><tr><td>DFNet (Wijesinghe&amp; Wang,2019)</td><td>X,A,Y</td><td>85.2 ±0.5</td><td>74.2 ± 0.3</td><td>84.3 ± 0.4</td></tr><tr><td colspan="5">Unsupervised Methods</td></tr><tr><td>RawFeatures(Velickovic et al.,2019)</td><td>X</td><td>47.9±0.4</td><td>49.3±0.2</td><td>69.1±0.3</td></tr><tr><td>DeepWalk (Perozzi et al.,2014)</td><td>A</td><td>67.2</td><td>43.2</td><td>65.3</td></tr><tr><td>DeepWalk + Features (Velickovic et al., 2019)</td><td>X,A</td><td>70.7 ± 0.6</td><td>51.4 ± 0.5</td><td>74.3 ± 0.9</td></tr><tr><td>GAE (Kipf &amp; Welling,2016)</td><td>X,A</td><td>80.9 ± 0.4</td><td>66.7±0.4</td><td>77.1 ±0.7</td></tr><tr><td>VGAE (Kipf &amp; Welling,2016)</td><td>X,A</td><td>80.0±0.2</td><td>64.1 ± 0.2</td><td>76.9 ± 0.1</td></tr><tr><td>DGI (Velickovic et al.,2019)</td><td>X,A</td><td>81.1 ± 0.1</td><td>71.4 ± 0.2</td><td>77.0± 0.2</td></tr><tr><td>GMI (Peng et al.,2020)</td><td>X,A</td><td>82.2 ±0.2</td><td>71.4± 0.5</td><td>78.5 ±0.1</td></tr><tr><td>TopoTER</td><td>X,A</td><td>83.7 ± 0.3</td><td>71.7 ± 0.5</td><td>79.1 ± 0.1</td></tr></table>
+
+Table 2: Model size comparison of DGI, GMI, and the proposed TopoTER   
+
+<table><tr><td>Model</td><td>DGI</td><td>GMI</td><td>TopoTER</td></tr><tr><td>No.of Parameters</td><td>996,354</td><td>1,730,052</td><td>736,260</td></tr></table>
+
+# 4 EXPERIMENTS
+
+# 4.1 NODE CLASSIFICATION
+
+Datasets. We adopt three citation networks to evaluate our model: Cora, Citeseer, and Pubmed (Sen et al., 2008), where nodes correspond to documents and edges represent citations. We follow the standard train/test split in (Kipf & Welling, 2017) to conduct the experiments.
+
+Implementation Details. In this task, the auto-encoder network is trained via Adam optimizer, and the learning rate is set to $1 0 ^ { - 4 }$ . We use the same early stopping strategy as DGI (Velickovic et al., 2019) on the observed training loss, with a patience of 20 epochs. We deploy one Simple Graph Convolution (SGC) layer (Wu et al., 2019) as our encoder, and the order of the adjacency matrix is set to 2, while we will study the order of the adjacency matrix in Appendix A. The LeakyReLU activation function with a negative slope of 0.1 is employed after the SGC layer. Similar to DGI (Velickovic et al., 2019), we set the output channel $F = 5 1 2$ for Cora and Citeseer dataset, and 256 for Pubmed dataset due to memory limitations. After the encoder, we use one linear layer to classify the transformation types. We set the edge perturbation rate in Eq. (9) as $r = \{ 0 . 7 , 0 . 4 , 0 . 7 \}$ for Cora, Citeseer, and Pubmed, respectively. The analysis of the edge perturbation rate will be presented in Appendix B.
+
+During the training procedure of the classifier, the SGC layer in the encoder is used to extract graph feature representations with the weights frozen. After the SGC layer, we apply one linear layer to map the features to the classification scores.
+
+Experimental Results. We compare the proposed method with five unsupervised methods, including one node embedding method DeepWalk, two graph auto-encoders GAE and VGAE (Kipf & Welling, 2016), and two contrastive learning methods DGI (Velickovic et al., 2019) and GMI (Peng et al., 2020). Additionally, we report the results of Raw Features and DeepWalk+Features (Perozzi et al., 2014) under the same settings. For fair comparison, the results of all other unsupervised methods are reproduced by using the same encoder architecture of the TopoTER except DeepWalk and Raw Features. We report the mean classification accuracy (with standard deviation) on the test nodes for all methods after 50 runs of training. As reported in Tab. 1, the TopoTER outperforms all other competing unsupervised methods on three datasets. Further, the proposed unsupervised method also achieves comparable performance with semi-supervised results. This significantly closes the gap between unsupervised approaches and the semi-supervised methods.
+
+Moreover, we compare the proposed TopoTER with two contrastive learning methods DGI and GMI in terms of the model complexity, as reported in Tab. 2. The number of parameters in our model is less than that of DGI and even less than half of that of GMI, which further shows the TopoTER model is lightweight.
+
+Table 3: Graph classification accuracies (with standard deviation) in percentage on 6 datasets. $^ { 6 6 } > 1$ Day” represents that the computation exceeds 24 hours. “OOM” is out of memory error.   
+
+<table><tr><td>Dataset (No.Graphs) (No. Classes)</td><td>MUTAG 188 2</td><td>PTC-MR 344 2</td><td>RDT-B 2000 2</td><td>RDT-M5K 4999 5</td><td>IMDB-B 1000 2</td><td>IMDB-M 1500 3</td></tr><tr><td colspan="7">GraphKernelMethods</td></tr><tr><td>RW</td><td>83.72 ±1.50</td><td>57.85 ±1.30</td><td>OOM</td><td>OOM</td><td>50.68±0.26</td><td>34.65 ±0.19</td></tr><tr><td>SP</td><td>85.22 ± 2.43</td><td>58.24 ± 2.44</td><td>64.11 ± 0.14</td><td>39.55 ±0.22</td><td>55.60±0.22</td><td>37.99 ± 0.30</td></tr><tr><td>GK</td><td>81.66 ± 2.11</td><td>57.26 ± 1.41</td><td>77.34 ± 0.18</td><td>41.01 ± 0.17</td><td>65.87 ±0.98</td><td>43.89 ±0.38</td></tr><tr><td>WL</td><td>80.72 ±3.00</td><td>57.97 ± 0.49</td><td>68.82 ±0.41</td><td>46.06 ±0.21</td><td>72.30 ± 3.44</td><td>46.95 ± 0.46</td></tr><tr><td>DGK</td><td>87.44 ±2.72</td><td>60.08 ±2.55</td><td>78.04±0.39</td><td>41.27 ± 0.18</td><td>66.96 ±0.56</td><td>44.55± 0.52</td></tr><tr><td>MLG</td><td>87.94 ± 1.61</td><td>63.26 ± 1.48</td><td>&gt;1Day</td><td>&gt;1Day</td><td>66.55 ± 0.25</td><td>41.17 ± 0.03</td></tr><tr><td colspan="7">SupervisedMethods</td></tr><tr><td>GCN</td><td>85.6±5.8</td><td>64.2± 4.3</td><td>50.0±0.0</td><td>20.0±0.0</td><td>74.0±3.0</td><td>51.9±3.8</td></tr><tr><td>GraphSAGE</td><td>85.1± 7.6</td><td>63.9 ±7.7</td><td></td><td>=</td><td>72.3 ± 5.3</td><td>50.9 ± 2.2</td></tr><tr><td>GIN-0</td><td>89.4±5.6</td><td>64.6±7.0</td><td>92.4±2.5</td><td>57.5 ± 1.5</td><td>75.1 ± 5.1</td><td>52.3±2.8</td></tr><tr><td>GIN-e</td><td>89.0±6.0</td><td>63.7±8.2</td><td>92.2±2.3</td><td>57.0 ±1.7</td><td>74.3 ± 5.1</td><td>52.1±3.6</td></tr><tr><td colspan="7">Unsupervised Methods</td></tr><tr><td>node2vec</td><td>72.63±10.20</td><td>58.58±8.00</td><td></td><td>=</td><td>=</td><td></td></tr><tr><td>sub2vec</td><td>61.05 ± 15.80 83.15 ±9.25</td><td>59.99 ±6.38</td><td>71.48 ± 0.41 75.78 ±1.03</td><td>36.68 ±0.42 47.86 ±0.26</td><td>55.26 ± 1.54</td><td>36.67±0.83</td></tr><tr><td>graph2vec</td><td>89.01 ± 1.13</td><td>60.17 ±6.86 61.65 ±1.43</td><td>82.50 ±1.42</td><td>53.46 ± 1.03</td><td>71.10 ±0.54 73.03 ± 0.87</td><td>50.44 ± 0.87</td></tr><tr><td>InfoGraph TopoTER</td><td>89.25 ±0.81</td><td>64.59 ±1.26</td><td>84.93 ±0.18</td><td>55.52±0.20</td><td>73.46 ±0.38</td><td>49.69 ± 0.53</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>49.68 ±0.31</td></tr></table>
+
+# 4.2 GRAPH CLASSIFICATION
+
+Datasets. We conduct graph classification experiments on six well-known graph benchmark datasets (Yanardag & Vishwanathan, 2015): MUTAG, PTC, REDDIT-BINARY, REDDIT-MULTI5K, IMDB-BINARY, and IMDB-MULTI.
+
+Implementation Details. In this task, the entire network is trained via Adam optimizer with a batch size of 64, and the learning rate is set to $1 0 ^ { - 3 }$ . For the encoder architecture, we follow the same encoder settings in the released code of InfoGraph (Sun et al., 2020a), i.e., three Graph Isomorphism Network (GIN) layers (Xu et al., 2019b) with batch normalization. We also use one linear layer to classify the transformation types. We set the sampling rate $r = 0 . 5$ for all datasets.
+
+During the evaluation stage, the entire encoder will be frozen to extract node-level feature representations, which will go through a global add pooling layer to acquire global features. We then use LIBSVM to classify these global features to classification scores. We adopt the same procedure of previous works (Sun et al., 2020a) to make a fair comparison and use 10-fold cross validation accuracy to report the classification performance, and the experiments are repeated five times.
+
+Experimental Results. We take six graph kernel approaches for comparison: Random Walk (RW) (Gartner et al., 2003), Shortest Path Kernel (SP) (Borgwardt & Kriegel, 2005), Graphlet Kernel ¨ (GK) (Shervashidze et al., 2009), Weisfeiler-Lehman Sub-tree Kernel (WL) (Shervashidze et al., 2011), Deep Graph Kernels (DGK) (Yanardag & Vishwanathan, 2015), and Multi-Scale Laplacian Kernel (MLG) (Kondor & Pan, 2016). Aside from graph kernel methods, we also compare with three unsupervised graph-level representation learning methods: node2vec (Grover & Leskovec, 2016), sub2vec (Adhikari et al., 2018), and graph2vec (Narayanan et al., 2017), and one contrastive learning method: InfoGraph (Sun et al., 2020a). The experimental results of unsupervised graph classification are preseted in Tab. 3. The proposed TopoTER outperforms all unsupervised baseline methods on the first five datasets, and achieves comparable results on the other dataset. Also, the proposed approach reaches the performance of supervised methods at times, thus validating the effectiveness of the TopoTER model.
+
+# 5 CONCLUSION
+
+We propose Topology Transformation Equivariant Representation (TopoTER) for learning unsupervised representations on graph data. By maximizing the mutual information between topology transformations and feature representations before and after transformations, the TopoTER enforces the encoder to learn intrinsic graph feature representations that contain sufficient information about structures under applied topology transformations. We apply the TopoTER model to node classification and graph classification tasks, and results demonstrate that the TopoTER outperforms stateof-the-art unsupervised approaches and reaches the performance of supervised methods at times.
+
+# REFERENCES
+
+Sami Abu-El-Haija, Bryan Perozzi, Amol Kapoor, Nazanin Alipourfard, Kristina Lerman, Hrayr Harutyunyan, Greg Ver Steeg, and Aram Galstyan. Mixhop: Higher-order graph convolutional architectures via sparsified neighborhood mixing. In Proceedings of the 36th International Conference on Machine Learning (ICML), pp. 21–29, 2019.
+
+Bijaya Adhikari, Yao Zhang, Naren Ramakrishnan, and B Aditya Prakash. Sub2vec: Feature learning for subgraphs. In Pacific-Asia Conference on Knowledge Discovery and Data Mining, pp. 170–182. Springer, 2018.
+
+Karsten M Borgwardt and Hans-Peter Kriegel. Shortest-path kernels on graphs. In IEEE International Conference on Data Mining (ICDM), pp. 8–pp. IEEE, 2005.
+
+Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.
+
+Shaosheng Cao, Wei Lu, and Qiongkai Xu. Deep neural networks for learning graph representations. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), volume 16, pp. 1145– 1152, 2016.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 132–149, 2018.
+
+Taco Cohen and Max Welling. Group equivariant convolutional networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML), pp. 2990–2999, 2016.
+
+Nicola De Cao and Thomas Kipf. MolGAN: An implicit generative model for small molecular graphs. In International Conference on Machine Learning Workshop on Theoretical Foundations and Applications of Deep Generative Models, 2018.
+
+Pim de Haan, Maurice Weiler, Taco Cohen, and Max Welling. Gauge equivariant mesh cnns: Anisotropic convolutions on geometric graphs. arXiv preprint arXiv:2003.05425, 2020.
+
+Sander Dieleman, Kyle W Willett, and Joni Dambre. Rotation-invariant convolutional neural networks for galaxy morphology prediction. Monthly Notices of the Royal Astronomical Society, 450 (2):1441–1459, 2015.
+
+Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. In International Conference on Machine Learning (ICML), pp. 1889– 1898, 2016.
+
+Fabian B Fuchs, Daniel E Worrall, Volker Fischer, and Max Welling. Se (3)-transformers: 3d rototranslation equivariant attention networks. arXiv preprint arXiv:2006.10503, 2020.
+
+Xiang Gao, Wei Hu, and Guo-Jun Qi. GraphTER: Unsupervised learning of graph transformation equivariant representations via auto-encoding node-wise transformations. In Proceedings of IEEE/CVF Conferences on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+Thomas Gartner, Peter Flach, and Stefan Wrobel. On graph kernels: Hardness results and efficient ¨ alternatives. In Learning Theory and Kernel Machines, pp. 129–143. Springer, 2003.
+
+Robert Gens and Pedro M Domingos. Deep symmetry networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2537–2545, 2014.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 855–864, 2016.
+
+Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks (ICANN), pp. 44–51. Springer, 2011.
+
+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. In International Conference on Learning Representations (ICLR), 2018.
+
+Thomas N Kipf and Max Welling. Variational graph auto-encoders. In Proceedings of the NIPS Workshop on Bayesian Deep Learning, 2016.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Jyri J Kivinen and Christopher KI Williams. Transformation equivariant boltzmann machines. In International Conference on Artificial Neural Networks (ICANN), pp. 1–9. Springer, 2011.
+
+Risi Kondor and Horace Pan. The multiscale laplacian graph kernel. In Advances in Neural Information Processing Systems (NIPS), pp. 2990–2998, 2016.
+
+Karel Lenc and Andrea Vedaldi. Understanding image representations by measuring their equivariance and equivalence. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 991–999, 2015.
+
+Jan Eric Lenssen, Matthias Fey, and Pascal Libuschewski. Group equivariant capsule networks. In Advances in Neural Information Processing Systems (NIPS), pp. 8844–8853, 2018.
+
+Xiao Liu, Fanjin Zhang, Zhenyu Hou, Zhaoyu Wang, Li Mian, Jing Zhang, and Jie Tang. Selfsupervised learning: Generative or contrastive. arXiv, pp. arXiv–2006, 2020.
+
+Tengfei Ma, Jie Chen, and Cao Xiao. Constrained generation of semantically valid graphs via regularizing variational autoencoders. In Advances in Neural Information Processing Systems (NIPS), pp. 7113–7124, 2018.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5115–5124, 2017.
+
+Annamalai Narayanan, Mahinthan Chandramohan, Rajasekar Venkatesan, Lihui Chen, Yang Liu, and Shantanu Jaiswal. graph2vec: Learning distributed representations of graphs. In Proceedings of the 13th International Workshop on Mining and Learning with Graphs (MLG), 2017.
+
+Zhen Peng, Wenbing Huang, Minnan Luo, Qinghua Zheng, Yu Rong, Tingyang Xu, and Junzhou Huang. Graph representation learning via graphical mutual information maximization. In Proceedings of The Web Conference, pp. 259–270, 2020.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 701–710, 2014.
+
+Guo-Jun Qi, Liheng Zhang, Chang Wen Chen, and Qi Tian. AVT: Unsupervised learning of transformation equivariant representations by autoencoding variational transformations. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019a.
+
+Guo-Jun Qi, Liheng Zhang, and Xiao Wang. Learning generalized transformation equivariant representations via autoencoding transformations. arXiv preprint arXiv:1906.08628, 2019b.
+
+Jiezhong Qiu, Qibin Chen, Yuxiao Dong, Jing Zhang, Hongxia Yang, Ming Ding, Kuansan Wang, and Jie Tang. Gcc: Graph contrastive coding for graph neural network pre-training. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 1150–1160, 2020.
+
+Uwe Schmidt and Stefan Roth. Learning rotation-aware features: From invariant priors to equivariant descriptors. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2050–2057. IEEE, 2012.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Nino Shervashidze, SVN Vishwanathan, Tobias Petri, Kurt Mehlhorn, and Karsten Borgwardt. Efficient graphlet kernels for large graph comparison. In Artificial Intelligence and Statistics, pp. 488–495, 2009.
+
+Nino Shervashidze, Pascal Schweitzer, Erik Jan Van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(9), 2011.
+
+Martin Simonovsky and Nikos Komodakis. Graphvae: Towards generation of small graphs using variational autoencoders. In International Conference on Artificial Neural Networks (ICANN), pp. 412–422. Springer, 2018.
+
+Henrik Skibbe. Spherical Tensor Algebra for Biomedical Image Analysis. PhD thesis, Verlag nicht ermittelbar, 2013.
+
+Kihyuk Sohn and Honglak Lee. Learning invariant representations with local transformations. In International Conference on Machine Learning (ICML), pp. 1339–1346, 2012.
+
+Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semisupervised graph-level representation learning via mutual information maximization. In International Conference on Learning Representations (ICLR), 2020a.
+
+Ke Sun, Zhouchen Lin, and Zhanxing Zhu. Multi-stage self-supervised learning for graph convolutional networks on graphs with few labeled nodes. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), pp. 5892–5899, 2020b.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations (ICLR), 2018.
+
+Petar Velickovic, William Fedus, William L Hamilton, Pietro Lio, Yoshua Bengio, and R Devon \` Hjelm. Deep graph infomax. In International Conference on Learning Representations (ICLR), 2019.
+
+Daixin Wang, Peng Cui, and Wenwu Zhu. Structural deep network embedding. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1225–1234, 2016.
+
+Jiayu Wang, Wengang Zhou, Guo-Jun Qi, Zhongqian Fu, Qi Tian, and Houqiang Li. Transformation gan for unsupervised image synthesis and representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 472–481, 2020.
+
+WOK Asiri Suranga Wijesinghe and Qing Wang. Dfnets: Spectral cnns for graphs with feedbacklooped filters. In Advances in Neural Information Processing Systems (NIPS), pp. 6009–6020, 2019.
+
+Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. In Proceedings of the 36th International Conference on Machine Learning (ICML), pp. 6861–6871, 2019.
+
+Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020.
+
+Bingbing Xu, Huawei Shen, Qi Cao, Yunqi Qiu, and Xueqi Cheng. Graph wavelet neural network. In International Conference on Learning Representations (ICLR), 2019a.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations (ICLR), 2019b.
+
+Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1365–1374, 2015.
+
+Jiaxuan You, Rex Ying, Xiang Ren, William L Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. In Proceedings of the 35th International Conference on Machine Learning (ICML), pp. 5694–5703, 2018.
+
+Liheng Zhang, Guo-Jun Qi, Liqiang Wang, and Jiebo Luo. AET vs. AED: Unsupervised representation learning by auto-encoding transformations rather than data. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2547–2555, 2019.
+
+# A EXPERIMENTS ON DIFFERENT ORDERS OF THE ADJACENCY MATRIX
+
+As presented in Sec. 3.2, we perturb the 1-hop neighborhoods via the proposed topology transformations, leading to possibly significant changes in the graph topology. This increases the difficulties of predicting the topology transformations when using one-layer GCN (Kipf & Welling, 2017) by aggregating the 1-hop neighborhood information. Therefore, we employ one Simple Graph Convolution (SGC) layer (Wu et al., 2019) with order $k$ as our encoder $E ( \cdot )$ , where the output feature representations aggregate multi-hop neighborhood information. Formally, the SGC layer is defined as
+
+$$
+\mathbf { H } = E ( \mathbf { X } , \mathbf { A } ) = \left( \mathbf { D } ^ { - { \frac { 1 } { 2 } } } ( \mathbf { A } + \mathbf { I } ) \mathbf { D } ^ { - { \frac { 1 } { 2 } } } \right) ^ { k } \mathbf { X } \mathbf { W } ,
+$$
+
+where $\mathbf { D }$ is the degree matrix of $\mathbf { A } + \mathbf { I }$ , $\mathbf { W } \in \mathbb { R } ^ { C \times F }$ is a learnable parameter matrix, and $k$ is the order of the normalized adjacency matrix.
+
+To study the influence of different orders of the adjacency matrix, we adopt five orders from 1 to 5 to train five models on the node classification task. Fig. 3 presents the node classification accuracy under different orders of the adjacency matrix for TopoTER and DGI respectively. As we can see, the proposed TopoTER achieves best classification performance when $\bar { k } = \{ 4 , 2 , 3 \}$ on the three datasets respectively. When $k = 1$ , our model still achieves reasonable results although it is difficult to predict the topology transformations from 1-hop neighborhood information; when $k > 1$ , our proposed TopoTER outperforms DGI by a large margin on Cora and Pubmed dataset, and achieves comparable results to DGI on Citeseer dataset. This is because DGI adopts feature shuffling to generate negative samples, which is insufficient to learn contrastive feature representations when aggregating multi-hop neighborhood information, while TopoTER takes advantage of multi-hop neighborhood information to predict the topology transformations, leading to improved performance.
+
+![](images/8ddbf8b4e04cab400e9891a928714a2981f607b9d3a138ffb5b36d9e723dac71.jpg)  
+Figure 3: Node classification accuracies under different orders of the adjacency matrix on the Cora, Citeseer, and Pubmed datasets.
+
+# B EXPERIMENTS ON DIFFERENT EDGE PERTURBATION RATES
+
+Further, we evaluate the influence of the edge perturbation rate in Eq. (9) on the node classification task. We choose 11 edge perturbation rates from 0.0 to 1.0 at an interval of 0.1 to train the proposed TopoTER. We use one SGC layer as our encoder $E ( \cdot )$ , where the order of the adjacency matrix is set to 1. As presented in Fig. 4, the blue solid line with error bar shows the classification accuracy of our TopoTER under different edge perturbation rates. We also provide the classification accuracy on feature representations of graphs from a randomly initialized encoder $E ( \cdot )$ , denoted as Random Init., which serves as the lower bound of the performance.
+
+As we can see, the classification performance reaches the best when the graph is perturbed under a reasonable edge perturbation rate, e.g., $r = \{ 0 . 6 , 0 . 5 , 0 . 6 \}$ for the Cora, Citeseer, and Pubmed dataset, respectively. When the edge perturbation rate $r ~ = ~ 0 . 0$ , the unsupervised training task of TopoTER becomes link prediction, which cannot take advantage of the proposed method by predicting the topology transformations; when the edge perturbation rate $r = 1 . 0$ , our TopoTER still achieves reasonable classification results, which shows the stability of our model under high edge perturbation rates. At the same time, we observe that the proposed TopoTER outperforms Random Init. by a large margin, which validates the effectiveness of the proposed unsupervised training strategy.
+
+![](images/cfee187499901abc7aaea98a85b3758d39bf6b7135d31b0e4e98280246dd31f5.jpg)  
+Figure 4: Node classification accuracies under different edge perturbation rates on the Cora, Citeseer, and Pubmed datasets.

parse/train/9az9VKjOx00/9az9VKjOx00_content_list.json

@@ -0,0 +1,1895 @@
+[
+    {
+        "type": "text",
+        "text": "TOPOTER: UNSUPERVISED LEARNING OF TOPOLOGY TRANSFORMATION EQUIVARIANT REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            172,
+            398,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present the Topology Transformation Equivariant Representation (TopoTER) learning, a general paradigm of unsupervised learning of node representations of graph data for the wide applicability to Graph Convolutional Neural Networks (GCNNs). We formalize the TopoTER from an information-theoretic perspective, by maximizing the mutual information between topology transformations and node representations before and after the transformations. We derive that maximizing such mutual information can be relaxed to minimizing the cross entropy between the applied topology transformation and its estimation from node representations. In particular, we seek to sample a subset of node pairs from the original graph and flip the edge connectivity between each pair to transform the graph topology. Then, we self-train a representation encoder to learn node representations by reconstructing the topology transformations from the feature representations of the original and transformed graphs. In experiments, we apply the TopoTER to the downstream node and graph classification tasks, and results show that the TopoTER outperforms the state-of-the-art unsupervised approaches. ",
+        "bbox": [
+            233,
+            268,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            498,
+            336,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graphs provide a natural and efficient representation for non-Euclidean data, such as brain networks, social networks, citation networks, and 3D point clouds. Graph Convolutional Neural Networks (GCNNs) (Bronstein et al., 2017) have been proposed to generalize the CNNs to learn representations from non-Euclidean data, which has made significant advances in various applications such as node classification (Kipf & Welling, 2017; Velickovi ˇ c et al., 2018; Xu et al., 2019a) and graph ´ classification (Xu et al., 2019b). However, most existing GCNNs are trained in a supervised fashion, requiring a large amount of labeled data for network training. This limits the applications of the GCNNs since it is often costly to collect adequately labeled data, especially on large-scale graphs. Hence, this motivates the proposed research to learn graph feature representations in an unsupervised fashion, which enables the discovery of intrinsic graph structures and thus adapts to various downstream tasks. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Auto-Encoders (AEs) and Generative Adversarial Networks (GANs) are two most representative unsupervised learning methods. Based on the AEs and GANs, many approaches have sought to learn transformation equivariant representations (TERs) to further improve the quality of unsupervised representation learning. It assumes that the learned representations equivarying to transformations are able to encode the intrinsic structures of data such that the transformations can be reconstructed from the representations before and after transformations (Qi et al., 2019b). Learning TERs traces back to Hinton’s seminal work on learning transformation capsules (Hinton et al., 2011), and embodies a variety of methods developed for Euclidean data (Kivinen & Williams, 2011; Sohn & Lee, 2012; Schmidt & Roth, 2012; Skibbe, 2013; Lenc & Vedaldi, 2015; Gens & Domingos, 2014; Dieleman et al., 2015; 2016; Zhang et al., 2019; Qi et al., 2019a). Further, Gao et al. (2020) extend transformation equivariant representation learning to non-Euclidean domain, which formalizes Graph Transformation Equivariant Representation (GraphTER) learning by auto-encoding nodewise transformations in an unsupervised fashion. Nevertheless, only transformations on node features are explored, while the underlying graph may vary implicitly. The graph topology has not been fully explored yet, which however is crucial in unsupervised graph representation learning. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To this end, we propose the Topology Transformation Equivariant Representation (TopoTER) learning to infer unsupervised graph feature representations by estimating topology transformations. Instead of transforming node features as in the GraphTER, the proposed TopoTER studies the transformation equivariant representation learning by transforming the graph topology, i.e., adding or removing edges to perturb the graph structure. Then the same input signals are attached to the resultant graph topologies, resulting in different graph representations. This provides an insight into how the same input signals associated with different graph topologies would lead to equivariant representations enabling the fusion of node feature and graph topology in GCNNs. Formally, we propose the TopoTER from an information-theoretic perspective, aiming to maximize the mutual information between topology transformations and feature representations with respect to the original and transformed graphs. We derive that maximizing such mutual information can be relaxed to the cross entropy minimization between the applied topology transformations and the estimation from the learned representations of graph data under the topological transformations. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Specifically, given an input graph and its associated node features, we first sample a subset of node pairs from the graph and flip the edge connectivity between each pair at a perturbation rate, leading to a transformed graph with attached node features. Then, we design a graph-convolutional auto-encoder architecture, where the encoder learns the node-wise representations over the original and transformed graphs respectively, and the decoder predicts the topology transformations of edge connectivity from both representations by minimizing the cross entropy between the applied and estimated transformations. Experimental results demonstrate that the proposed TopoTER model outperforms the state-of-the-art unsupervised models, and even achieves comparable results to the (semi-)supervised approaches in node classification and graph classification tasks at times. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are summarized as follows. ",
+        "bbox": [
+            174,
+            396,
+            509,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose the Topology Transformation Equivariant Representation (TopoTER) learning to infer expressive node feature representations in an unsupervised fashion, which can characterize the intrinsic structures of graphs and the associated features by exploring the graph transformations of connectivity topology. We formulate the TopoTER from an information-theoretic perspective, by maximizing the mutual information between feature representations and topology transformations, which can be relaxed to the cross entropy minimization between the applied transformations and the prediction in an end-to-end graph-convolutional auto-encoder architecture.   \n• Experiments demonstrate that the proposed TopoTER model outperforms the state-of-the-art unsupervised methods in both node classification and graph classification. ",
+        "bbox": [
+            176,
+            411,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            344,
+            578
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Auto-Encoders. Graph Auto-Encoders (GAEs) are the most representative unsupervised methods. GAEs encode graph data into feature space via an encoder and reconstruct the input graph data from the encoded feature representations via a decoder. GAEs are often used to learn network embeddings and graph generative distributions (Wu et al., 2020). For network embedding learning, GAEs learn the feature representations of each node by reconstructing graph structural information, such as the graph adjacency matrix (Kipf & Welling, 2016) and the positive pointwise mutual information (PPMI) matrix (Cao et al., 2016; Wang et al., 2016). For graph generation, some methods generate nodes and edges of a graph alternately (You et al., 2018), while other methods output an entire graph (Simonovsky & Komodakis, 2018; Ma et al., 2018; De Cao & Kipf, 2018). ",
+        "bbox": [
+            174,
+            583,
+            825,
+            708
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Contrastive Learning. An important paradigm called contrastive learning aims to train an encoder to be contrastive between the representations of positive samples and negative samples. Recent contrastive learning frameworks can be divided into two categories (Liu et al., 2020): context-instance contrast and context-context contrast. Context-instance contrast focuses on modeling the relationships between the local feature of a sample and its global context representation. Deep InfoMax (DIM) (Hjelm et al., 2018) first proposes to maximize the mutual information between a local patch and its global context through a contrastive learning task. Deep Graph InfoMax (DGI) (Velickovic et al., 2019) proposes to learn node-level feature representation by extending DIM to graph-structured data, while InfoGraph (Sun et al., 2020a) aims to use mutual information maximization for unsupervised representation learning on entire graphs. Peng et al. (2020) propose a Graphical Mutual Information (GMI) approach to maximize the mutual information of both features and edges between inputs and outputs. In contrast to context-instance methods, contextcontext contrast studies the relationships between the global representations of different samples. M3S (Sun et al., 2020b) adopts a self-supervised pre-training paradigm as in DeepCluster (Caron et al., 2018) for better semi-supervised prediction in GCNNs. Graph Contrastive Coding (GCC) ",
+        "bbox": [
+            174,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/cbc8db40326b530c55230ef423a1f620241001c32f6e5f21d94a80fd4281a98d.jpg",
+        "image_caption": [
+            "Figure 1: An example of graphs before and after topology transformations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            98,
+            807,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(Qiu et al., 2020) designs the pre-training task as subgraph instance discrimination in and across networks to empower graph neural networks to learn the intrinsic structural representations. ",
+        "bbox": [
+            173,
+            279,
+            821,
+            308
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformation Equivariant Representation Learning. Many approaches have sought to learn transformation equivariant representations. Learning transformation equivariant representations has been advocated in Hinton’s seminal work on learning transformation capsules. Following this, a variety of approaches have been proposed to learn transformation equivariant representations (Gens & Domingos, 2014; Dieleman et al., 2015; 2016; Cohen & Welling, 2016; Lenssen et al., 2018). To generalize to generic transformations, Zhang et al. (2019) propose to learn unsupervised feature representations via Auto-Encoding Transformations (AET) by estimating transformations from the learned feature representations of both the original and transformed images, while Qi et al. (2019a) extend AET from an information-theoretic perspective by maximizing the lower bound of mutual information between transformations and representations. Wang et al. (2020) extend the AET to Generative Adversarial Networks (GANs) for unsupervised image synthesis and representation learning. Gao et al. (2020) introduce the GraphTER model that extends AET to graph-structured data, which is formalized by auto-encoding node-wise transformations in an unsupervised manner. de Haan et al. (2020) propose Gauge Equivariant Mesh CNNs which generalize GCNNs to apply anisotropic gauge equivariant kernels. Fuchs et al. (2020) introduce a self-attention mechanism specifically for 3D point cloud data, which adheres to equivariance constraints, improving robustness to nuisance transformations. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            282,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            313,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider an undirected graph $\\mathcal { G } = \\{ \\mathcal { V } , \\mathcal { E } , \\mathbf { A } \\}$ composed of a node set $\\nu$ of cardinality $| \\nu | = N$ , an edge set $\\mathcal { E }$ connecting nodes of cardinality $| { \\mathcal { E } } | = M$ . $\\mathbf { A }$ is a real symmetric $N \\times N$ matrix that encodes the graph structure, where $a _ { i , j } = 1$ if there exists an edge $( i , j )$ between nodes $i$ and $j$ , and $a _ { i , j } = 0$ otherwise. Graph signal refers to data that reside on the nodes of a graph $\\mathcal { G }$ , denoted by $\\mathbf { X } \\in \\mathbb { R } ^ { N \\times C }$ with the $i$ -th row representing the $C$ -dimensional graph signal on the $i$ -th node of $\\nu$ . ",
+        "bbox": [
+            173,
+            598,
+            825,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 TOPOLOGY TRANSFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            684,
+            429,
+            698
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the topology transformation $\\mathbf { t }$ as adding or removing edges from the original edge set $\\mathcal { E }$ in graph $\\mathcal { G }$ . This can be done by sampling, i.i.d., a switch parameter $\\sigma _ { i , j }$ as in (Velickovic et al., 2019), which determines whether to modify edge $( i , j )$ in the adjacency matrix. Assuming a Bernoulli distribution $B ( p )$ , where $p$ denotes the probability of each edge being modified, we draw a random matrix $\\Sigma = \\{ \\bar { \\sigma _ { i , j } } \\} _ { N \\times N }$ from $B ( p )$ , i.e., $\\Sigma \\sim B ( p )$ . We then acquire the perturbed adjacency matrix as ",
+        "bbox": [
+            173,
+            704,
+            825,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bff49dc4052586d2282dcbfcece3097e484771c86359439bf3fc3ffe5a0d78d.jpg",
+        "text": "$$\n\\widetilde { \\mathbf { A } } = \\mathbf { A } \\oplus \\Sigma ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            784,
+            542,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\oplus$ is the exclusive OR (XOR) operation. This strategy produces a transformed graph through the topology transformation $\\mathbf { t }$ , i.e., $\\overset { \\sim } { \\mathbf { A } } = \\mathbf { t } ( \\mathbf { A } )$ . Here, the edge perturbation probability of $p = 0$ corresponds to a non-transformed adjacency matrix, which is a special case of an identity transformation to A. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The transformed adjacency matrix $\\widetilde { \\bf A }$ can also be written as the sum of the original adjacency matrix A and a topology perturbation matrix $\\Delta \\mathbf { A }$ : ",
+        "bbox": [
+            174,
+            869,
+            823,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b01edf601dcf3a9289d61ce1878e2726a175425873e011f803b7935d7311bfa7.jpg",
+        "text": "$$\n\\begin{array} { r } { \\widetilde { \\bf A } = { \\bf A } + \\Delta { \\bf A } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            905,
+            552,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\Delta \\mathbf { A } = \\{ \\delta a _ { i , j } \\} _ { N \\times N }$ encodes the perturbation of edges, with $\\delta a _ { i , j } \\in \\{ - 1 , 0 , 1 \\}$ . As shown in Fig. 1, when $\\delta a _ { i , j } = 0$ , the edge between node $i$ and node $j$ keeps unchanged (i.e., black solid lines); when $\\delta a _ { i , j } = - 1$ or 1, it means removing (i.e., orange dotted lines) or adding (i.e., blue solid lines) the edge between node $i$ and node $j$ , respectively. ",
+        "bbox": [
+            173,
+            102,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 THE FORMULATION OF TOPOTER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            171,
+            449,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 Given a pair of graph signal and adjacency matrix $( \\mathbf { X } , \\mathbf { A } )$ , and a pair of graph signal and transformed adjacency matrix $( \\mathbf { X } , { \\widetilde { \\mathbf { A } } } )$ by a topology transformation $\\mathbf { t } ( \\cdot )$ , a function $E ( \\cdot )$ is transformation equivariant if it satisfies ",
+        "bbox": [
+            173,
+            193,
+            825,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b0dce72b4daca57905e5cc48c397f919d289cc20246ce1655b00e0ce87bc006.jpg",
+        "text": "$$\nE ( \\mathbf { X } , { \\widetilde { \\mathbf { A } } } ) = E \\left( \\mathbf { X } , \\mathbf { t } ( \\mathbf { A } ) \\right) = \\rho ( \\mathbf { t } ) \\left[ E ( \\mathbf { X } , \\mathbf { A } ) \\right] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            244,
+            648,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho ( \\mathbf t ) [ \\cdot ]$ is a homomorphism of transformation t in the representation space. ",
+        "bbox": [
+            174,
+            270,
+            705,
+            285
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let us denote $\\mathbf { H } = E ( \\mathbf { X } , \\mathbf { A } )$ , and $\\widetilde { \\mathbf { H } } = E ( \\mathbf { X } , \\widetilde { \\mathbf { A } } )$ . We seek to learn an encoder $E : ( { \\bf X } , { \\bf A } ) \\mapsto$ $\\mathbf { H } ; ( \\mathbf { X } , \\widetilde { \\mathbf { A } } ) \\mapsto \\widetilde { \\mathbf { H } }$ that maps both the original and transformed sample to representations $\\{ \\mathbf { H } , \\widetilde { \\mathbf { H } } \\}$ equivariant to the sampled transformation $\\mathbf { t }$ , whose information can thus be inferred from the representations via a decoder $D : ( \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\mapsto \\widehat { \\Delta \\mathbf { A } }$ as much as possible. From an information-theoretic perspective, this requires $( \\mathbf { H } , \\Delta \\mathbf { A } )$ should jointly contain all necessary information about $\\widetilde { \\bf H }$ . ",
+        "bbox": [
+            173,
+            296,
+            825,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then a natural choice to formalize the topology transformation equivariance is the mutual information $I ( \\mathbf { H } , \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } )$ between $( \\mathbf { H } , \\Delta \\mathbf { A } )$ and $\\widetilde { \\bf H }$ . The larger the mutual information is, the more knowledge about $\\Delta \\mathbf { A }$ can be inferred from the representations $\\{ \\mathbf { H } , \\widetilde { \\mathbf { H } } \\}$ . Hence, we propose to maximize the mutual information to learn the topology transformation equivariant representations as follows: ",
+        "bbox": [
+            173,
+            385,
+            825,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9af03e27326d2885ad08b1cce9a358f19adb6dcfb5bc724e1553dcb77a8e910c.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } I ( \\mathbf { H } , \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            455,
+            568,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ denotes the parameters of the auto-encoder network. ",
+        "bbox": [
+            173,
+            484,
+            573,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Nevertheless, it is difficult to compute the mutual information directly. Instead, we derive that maximizing the mutual information can be relaxed to minimizing the cross entropy, as described in the following theorem. ",
+        "bbox": [
+            173,
+            505,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 The maximization of the mutual information $I ( \\mathbf { H } , \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } )$ can be relaxed to the minimization of the cross entropy $H ( p \\parallel q )$ between the probability distributions $p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ and $q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ : ",
+        "bbox": [
+            173,
+            560,
+            825,
+            611
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0a79f4c3a6834ecd72fe53756e6e7cac8b7f2aebe03d5bb8149ca6a4a870cf2.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } ~ H \\left( p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\parallel q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\right) \\triangleq - \\underset { p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) } { \\mathbb { E } } \\log q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            617,
+            750,
+            650
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof By using the chain rule of mutual information, we have ",
+        "bbox": [
+            174,
+            662,
+            594,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b3d75bef2f8d101fcd97203c64c1feb87d6f00559375579da7030f83ce331d7.jpg",
+        "text": "$$\nI ( \\mathbf { H } , \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } ) = I ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } ) + I ( \\mathbf { H } ; \\widetilde { \\mathbf { H } } ) \\ge I ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            683,
+            699,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus the mutual information $I ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } )$ is the lower bound of the mutual information $I ( \\mathbf { H } , \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } )$ that attains its minimum value when $I ( \\mathbf { H } ; \\widetilde { \\mathbf { H } } ) = 0$ . ",
+        "bbox": [
+            173,
+            710,
+            823,
+            744
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we relax the objective to maximizing the lower bound mutual information $I ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } )$ between the transformed representation $\\widetilde { \\bf H }$ and the topology transformation $\\Delta \\mathbf { A }$ : ",
+        "bbox": [
+            171,
+            752,
+            823,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/10376528db74dd81e9ef9e5d7595949f77a91d76fcb4b602ff547da7ccb32d7a.jpg",
+        "text": "$$\nI ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } ) = H ( \\Delta \\mathbf { A } | \\mathbf { H } ) - H ( \\Delta \\mathbf { A } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            790,
+            653,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $H ( \\cdot )$ denotes the conditional entropy. Since $\\Delta \\mathbf { A }$ and $\\mathbf { H }$ are independent, we have $H ( \\Delta \\mathbf { A } | \\mathbf { H } ) = H ( \\Delta \\mathbf { A } )$ . Hence, maximizing $I ( \\Delta \\mathbf { A } ; \\widetilde { \\mathbf { H } } | \\mathbf { H } )$ becomes ",
+        "bbox": [
+            176,
+            815,
+            823,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0d1e734d031a119dc2d65b590aaeca7809f5dfe654792a7ae3c5a3d5a30803ec.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\ H ( \\Delta \\mathbf { A } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            853,
+            570,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to the chain rule of conditional entropy, we have ",
+        "bbox": [
+            174,
+            885,
+            565,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a150e11d4aa26fbfa5e4a77344a33da135218c2e8aa4eedb07aa991456ae3d7d.jpg",
+        "text": "$$\nH ( \\Delta \\mathbf { A } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) = H ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) - H ( \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\leq H ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            905,
+            712,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d71ce9251b65e6c86f27cf303680468a96f1e7c79d30276ae320dce1ce6de06d.jpg",
+        "image_caption": [
+            "Figure 2: The architecture of the proposed TopoTER. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            101,
+            823,
+            234
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where the conditional entropy ${ \\cal H } ( \\Delta { \\bf A } | \\widetilde { \\bf H } , { \\bf H } )$ is upper bounded by the joint entropy $H ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ . Thus, the minimization problem in Eq. (6) becomes ",
+        "bbox": [
+            173,
+            271,
+            823,
+            303
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3429883215ef24124d03542bc6b1b24bbabc60f3fb3997088919abe1db05e75c.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\ H ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            305,
+            571,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We next introduce a conditional probability distribution $q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ to approximate the intractable posterior $\\tilde { q } ( \\Delta \\mathbf { A } | \\tilde { \\mathbf { H } } , \\mathbf { H } )$ with an estimated $\\widehat { \\Delta \\mathbf { A } }$ . According to the definition of the Kullback-Leibler divergence, we have ",
+        "bbox": [
+            173,
+            337,
+            826,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efd6042a5b11a3ace01f3a5527c7c45c0076a3f4cb507780fc8759f8d4979a37.jpg",
+        "text": "$$\nH ( \\Delta \\mathbf { A } , { \\widetilde { \\mathbf { H } } } , \\mathbf { H } ) = H ( p ) = H ( p \\parallel q ) - D _ { \\mathrm { K L } } ( p \\parallel q ) \\leq H ( p \\parallel q ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            388,
+            710,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { \\mathrm { K L } } ( p \\parallel q )$ denotes the Kullback-Leibler divergence of $p$ and $q$ that is non-negative, and $H ( p \\parallel q )$ is the cross entropy between $p$ and $q$ . Thus, Eq. (6) is converted to minimizing the cross entropy as the upper bound: ",
+        "bbox": [
+            174,
+            412,
+            825,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/051f70b53654bac401725eb2b9d94815a6e94dad6ac6f3282772682c7f0d5435.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } ~ H \\left( p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\parallel q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\right) \\triangleq - \\underset { p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) } { \\mathbb { E } } \\log q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            458,
+            750,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hence, we relax the maximization problem in Eq. (4) to the optimization in Eq. (5). ",
+        "bbox": [
+            174,
+            494,
+            720,
+            511
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on Theorem 1, we train the decoder $D$ to learn the distribution $q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ so as to estimate the topology transformation $\\widehat { \\Delta \\mathbf { A } }$ from the encoded $\\{ \\widetilde { \\mathbf { H } } , \\mathbf { H } \\}$ , where the input pairs of original and transformed graph representations $\\{ \\widetilde { \\mathbf { H } } , \\mathbf { H } \\}$ as well as the ground truth target $\\Delta \\mathbf { A }$ can be sampled tractably from the factorization of $p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\triangleq p ( \\Delta \\mathbf { A } ) p ( \\mathbf { H } ) p ( \\widetilde { \\mathbf { H } } | \\Delta \\mathbf { A } , \\mathbf { H } )$ . This allows us to minimize the cross entropy between $p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ and $q ( \\widehat { \\Delta \\mathbf { A } } | \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ as in (5) with the training triplets $( \\widetilde { \\mathbf { H } } , \\mathbf { H } ; \\Delta \\mathbf { A } )$ drawn from the tractable factorization of $p ( \\Delta \\mathbf { A } , \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ . Hence, we formulate the TopoTER as the joint optimization of the representation encoder $E$ and the transformation decoder $D$ . ",
+        "bbox": [
+            173,
+            517,
+            825,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 THE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            657,
+            338,
+            672
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design a graph-convolutional auto-encoder network for the TopoTER learning, as illustrated in Fig. 2. Given a graph signal $\\mathbf { X }$ associated with a graph $\\mathcal { G } = \\{ \\bar { \\nu _ { , } } \\mathcal { E } , \\mathbf { A } \\}$ , the proposed unsupervised learning algorithm for the TopoTER consists of three steps: 1) topology transformation, which samples and perturbs some edges from $\\mathcal { E }$ to acquire a transformed adjacency matrix $\\widetilde { \\bf A }$ ; 2) representation encoding, which extracts the feature representations of graph signals before and after the topology transformation; 3) transformation decoding, which estimates the topology transformation parameters from the learned feature representations. We elaborate on the three steps as follows. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Topology Transformation. We randomly sample a subset of edges from $\\mathcal { E }$ for topology perturbation—adding or removing edges, which not only enables to characterize local graph structures at various scales, but also reduces the number of edge transformation parameters to estimate for computational efficiency. In practice, in each iteration of training, we sample all the node pairs with connected edges $\\mathbf { S } _ { 1 }$ , and randomly sample a subset of disconnected node pairs $\\mathbf { S } _ { 0 }$ , i.e., ",
+        "bbox": [
+            173,
+            785,
+            825,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fde333a6378b81ff90ba0b88dcb42c587a1509cfe53be16456d68a12b8cf1d1.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { S } _ { 0 } = \\left\\{ ( i , j ) \\big | a _ { i , j } = 0 \\right\\} , \\mathbf { S } _ { 1 } = \\left\\{ ( i , j ) \\big | a _ { i , j } = 1 \\right\\} , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            859,
+            658,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $| \\mathbf { S } _ { 0 } | = | \\mathbf { S } _ { 1 } | = M$ . Next, we randomly split $\\mathbf { S } _ { 0 }$ and $\\mathbf { S } _ { 1 }$ into two disjoint sets, respectively, i.e., ",
+        "bbox": [
+            179,
+            882,
+            821,
+            897
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d881a09fe87c93ec07d7271a5738cac108b96394b044da79fa76755891d4836.jpg",
+        "text": "$$\n\\mathbf { S } _ { i } = \\left\\{ \\mathbf { S } _ { i } ^ { ( 1 ) } , \\mathbf { S } _ { i } ^ { ( 2 ) } \\ \\big \\vert \\ \\mathbf { S } _ { i } ^ { ( 1 ) } \\cap \\mathbf { S } _ { i } ^ { ( 2 ) } = \\mathcal { Q } , \\mathbf { S } _ { i } ^ { ( 1 ) } \\cup \\mathbf { S } _ { i } ^ { ( 2 ) } = \\mathbf { S } _ { i } , \\big \\vert \\mathbf { S } _ { i } ^ { ( 1 ) } \\big \\vert = r \\cdot \\big \\vert \\mathbf { S } _ { i } \\big \\vert \\right\\} , i \\in \\{ 0 , 1 \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            901,
+            776,
+            929
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $r$ is the edge perturbation rate. Then, for each node pair $( i , j )$ in $\\mathbf { S } _ { 0 } ^ { ( 1 ) }$ and $\\mathbf { S } _ { 1 } ^ { ( 1 ) }$ , we flip the corresponding entry in the original graph adjacency matrix. That is, if $a _ { i , j } = 0$ , then we set $\\tilde { a } _ { i , j } = 1$ ; otherwise, we set $\\tilde { a } _ { i , j } = 0$ . For each node pair $( i , j )$ in $\\mathbf { S } _ { 0 } ^ { ( 2 ) }$ and $\\mathbf { S } _ { 1 } ^ { ( 2 ) }$ , we keep the original connectivities unchanged, i.e., $\\tilde { a } _ { i , j } = a _ { i , j }$ . ",
+        "bbox": [
+            173,
+            102,
+            825,
+            166
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This leads to the transformed adjacency matrix $\\widetilde { \\bf A }$ , as well as the sampled transformation parameters by accessing $\\Delta \\mathbf { A }$ at position $( i , j )$ from $\\mathbf { S } _ { 0 }$ and $\\mathbf { S } _ { 1 }$ . Also, we can category the sampled topology transformation parameters into four types: ",
+        "bbox": [
+            173,
+            174,
+            826,
+            218
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. add an edge to a disconnected node pair, i.e., $\\{ \\mathbf { t } : a _ { i , j } = 0 \\mapsto \\tilde { a } _ { i , j } = 1 , ( i , j ) \\in \\mathbf { S } _ { 0 } ^ { ( 1 ) } \\} ;$ ;   \n2. delete the edge between a connected node pair, i.e., $\\{ \\mathbf { t } : a _ { i , j } = 1 \\mapsto \\tilde { a } _ { i , j } = 0 , ( i , j ) \\in \\mathbf { S } _ { 1 } ^ { ( 1 ) } \\}$ ;   \n3. keep the disconnection between node pairs in $\\mathbf { S } _ { 0 } ^ { ( 2 ) }$ , i.e., $\\{ \\mathbf { t } : a _ { i , j } = 0 \\mapsto \\tilde { a } _ { i , j } = 0 , ( i , j ) \\in \\mathbf { S } _ { 0 } ^ { ( 2 ) } \\} ;$   \n4. keep the connection between node pairs in $\\mathbf { S } _ { 1 } ^ { ( 2 ) }$ , i.e., $\\{ \\mathbf { t } : a _ { i , j } = 1 \\mapsto \\tilde { a } _ { i , j } = 1 , ( i , j ) \\in \\mathbf { S } _ { 1 } ^ { ( 2 ) } \\}$ . ",
+        "bbox": [
+            173,
+            228,
+            823,
+            314
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, we cast the problem of estimating transformation parameters in $\\Delta \\mathbf { A }$ from $( \\widetilde { \\mathbf { H } } , \\mathbf { H } )$ as the classification problem of the transformation parameter types. The percentage of these four types is $r : r : ( 1 - r ) : ( 1 - r )$ . ",
+        "bbox": [
+            173,
+            324,
+            825,
+            367
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Representation Encoder. We train an encoder $E : ( \\mathbf { X } , \\mathbf { A } ) \\mapsto E ( \\mathbf { X } , \\mathbf { A } )$ to encode the feature representations of each node in the graph. As demonstrated in Fig. 2, we leverage GCNNs with shared weights to extract feature representations of each node in the graph signal. Taking the GCN (Kipf & Welling, 2017) as an example, the graph convolution in the GCN is defined as ",
+        "bbox": [
+            173,
+            373,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3eb3dc60dfb1627d750589fb7ff3b681e88012631b8239f9b759c661a258a31e.jpg",
+        "text": "$$\n\\mathbf { H } = E ( \\mathbf { X } , \\mathbf { A } ) = \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } ( \\mathbf { A } + \\mathbf { I } ) \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } \\mathbf { X } \\mathbf { W } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            433,
+            640,
+            453
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { D }$ is the degree matrix of $\\mathbf { A } + \\mathbf { I }$ , $\\mathbf { W } \\in \\mathbb { R } ^ { C \\times F }$ is a learnable parameter matrix, and $\\mathbf { H } =$ $[ \\mathbf { h } _ { 1 } , . . . , \\mathbf { h } _ { N } ] ^ { \\top } \\in \\mathbb { R } ^ { \\breve { N } \\times F }$ denotes the node-wise feature matrix with $F$ output channels. Similarly, the node feature of the transformed counterpart is as follows with the shared weights $\\mathbf { W }$ . ",
+        "bbox": [
+            174,
+            454,
+            825,
+            497
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15e07a3fd690b6756aab1bd450fd684d9303d83defb0abc46fb87e0c6dfa3238.jpg",
+        "text": "$$\n\\begin{array} { r } { \\widetilde { \\mathbf { H } } = E ( \\mathbf { X } , \\widetilde { \\mathbf { A } } ) = \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } ( \\widetilde { \\mathbf { A } } + \\mathbf { I } ) \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\mathbf { X } \\mathbf { W } \\quad } \\\\ { = \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } ( \\mathbf { A } + \\mathbf { I } ) \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\mathbf { X } \\mathbf { W } + \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\Delta \\mathbf { A } \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\mathbf { X } \\mathbf { W } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            498,
+            717,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We thus acquire the feature representations $\\mathbf { H }$ and $\\widetilde { \\bf H }$ of graph signals before and after topology transformations. ",
+        "bbox": [
+            174,
+            547,
+            823,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Transformation Decoder. Comparing Eq. (10) and Eq. (11), the prominent difference between $\\widetilde { \\bf H }$ and $\\mathbf { H }$ lies in the second term of Eq. (11) featuring $\\Delta \\mathbf { A }$ . This enables us to train a decoder $D : ( \\widetilde { \\mathbf { H } } , \\mathbf { H } ) \\mapsto \\widehat { \\Delta \\mathbf { A } }$ to estimate the topology transformation from the joint representations before and after transformation. We first take the difference between the extracted feature representations before and after transformations along the feature channel, ",
+        "bbox": [
+            173,
+            583,
+            825,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4b7120f110397b8b4b0a8ffd8ca736b0584777c7d718907f8a0a1ed76f0e1fb.jpg",
+        "text": "$$\n\\Delta { \\bf H } = \\widetilde { { \\bf H } } - { \\bf H } = [ \\delta { \\bf h } _ { 1 } , . . . , \\delta { \\bf h } _ { N } ] ^ { \\top } \\in \\mathbb { R } ^ { N \\times F } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            661,
+            648,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thus, we can predict the topology transformation between node $i$ and node $j$ through the node-wise feature difference $\\Delta \\mathbf { H }$ by constructing the edge representation as ",
+        "bbox": [
+            171,
+            684,
+            825,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50d706e6feadf2d41c6a21831ee25d4ae0d1539d1ea89db231c717d46395ffca.jpg",
+        "text": "$$\n\\mathbf { e } _ { i , j } = \\frac { \\exp \\{ - ( \\delta \\mathbf { h } _ { i } - \\delta \\mathbf { h } _ { j } ) \\odot ( \\delta \\mathbf { h } _ { i } - \\delta \\mathbf { h } _ { j } ) \\} } { \\lVert \\exp \\{ - ( \\delta \\mathbf { h } _ { i } - \\delta \\mathbf { h } _ { j } ) \\odot ( \\delta \\mathbf { h } _ { i } - \\delta \\mathbf { h } _ { j } ) \\} \\rVert _ { 1 } } \\in \\mathbb { R } ^ { F } , \\quad \\forall ( i , j ) \\in \\mathbf { S } _ { 0 } \\cup \\mathbf { S } _ { 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            714,
+            750,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ denotes the Hadamard product of two vectors to capture the feature representation, and $\\| \\cdot \\| _ { 1 }$ is the $\\ell _ { 1 }$ -norm of a vector for normalization. The edge representation $\\mathbf { e } _ { i , j }$ of node $i$ and $j$ is then fed into several linear layers for the prediction of the topology transformation, ",
+        "bbox": [
+            174,
+            751,
+            823,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/39fda4aa7c7575010340f05821e136deb9601cd0458a9e4de8a2046ec62621d7.jpg",
+        "text": "$$\n\\widehat { \\mathbf { y } } _ { i , j } = \\mathrm { s o f t m a x } \\left( \\mathrm { l i n e a r } ( \\mathbf { e } _ { i , j } ) \\right) , \\quad \\forall ( i , j ) \\in \\mathbf { S } _ { 0 } \\cup \\mathbf { S } _ { 1 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            796,
+            669,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where softmax $( \\cdot )$ is an activation function. ",
+        "bbox": [
+            176,
+            815,
+            457,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "According to Eq. (5), the entire auto-encoder network is trained by minimizing the cross entropy ",
+        "bbox": [
+            171,
+            837,
+            803,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cce336e7fb98d3a11c8e51af662f3e1d32abe9834e8e3c8506f9b08f2d1f5371.jpg",
+        "text": "$$\n\\mathcal { L } = - \\underset { ( i , j ) \\in { \\bf S } _ { 0 } \\cup { \\bf S } _ { 1 } } { \\mathbb { E } } \\sum _ { f = 0 } ^ { 3 } { \\bf y } _ { i , j } ^ { ( f ) } \\log \\widehat { \\bf y } _ { i , j } ^ { ( f ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            854,
+            617,
+            898
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $f$ denotes the transformation type $( f \\in \\{ 0 , 1 , 2 , 3 \\}$ ), and $\\mathbf { y }$ is the ground-truth binary indicator (0 or 1) for each transformation parameter type. ",
+        "bbox": [
+            171,
+            901,
+            823,
+            931
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/cbcf0b2325d5d5f967be1a58405106323ea30412e098600ed31e86695bde6a04.jpg",
+        "table_caption": [
+            "Table 1: Node classification accuracies (with standard deviation) in percentage on three datasets. X, A, Y denote the input data, adjacency matrix and labels respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>TrainingData</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td colspan=\"5\">Semi-SupervisedMethods</td></tr><tr><td>GCN(Kipf&amp;Welling,2017)</td><td>X,A,Y</td><td>81.5</td><td>70.3</td><td>79.0</td></tr><tr><td>MoNet (Monti et al.,2017)</td><td>X,A,Y</td><td>81.7 ± 0.5</td><td>-</td><td>78.8± 0.3</td></tr><tr><td>GAT(Velickovic et al.,2018)</td><td>X,A,Y</td><td>83.0 ±0.7</td><td>72.5±0.7</td><td>79.0±0.3</td></tr><tr><td>SGC (Wu et al., 2019)</td><td>X,A,Y</td><td>81.0 ±0.0</td><td>71.9 ± 0.1</td><td>78.9 ± 0.0</td></tr><tr><td>GWNN (Xu et al.,2019a)</td><td>X,A,Y</td><td>82.8</td><td>71.7</td><td>79.1</td></tr><tr><td>MixHop (Abu-El-Haija et al., 2019)</td><td>X,A,Y</td><td>81.9 ± 0.4</td><td>71.4 ± 0.8</td><td>80.8±0.6</td></tr><tr><td>DFNet (Wijesinghe&amp; Wang,2019)</td><td>X,A,Y</td><td>85.2 ±0.5</td><td>74.2 ± 0.3</td><td>84.3 ± 0.4</td></tr><tr><td colspan=\"5\">Unsupervised Methods</td></tr><tr><td>RawFeatures(Velickovic et al.,2019)</td><td>X</td><td>47.9±0.4</td><td>49.3±0.2</td><td>69.1±0.3</td></tr><tr><td>DeepWalk (Perozzi et al.,2014)</td><td>A</td><td>67.2</td><td>43.2</td><td>65.3</td></tr><tr><td>DeepWalk + Features (Velickovic et al., 2019)</td><td>X,A</td><td>70.7 ± 0.6</td><td>51.4 ± 0.5</td><td>74.3 ± 0.9</td></tr><tr><td>GAE (Kipf &amp; Welling,2016)</td><td>X,A</td><td>80.9 ± 0.4</td><td>66.7±0.4</td><td>77.1 ±0.7</td></tr><tr><td>VGAE (Kipf &amp; Welling,2016)</td><td>X,A</td><td>80.0±0.2</td><td>64.1 ± 0.2</td><td>76.9 ± 0.1</td></tr><tr><td>DGI (Velickovic et al.,2019)</td><td>X,A</td><td>81.1 ± 0.1</td><td>71.4 ± 0.2</td><td>77.0± 0.2</td></tr><tr><td>GMI (Peng et al.,2020)</td><td>X,A</td><td>82.2 ±0.2</td><td>71.4± 0.5</td><td>78.5 ±0.1</td></tr><tr><td>TopoTER</td><td>X,A</td><td>83.7 ± 0.3</td><td>71.7 ± 0.5</td><td>79.1 ± 0.1</td></tr></table>",
+        "bbox": [
+            215,
+            140,
+            781,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/53bb015def137e7833fadc4fc8dcafef51e50f1da1fb2cce3284bf9d987e8d3f.jpg",
+        "table_caption": [
+            "Table 2: Model size comparison of DGI, GMI, and the proposed TopoTER "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>DGI</td><td>GMI</td><td>TopoTER</td></tr><tr><td>No.of Parameters</td><td>996,354</td><td>1,730,052</td><td>736,260</td></tr></table>",
+        "bbox": [
+            328,
+            358,
+            665,
+            382
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            400,
+            326,
+            415
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 NODE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            379,
+            439
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We adopt three citation networks to evaluate our model: Cora, Citeseer, and Pubmed (Sen et al., 2008), where nodes correspond to documents and edges represent citations. We follow the standard train/test split in (Kipf & Welling, 2017) to conduct the experiments. ",
+        "bbox": [
+            174,
+            452,
+            821,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. In this task, the auto-encoder network is trained via Adam optimizer, and the learning rate is set to $1 0 ^ { - 4 }$ . We use the same early stopping strategy as DGI (Velickovic et al., 2019) on the observed training loss, with a patience of 20 epochs. We deploy one Simple Graph Convolution (SGC) layer (Wu et al., 2019) as our encoder, and the order of the adjacency matrix is set to 2, while we will study the order of the adjacency matrix in Appendix A. The LeakyReLU activation function with a negative slope of 0.1 is employed after the SGC layer. Similar to DGI (Velickovic et al., 2019), we set the output channel $F = 5 1 2$ for Cora and Citeseer dataset, and 256 for Pubmed dataset due to memory limitations. After the encoder, we use one linear layer to classify the transformation types. We set the edge perturbation rate in Eq. (9) as $r = \\{ 0 . 7 , 0 . 4 , 0 . 7 \\}$ for Cora, Citeseer, and Pubmed, respectively. The analysis of the edge perturbation rate will be presented in Appendix B. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "During the training procedure of the classifier, the SGC layer in the encoder is used to extract graph feature representations with the weights frozen. After the SGC layer, we apply one linear layer to map the features to the classification scores. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            703
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental Results. We compare the proposed method with five unsupervised methods, including one node embedding method DeepWalk, two graph auto-encoders GAE and VGAE (Kipf & Welling, 2016), and two contrastive learning methods DGI (Velickovic et al., 2019) and GMI (Peng et al., 2020). Additionally, we report the results of Raw Features and DeepWalk+Features (Perozzi et al., 2014) under the same settings. For fair comparison, the results of all other unsupervised methods are reproduced by using the same encoder architecture of the TopoTER except DeepWalk and Raw Features. We report the mean classification accuracy (with standard deviation) on the test nodes for all methods after 50 runs of training. As reported in Tab. 1, the TopoTER outperforms all other competing unsupervised methods on three datasets. Further, the proposed unsupervised method also achieves comparable performance with semi-supervised results. This significantly closes the gap between unsupervised approaches and the semi-supervised methods. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we compare the proposed TopoTER with two contrastive learning methods DGI and GMI in terms of the model complexity, as reported in Tab. 2. The number of parameters in our model is less than that of DGI and even less than half of that of GMI, which further shows the TopoTER model is lightweight. ",
+        "bbox": [
+            174,
+            869,
+            823,
+            926
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/03aaf6d9c65376ad0590fcd8166eb53b1f0f9930b24a889b997a89a64e87db88.jpg",
+        "table_caption": [
+            "Table 3: Graph classification accuracies (with standard deviation) in percentage on 6 datasets. $^ { 6 6 } > 1$ Day” represents that the computation exceeds 24 hours. “OOM” is out of memory error. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset (No.Graphs) (No. Classes)</td><td>MUTAG 188 2</td><td>PTC-MR 344 2</td><td>RDT-B 2000 2</td><td>RDT-M5K 4999 5</td><td>IMDB-B 1000 2</td><td>IMDB-M 1500 3</td></tr><tr><td colspan=\"7\">GraphKernelMethods</td></tr><tr><td>RW</td><td>83.72 ±1.50</td><td>57.85 ±1.30</td><td>OOM</td><td>OOM</td><td>50.68±0.26</td><td>34.65 ±0.19</td></tr><tr><td>SP</td><td>85.22 ± 2.43</td><td>58.24 ± 2.44</td><td>64.11 ± 0.14</td><td>39.55 ±0.22</td><td>55.60±0.22</td><td>37.99 ± 0.30</td></tr><tr><td>GK</td><td>81.66 ± 2.11</td><td>57.26 ± 1.41</td><td>77.34 ± 0.18</td><td>41.01 ± 0.17</td><td>65.87 ±0.98</td><td>43.89 ±0.38</td></tr><tr><td>WL</td><td>80.72 ±3.00</td><td>57.97 ± 0.49</td><td>68.82 ±0.41</td><td>46.06 ±0.21</td><td>72.30 ± 3.44</td><td>46.95 ± 0.46</td></tr><tr><td>DGK</td><td>87.44 ±2.72</td><td>60.08 ±2.55</td><td>78.04±0.39</td><td>41.27 ± 0.18</td><td>66.96 ±0.56</td><td>44.55± 0.52</td></tr><tr><td>MLG</td><td>87.94 ± 1.61</td><td>63.26 ± 1.48</td><td>&gt;1Day</td><td>&gt;1Day</td><td>66.55 ± 0.25</td><td>41.17 ± 0.03</td></tr><tr><td colspan=\"7\">SupervisedMethods</td></tr><tr><td>GCN</td><td>85.6±5.8</td><td>64.2± 4.3</td><td>50.0±0.0</td><td>20.0±0.0</td><td>74.0±3.0</td><td>51.9±3.8</td></tr><tr><td>GraphSAGE</td><td>85.1± 7.6</td><td>63.9 ±7.7</td><td></td><td>=</td><td>72.3 ± 5.3</td><td>50.9 ± 2.2</td></tr><tr><td>GIN-0</td><td>89.4±5.6</td><td>64.6±7.0</td><td>92.4±2.5</td><td>57.5 ± 1.5</td><td>75.1 ± 5.1</td><td>52.3±2.8</td></tr><tr><td>GIN-e</td><td>89.0±6.0</td><td>63.7±8.2</td><td>92.2±2.3</td><td>57.0 ±1.7</td><td>74.3 ± 5.1</td><td>52.1±3.6</td></tr><tr><td colspan=\"7\">Unsupervised Methods</td></tr><tr><td>node2vec</td><td>72.63±10.20</td><td>58.58±8.00</td><td></td><td>=</td><td>=</td><td></td></tr><tr><td>sub2vec</td><td>61.05 ± 15.80 83.15 ±9.25</td><td>59.99 ±6.38</td><td>71.48 ± 0.41 75.78 ±1.03</td><td>36.68 ±0.42 47.86 ±0.26</td><td>55.26 ± 1.54</td><td>36.67±0.83</td></tr><tr><td>graph2vec</td><td>89.01 ± 1.13</td><td>60.17 ±6.86 61.65 ±1.43</td><td>82.50 ±1.42</td><td>53.46 ± 1.03</td><td>71.10 ±0.54 73.03 ± 0.87</td><td>50.44 ± 0.87</td></tr><tr><td>InfoGraph TopoTER</td><td>89.25 ±0.81</td><td>64.59 ±1.26</td><td>84.93 ±0.18</td><td>55.52±0.20</td><td>73.46 ±0.38</td><td>49.69 ± 0.53</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>49.68 ±0.31</td></tr></table>",
+        "bbox": [
+            173,
+            140,
+            833,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 GRAPH CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            387,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We conduct graph classification experiments on six well-known graph benchmark datasets (Yanardag & Vishwanathan, 2015): MUTAG, PTC, REDDIT-BINARY, REDDIT-MULTI5K, IMDB-BINARY, and IMDB-MULTI. ",
+        "bbox": [
+            174,
+            388,
+            823,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details. In this task, the entire network is trained via Adam optimizer with a batch size of 64, and the learning rate is set to $1 0 ^ { - 3 }$ . For the encoder architecture, we follow the same encoder settings in the released code of InfoGraph (Sun et al., 2020a), i.e., three Graph Isomorphism Network (GIN) layers (Xu et al., 2019b) with batch normalization. We also use one linear layer to classify the transformation types. We set the sampling rate $r = 0 . 5$ for all datasets. ",
+        "bbox": [
+            174,
+            436,
+            823,
+            506
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "During the evaluation stage, the entire encoder will be frozen to extract node-level feature representations, which will go through a global add pooling layer to acquire global features. We then use LIBSVM to classify these global features to classification scores. We adopt the same procedure of previous works (Sun et al., 2020a) to make a fair comparison and use 10-fold cross validation accuracy to report the classification performance, and the experiments are repeated five times. ",
+        "bbox": [
+            174,
+            513,
+            823,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental Results. We take six graph kernel approaches for comparison: Random Walk (RW) (Gartner et al., 2003), Shortest Path Kernel (SP) (Borgwardt & Kriegel, 2005), Graphlet Kernel ¨ (GK) (Shervashidze et al., 2009), Weisfeiler-Lehman Sub-tree Kernel (WL) (Shervashidze et al., 2011), Deep Graph Kernels (DGK) (Yanardag & Vishwanathan, 2015), and Multi-Scale Laplacian Kernel (MLG) (Kondor & Pan, 2016). Aside from graph kernel methods, we also compare with three unsupervised graph-level representation learning methods: node2vec (Grover & Leskovec, 2016), sub2vec (Adhikari et al., 2018), and graph2vec (Narayanan et al., 2017), and one contrastive learning method: InfoGraph (Sun et al., 2020a). The experimental results of unsupervised graph classification are preseted in Tab. 3. The proposed TopoTER outperforms all unsupervised baseline methods on the first five datasets, and achieves comparable results on the other dataset. Also, the proposed approach reaches the performance of supervised methods at times, thus validating the effectiveness of the TopoTER model. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            768,
+            318,
+            784
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We propose Topology Transformation Equivariant Representation (TopoTER) for learning unsupervised representations on graph data. By maximizing the mutual information between topology transformations and feature representations before and after transformations, the TopoTER enforces the encoder to learn intrinsic graph feature representations that contain sufficient information about structures under applied topology transformations. We apply the TopoTER model to node classification and graph classification tasks, and results demonstrate that the TopoTER outperforms stateof-the-art unsupervised approaches and reaches the performance of supervised methods at times. ",
+        "bbox": [
+            174,
+            790,
+            823,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sami Abu-El-Haija, Bryan Perozzi, Amol Kapoor, Nazanin Alipourfard, Kristina Lerman, Hrayr Harutyunyan, Greg Ver Steeg, and Aram Galstyan. Mixhop: Higher-order graph convolutional architectures via sparsified neighborhood mixing. In Proceedings of the 36th International Conference on Machine Learning (ICML), pp. 21–29, 2019. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            183
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bijaya Adhikari, Yao Zhang, Naren Ramakrishnan, and B Aditya Prakash. Sub2vec: Feature learning for subgraphs. In Pacific-Asia Conference on Knowledge Discovery and Data Mining, pp. 170–182. Springer, 2018. ",
+        "bbox": [
+            174,
+            191,
+            823,
+            234
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karsten M Borgwardt and Hans-Peter Kriegel. Shortest-path kernels on graphs. In IEEE International Conference on Data Mining (ICDM), pp. 8–pp. IEEE, 2005. ",
+        "bbox": [
+            171,
+            244,
+            820,
+            273
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael M Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017. ",
+        "bbox": [
+            173,
+            282,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shaosheng Cao, Wei Lu, and Qiongkai Xu. Deep neural networks for learning graph representations. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), volume 16, pp. 1145– 1152, 2016. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 132–149, 2018. ",
+        "bbox": [
+            173,
+            387,
+            825,
+            431
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen and Max Welling. Group equivariant convolutional networks. In Proceedings of the 33rd International Conference on Machine Learning (ICML), pp. 2990–2999, 2016. ",
+        "bbox": [
+            169,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicola De Cao and Thomas Kipf. MolGAN: An implicit generative model for small molecular graphs. In International Conference on Machine Learning Workshop on Theoretical Foundations and Applications of Deep Generative Models, 2018. ",
+        "bbox": [
+            176,
+            478,
+            823,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pim de Haan, Maurice Weiler, Taco Cohen, and Max Welling. Gauge equivariant mesh cnns: Anisotropic convolutions on geometric graphs. arXiv preprint arXiv:2003.05425, 2020. ",
+        "bbox": [
+            176,
+            531,
+            821,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sander Dieleman, Kyle W Willett, and Joni Dambre. Rotation-invariant convolutional neural networks for galaxy morphology prediction. Monthly Notices of the Royal Astronomical Society, 450 (2):1441–1459, 2015. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sander Dieleman, Jeffrey De Fauw, and Koray Kavukcuoglu. Exploiting cyclic symmetry in convolutional neural networks. In International Conference on Machine Learning (ICML), pp. 1889– 1898, 2016. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fabian B Fuchs, Daniel E Worrall, Volker Fischer, and Max Welling. Se (3)-transformers: 3d rototranslation equivariant attention networks. arXiv preprint arXiv:2006.10503, 2020. ",
+        "bbox": [
+            171,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xiang Gao, Wei Hu, and Guo-Jun Qi. GraphTER: Unsupervised learning of graph transformation equivariant representations via auto-encoding node-wise transformations. In Proceedings of IEEE/CVF Conferences on Computer Vision and Pattern Recognition (CVPR), 2020. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas Gartner, Peter Flach, and Stefan Wrobel. On graph kernels: Hardness results and efficient ¨ alternatives. In Learning Theory and Kernel Machines, pp. 129–143. Springer, 2003. ",
+        "bbox": [
+            169,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robert Gens and Pedro M Domingos. Deep symmetry networks. In Advances in Neural Information Processing Systems (NIPS), pp. 2537–2545, 2014. ",
+        "bbox": [
+            171,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 855–864, 2016. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Alex Krizhevsky, and Sida D Wang. Transforming auto-encoders. In International Conference on Artificial Neural Networks (ICANN), pp. 44–51. Springer, 2011. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Variational graph auto-encoders. In Proceedings of the NIPS Workshop on Bayesian Deep Learning, 2016. ",
+        "bbox": [
+            176,
+            156,
+            821,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            195,
+            820,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jyri J Kivinen and Christopher KI Williams. Transformation equivariant boltzmann machines. In International Conference on Artificial Neural Networks (ICANN), pp. 1–9. Springer, 2011. ",
+        "bbox": [
+            173,
+            234,
+            821,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Risi Kondor and Horace Pan. The multiscale laplacian graph kernel. In Advances in Neural Information Processing Systems (NIPS), pp. 2990–2998, 2016. ",
+        "bbox": [
+            173,
+            273,
+            823,
+            303
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karel Lenc and Andrea Vedaldi. Understanding image representations by measuring their equivariance and equivalence. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 991–999, 2015. ",
+        "bbox": [
+            176,
+            313,
+            823,
+            356
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Eric Lenssen, Matthias Fey, and Pascal Libuschewski. Group equivariant capsule networks. In Advances in Neural Information Processing Systems (NIPS), pp. 8844–8853, 2018. ",
+        "bbox": [
+            171,
+            364,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiao Liu, Fanjin Zhang, Zhenyu Hou, Zhaoyu Wang, Li Mian, Jing Zhang, and Jie Tang. Selfsupervised learning: Generative or contrastive. arXiv, pp. arXiv–2006, 2020. ",
+        "bbox": [
+            171,
+            404,
+            823,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tengfei Ma, Jie Chen, and Cao Xiao. Constrained generation of semantically valid graphs via regularizing variational autoencoders. In Advances in Neural Information Processing Systems (NIPS), pp. 7113–7124, 2018. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5115–5124, 2017. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Annamalai Narayanan, Mahinthan Chandramohan, Rajasekar Venkatesan, Lihui Chen, Yang Liu, and Shantanu Jaiswal. graph2vec: Learning distributed representations of graphs. In Proceedings of the 13th International Workshop on Mining and Learning with Graphs (MLG), 2017. ",
+        "bbox": [
+            173,
+            563,
+            823,
+            607
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhen Peng, Wenbing Huang, Minnan Luo, Qinghua Zheng, Yu Rong, Tingyang Xu, and Junzhou Huang. Graph representation learning via graphical mutual information maximization. In Proceedings of The Web Conference, pp. 259–270, 2020. ",
+        "bbox": [
+            174,
+            616,
+            823,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 701–710, 2014. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            712
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guo-Jun Qi, Liheng Zhang, Chang Wen Chen, and Qi Tian. AVT: Unsupervised learning of transformation equivariant representations by autoencoding variational transformations. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019a. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guo-Jun Qi, Liheng Zhang, and Xiao Wang. Learning generalized transformation equivariant representations via autoencoding transformations. arXiv preprint arXiv:1906.08628, 2019b. ",
+        "bbox": [
+            173,
+            775,
+            823,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiezhong Qiu, Qibin Chen, Yuxiao Dong, Jing Zhang, Hongxia Yang, Ming Ding, Kuansan Wang, and Jie Tang. Gcc: Graph contrastive coding for graph neural network pre-training. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 1150–1160, 2020. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uwe Schmidt and Stefan Roth. Learning rotation-aware features: From invariant priors to equivariant descriptors. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2050–2057. IEEE, 2012. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008. ",
+        "bbox": [
+            171,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nino Shervashidze, SVN Vishwanathan, Tobias Petri, Kurt Mehlhorn, and Karsten Borgwardt. Efficient graphlet kernels for large graph comparison. In Artificial Intelligence and Statistics, pp. 488–495, 2009. ",
+        "bbox": [
+            174,
+            140,
+            821,
+            183
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nino Shervashidze, Pascal Schweitzer, Erik Jan Van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(9), 2011. ",
+        "bbox": [
+            171,
+            190,
+            821,
+            220
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Simonovsky and Nikos Komodakis. Graphvae: Towards generation of small graphs using variational autoencoders. In International Conference on Artificial Neural Networks (ICANN), pp. 412–422. Springer, 2018. ",
+        "bbox": [
+            174,
+            227,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Henrik Skibbe. Spherical Tensor Algebra for Biomedical Image Analysis. PhD thesis, Verlag nicht ermittelbar, 2013. ",
+        "bbox": [
+            169,
+            277,
+            825,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kihyuk Sohn and Honglak Lee. Learning invariant representations with local transformations. In International Conference on Machine Learning (ICML), pp. 1339–1346, 2012. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            344
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semisupervised graph-level representation learning via mutual information maximization. In International Conference on Learning Representations (ICLR), 2020a. ",
+        "bbox": [
+            174,
+            352,
+            821,
+            395
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ke Sun, Zhouchen Lin, and Zhanxing Zhu. Multi-stage self-supervised learning for graph convolutional networks on graphs with few labeled nodes. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), pp. 5892–5899, 2020b. ",
+        "bbox": [
+            174,
+            401,
+            821,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            453,
+            825,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovic, William Fedus, William L Hamilton, Pietro Lio, Yoshua Bengio, and R Devon \\` Hjelm. Deep graph infomax. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            503,
+            823,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daixin Wang, Peng Cui, and Wenwu Zhu. Structural deep network embedding. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1225–1234, 2016. ",
+        "bbox": [
+            173,
+            554,
+            825,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiayu Wang, Wengang Zhou, Guo-Jun Qi, Zhongqian Fu, Qi Tian, and Houqiang Li. Transformation gan for unsupervised image synthesis and representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 472–481, 2020. ",
+        "bbox": [
+            174,
+            604,
+            823,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "WOK Asiri Suranga Wijesinghe and Qing Wang. Dfnets: Spectral cnns for graphs with feedbacklooped filters. In Advances in Neural Information Processing Systems (NIPS), pp. 6009–6020, 2019. ",
+        "bbox": [
+            176,
+            655,
+            823,
+            698
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. In Proceedings of the 36th International Conference on Machine Learning (ICML), pp. 6861–6871, 2019. ",
+        "bbox": [
+            176,
+            705,
+            825,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2020. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            800
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bingbing Xu, Huawei Shen, Qi Cao, Yunqi Qiu, and Xueqi Cheng. Graph wavelet neural network. In International Conference on Learning Representations (ICLR), 2019a. ",
+        "bbox": [
+            173,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations (ICLR), 2019b. ",
+        "bbox": [
+            174,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1365–1374, 2015. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiaxuan You, Rex Ying, Xiang Ren, William L Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. In Proceedings of the 35th International Conference on Machine Learning (ICML), pp. 5694–5703, 2018. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Liheng Zhang, Guo-Jun Qi, Liqiang Wang, and Jiebo Luo. AET vs. AED: Unsupervised representation learning by auto-encoding transformations rather than data. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 2547–2555, 2019. ",
+        "bbox": [
+            179,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTS ON DIFFERENT ORDERS OF THE ADJACENCY MATRIX ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            101,
+            789,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As presented in Sec. 3.2, we perturb the 1-hop neighborhoods via the proposed topology transformations, leading to possibly significant changes in the graph topology. This increases the difficulties of predicting the topology transformations when using one-layer GCN (Kipf & Welling, 2017) by aggregating the 1-hop neighborhood information. Therefore, we employ one Simple Graph Convolution (SGC) layer (Wu et al., 2019) with order $k$ as our encoder $E ( \\cdot )$ , where the output feature representations aggregate multi-hop neighborhood information. Formally, the SGC layer is defined as ",
+        "bbox": [
+            173,
+            132,
+            825,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/14e94d2a58e96524e73ec255c9d4069e57f825170487b2a0b692292126bc2f64.jpg",
+        "text": "$$\n\\mathbf { H } = E ( \\mathbf { X } , \\mathbf { A } ) = \\left( \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } ( \\mathbf { A } + \\mathbf { I } ) \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } \\right) ^ { k } \\mathbf { X } \\mathbf { W } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            227,
+            655,
+            257
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { D }$ is the degree matrix of $\\mathbf { A } + \\mathbf { I }$ , $\\mathbf { W } \\in \\mathbb { R } ^ { C \\times F }$ is a learnable parameter matrix, and $k$ is the order of the normalized adjacency matrix. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To study the influence of different orders of the adjacency matrix, we adopt five orders from 1 to 5 to train five models on the node classification task. Fig. 3 presents the node classification accuracy under different orders of the adjacency matrix for TopoTER and DGI respectively. As we can see, the proposed TopoTER achieves best classification performance when $\\bar { k } = \\{ 4 , 2 , 3 \\}$ on the three datasets respectively. When $k = 1$ , our model still achieves reasonable results although it is difficult to predict the topology transformations from 1-hop neighborhood information; when $k > 1$ , our proposed TopoTER outperforms DGI by a large margin on Cora and Pubmed dataset, and achieves comparable results to DGI on Citeseer dataset. This is because DGI adopts feature shuffling to generate negative samples, which is insufficient to learn contrastive feature representations when aggregating multi-hop neighborhood information, while TopoTER takes advantage of multi-hop neighborhood information to predict the topology transformations, leading to improved performance. ",
+        "bbox": [
+            173,
+            296,
+            825,
+            464
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ddbf8b4e04cab400e9891a928714a2981f607b9d3a138ffb5b36d9e723dac71.jpg",
+        "image_caption": [
+            "Figure 3: Node classification accuracies under different orders of the adjacency matrix on the Cora, Citeseer, and Pubmed datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            493,
+            776,
+            868
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B EXPERIMENTS ON DIFFERENT EDGE PERTURBATION RATES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            709,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Further, we evaluate the influence of the edge perturbation rate in Eq. (9) on the node classification task. We choose 11 edge perturbation rates from 0.0 to 1.0 at an interval of 0.1 to train the proposed TopoTER. We use one SGC layer as our encoder $E ( \\cdot )$ , where the order of the adjacency matrix is set to 1. As presented in Fig. 4, the blue solid line with error bar shows the classification accuracy of our TopoTER under different edge perturbation rates. We also provide the classification accuracy on feature representations of graphs from a randomly initialized encoder $E ( \\cdot )$ , denoted as Random Init., which serves as the lower bound of the performance. ",
+        "bbox": [
+            173,
+            133,
+            825,
+            231
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As we can see, the classification performance reaches the best when the graph is perturbed under a reasonable edge perturbation rate, e.g., $r = \\{ 0 . 6 , 0 . 5 , 0 . 6 \\}$ for the Cora, Citeseer, and Pubmed dataset, respectively. When the edge perturbation rate $r ~ = ~ 0 . 0$ , the unsupervised training task of TopoTER becomes link prediction, which cannot take advantage of the proposed method by predicting the topology transformations; when the edge perturbation rate $r = 1 . 0$ , our TopoTER still achieves reasonable classification results, which shows the stability of our model under high edge perturbation rates. At the same time, we observe that the proposed TopoTER outperforms Random Init. by a large margin, which validates the effectiveness of the proposed unsupervised training strategy. ",
+        "bbox": [
+            173,
+            238,
+            825,
+            364
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfee187499901abc7aaea98a85b3758d39bf6b7135d31b0e4e98280246dd31f5.jpg",
+        "image_caption": [
+            "Figure 4: Node classification accuracies under different edge perturbation rates on the Cora, Citeseer, and Pubmed datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            395,
+            779,
+            767
+        ],
+        "page_idx": 13
+    }
+]

parse/train/B1mAJI9gl/B1mAJI9gl.md

@@ -0,0 +1,529 @@
+# TOWARDS UNDERSTANDING THE INVERTIBILITY OF CONVOLUTIONAL NEURAL NETWORKS
+
+Anna C. Gilbert1 Yi Zhang1 Kibok Lee1 Yuting Zhang1 Honglak Lee1,2
+
+1University of Michigan, Ann Arbor, MI 48109 2Google Brain, Mountain View, CA 94043 {annacg,yeezhang,kibok,yutingzh,honglak}@umich.edu
+
+# ABSTRACT
+
+Several recent works have empirically observed that Convolutional Neural Nets (CNNs) are (approximately) invertible. To understand this approximate invertibility phenomenon and how to leverage it more effectively, we focus on a theoretical explanation and develop a mathematical model of sparse signal recovery that is consistent with CNNs with random weights. We give an exact connection to a particular model of model-based compressive sensing (and its recovery algorithms) and random-weight CNNs. We show empirically that several learned networks are consistent with our mathematical analysis and then demonstrate that with such a simple theoretical framework, we can obtain reasonable reconstruction results on real images. We also discuss gaps between our model assumptions and the CNN trained for classification in practical scenarios.
+
+# 1 INTRODUCTION
+
+Deep learning has achieved remarkable success in many technological areas (Bengio et al., 2013; Schmidhuber, 2015), including computer vision (Krizhevsky et al., 2012; Szegedy et al., 2015; Simonyan and Zisserman, 2015), automatic speech recognition (Hinton et al., 2012; Hannun et al., 2014), natural language processing (Collobert et al., 2011; Mikolov et al., 2013; Cho et al., 2014), bioinformatics (Chicco et al., 2014), even high energy particle physics (Baldi et al., 2014). In particular, deep Convolutional Neural Networks (CNNs) (LeCun et al., 1989; Krizhevsky et al., 2012; Simonyan and Zisserman, 2015) have been a critical enabling technique for analyzing images and sequential data.
+
+Following the unprecedented success of deep networks, there has been some theoretical work (e.g., Arora et al. (2014; 2015); Paul and Venkatasubramanian (2014)) that suggest several mathematical models for different deep learning architectures. However, theoretical analysis and understanding lag behind the very rapid evolution and empirical success of deep architectures, and more theoretical analysis is needed to better understand the state-of-the-art deep architectures, and possibly to improve them further.
+
+In this paper, we attempt to address the gap between the empirical success and theoretical understanding of the Convolutional Neural Nets, in particular its invertibility (i.e., reconstructing the input from the hidden activations), by analyzing a simplified mathematical model using random weights.1
+
+This property is intriguing because convolutional neural networks are typically trained with discriminative objectives (i.e., unrelated to reconstruction) with a large amount of labels, such as the ImageNet dataset. For example, Dosovitskiy and Brox (2016) used upsampling-deconvolutional architectures to invert the hidden activations of feedforward CNNs to the input domain. In other related work, Zhao et al. (2016) proposed stacked a what-where network via a (deconvolutional) decoder and demonstrate its promise in unsupervised and semi-supervised settings. Bruna et al. (2014) studied signal discovery from generalized pooling operators using image patches on non-convolutional small scale networks and datasets. Zhang et al. (2016) showed that CNNs discriminately trained for image classification (e.g., VGG Net (Simonyan and Zisserman, 2015)) are almost fully invertible using pooling switches. Despite these interesting results, there is no clear theoretical explanation as to why CNNs are invertible yet.
+
+We introduce three new concepts that, coupled with the accepted notion that images have sparse representations, guide our understanding of CNNs:
+
+1. we provide a particular model of sparse linear combinations of the learned filters that are consistent with natural images; also, this model of sparsity is itself consistent with the feedforward network;   
+2. we show that the effective matrices that capture explicitly the convolution of multiple filters exhibit a model-Restricted Isometry Property (model-RIP) (Baraniuk et al., 2010); and   
+3. our model can explain each layer of the feedforward CNN algorithm as one iteration of Iterative Hard Thresholding (IHT) (Blumensath and Davies, 2009) for model-based compressive sensing and, hence, we can reconstruct the input simply and accurately.
+
+In other words, we give a theoretical connection to a particular model of model-based compressive sensing (and its recovery algorithms) and CNNs. We show empirically that large-scale deep convolution networks are consistent with our mathematical analysis. We then demonstrate that with such a simple theoretical framework, we can obtain reasonable reconstruction results on real images, using filters from trained networks. Finally, we observe that it makes a significant difference which filters one uses for encoding and decoding, whether they are trained specifically for reconstruction, or random, or the same for both procedures. This paper explores these properties and elucidate specific empirical aspects that any more sophisticated mathematical model should take into account.2
+
+# 2 PRELIMINARIES
+
+In this section, we set the stage for our mathematical analysis in Section 3. We begin with discussion on the use of random weights in (convolutional) neural networks, and then provide the definitions and models for CNNs. Then, we discuss compressive sensing and sparse signal recovery. We define a particular model of sparsity that we will use throughout our analysis and detail the Iterative Hard Thresholding (IHT) algorithm which is the basis of our reconstruction analysis.
+
+In order to simplify our notation and to make clear our analysis, we focus on a single layer in the analysis instead of multiple layers.3 Also, we assume that all of our input signals are vectors rather than matrices and that any operations we would ordinarily carry out on images (e.g., convolving with a filter bank, dividing into regions over which we pool coefficients), we do on vectors with the appropriate modifications for a simplified structure. While these assumptions ease our exposition, they do not change the nature of our arguments nor their implications for images. Furthermore, we demonstrate the validity of our results in two-dimensional natural images.
+
+# 2.1 EFFECTIVENESS OF GAUSSIAN RANDOM FILTERS
+
+We analyze theoretically CNNs with Gaussian random filters, which have been surprisingly effective in unsupervised and supervised deep learning tasks. Jarrett et al. (2009) showed that random filters in 2-layer CNNs work well for image classification. In addition, Saxe et al. (2011) observed that convolutional layer followed by pooling layer is frequency selective and translation invariant, even with random filters, and these properties lead to good performance for object recognition tasks. On the other hand, Giryes et al. (2016) proved that CNNs with random Gaussian filters have metric preservation property, and they argued that the role of training is to select better hyperplanes discriminating classes by distorting boundary points among classes. According to their observation, random filters are in fact a good choice if training data are initially well-separated. Also, He et al. (2016) empirically showed that random weight CNNs can do image reconstruction well.
+
+To better demonstrate the effectiveness of Gaussian random CNNs, we evaluate their classification performance on CIFAR-10; see Section 4.1 for details. We find that a 3-layer Gaussian random CNN is able to achieve $\sim 7 5 \%$ accuracy on the test set, with only the last classifier layer optimized, (see Table 1 for more details). Even though this number is far from the state-of-the-art results, it is surprisingly good considering the networks are almost untrained. Our theoretical results may provide another new perspective on explaining these phenomena.
+
+$$
+\begin{array} { r l } { W } & { x \quad = \quad h } \\  \underbrace { \frac { l } { \sqrt { 1 + \cdots } } - \cdots - \cdots } _  | \begin{array} { l } { \frac { l } { 1 } } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \cdots - \cdots } \\ { \frac { l } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \cdots - \cdots } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \cdots - \cdots } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \cdots - \cdot } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \cdots - \cdots } \\ { \frac { l } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { - \cdots } - \frac { l } { \sqrt { 1 + \cdots } } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { - \cdots } - \frac { l } { \sqrt { 1 + \cdots } } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { - \cdots } - \frac { l } { \sqrt { 1 + \cdots } } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { - \cdots } - \frac { l } { \sqrt { 1 + \cdots } } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \frac { l } { \sqrt { - \cdots } - \frac { l } { \sqrt { 1 + \cdots } } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \\ { \quad - \frac { l } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } - \frac { 1 } { \sqrt { 1 + \cdots } } } \end{array} ] , M [ \begin{array} { l }  \frac { l }  \end{array} \end{array}
+$$
+
+Figure 1: One-dimensional CNN architecture where $\boldsymbol { W } \in \mathbb { R } ^ { K n \times M D }$ is the matrix instantiation of convolution over $M$ channels with a filter bank consisting of $K$ different filters. Note that a filter bank has $\mathbf { K }$ filters of size $l \times M$ , such that there are $l M K$ parameters in this architecture.
+
+# 2.2 CONVOLUTIONAL NEURAL NETS
+
+We define a single layer of our CNN as follows. We assume that the input signal $_ { \textbf { \em x } }$ consists of $M$ channels, each of length $D$ , and we write $\pmb { x } \in \mathbb { R } ^ { M D }$ . For each of the input channels, $m = 1 , \ldots , M$ let ${ \pmb w } _ { i , m }$ , $i = 1 , \ldots , K$ denote one of $K$ filters, each of length $\ell$ . Let $t$ be the stride length, the number of indices by which we shift each filter. Note that $t$ can be larger than 1.
+
+We assume that the number of shifts, $n = ( D - \ell ) / t + 1$ , is an integer. Let $\pmb { w } _ { i , m } ^ { j }$ be a vector of length $D$ that consists of the $( i , m )$ -th filter shifted by $j t , j = 0 , \ldots , n - 1$ (i.e., $\pmb { w } _ { i , m } ^ { j }$ has at most $\ell$ non-zero entries). We will concatenate over the $M$ channels each of these vectors (as row vectors) to form a large matrix, $W$ , which is the $K n \times M D$ matrix made up of $K$ blocks of the $n$ shifts of each filter in each of $M$ channels. We assume that $K n \ge M D$ . We also assume that the $K n$ row vectors of $W$ span $\mathbb { R } ^ { M D }$ and that we have normalized the rows so that they have unit $\ell _ { 2 }$ norm. We assume that the hidden units of the feed-forward CNN are computed by multiplying an input signal $\pmb { x } \in \mathbb { R } ^ { M D }$ by the matrix $W$ (i.e., convolving, in each channel, by a filter bank of size $K$ , and summing over the channels to obtain $K n$ outputs), applying the ReLU function to the $K n$ outputs, and then selecting the value with maximum absolute value in each of the $K$ blocks; i.e., we perform max pooling over each of the convolved filters and sum over the channels.4 We use $h = W x$ for the hidden activation computed by a single layer CNN without pooling. Figure 1 illustrates the architecture.
+
+# 2.3 COMPRESSIVE SENSING
+
+Let $\Phi$ be a $i \times j$ matrix with $j > i$ . We say that $\Phi$ satisfies the Restricted Isometry Property $\mathrm { R I P } ( k , \delta _ { k } )$ (or, just RIP) if there is a distortion factor $\delta _ { k } > 0$ such that for all $z \in \mathbb { R } ^ { j }$ with exactly $k$ non-zero entries, $( 1 - \delta _ { k } ) \| z \| _ { 2 } ^ { 2 } \leq \| \Phi z \| _ { 2 } ^ { 2 } \leq ( 1 + \delta _ { k } ) \| z \| _ { 2 } ^ { 2 }$ . If $\Phi$ satisfies RIP (for appropriate sparsity level $k$ and sufficiently small $\delta _ { k }$ ) and if $z \in \mathbb { R } ^ { j }$ is $k$ -sparse, then, given the vector $\mathbf { \bar { x } } = \Phi \boldsymbol { z } \in \bar { \mathbb { R } } ^ { i }$ , we can efficiently recover $_ z$ (see Candés (2008) for more details)5. There are many efficient algorithms for doing so, including $\ell _ { 1 }$ sparse coding (e.g., $\ell _ { 2 }$ minimization with $\ell _ { 1 }$ regularization) and greedy, iterative algorithms (such as Iterative Hard Thresholding or IHT).
+
+Model-based compressive sensing. While sparse signals are a natural model for some applications, they are less realistic for CNNs. We consider a vector $z \in \mathbb { R } ^ { K n }$ as the true sparse code for generating the CNN input $_ { \textbf { \em x } }$ with a particular model of sparsity. Rather than permitting $k$ non-zero entries anywhere in the vector $_ z$ , we divide the support of $_ z$ into $K$ contiguous blocks of size $n$ and we stipulate that from each block there is at most one non-zero entry in $_ z$ with a total of $k$ non-zero entries. We call a vector with this sparsity model model- $k$ -sparse and denote the union of all $k$ - sparse subspaces with this structure analysis, we consider linear combinati $\mathcal { M } _ { k }$ . It is clear tof two model- at -s $\mathcal { M } _ { k }$ contains  signals. $n ^ { k } \binom { K } { k }$ subspaces. In ourrecise, suppose that $k$ $z = \alpha _ { 1 } z _ { 1 } + \alpha _ { 2 } z _ { 2 }$ is the linear combination of two elements in $\mathcal { M } _ { k }$ . Then, we say that $_ z$ lies in the linear subspace $\mathcal { M } _ { k } ^ { 2 }$ that consists of all linear combinations of vectors from $\mathcal { M } _ { k }$ .
+
+We say that a matrix $\Phi$ satisfies the model-RIP condition for parameter $k$ if, there is a distortion factor $\delta _ { k } > 0$ such that, for all $z \in \mathcal { M } _ { k }$ ,
+
+$$
+( 1 - \delta _ { k } ) \| z \| _ { 2 } ^ { 2 } \leq \| \Phi z \| _ { 2 } ^ { 2 } \leq ( 1 + \delta _ { k } ) \| z \| _ { 2 } ^ { 2 } .
+$$
+
+See Baraniuk et al. (2010) for the definitions of model sparse and model-RIP, as well as the necessary modifications to account for signal noise and compressible (as opposed to exactly sparse) signals (which we have neglected to consider to keep our analysis simple). Intuitively speaking, a matrix that satisfies the model-RIP is a nearly an orthonormal matrix for a particular set of sparse vectors with a particular sparsity model or pattern.
+
+For our analysis, we also need matrices $\Phi$ that satisfy the model-RIP condition for vectors $z \in \mathcal { M } _ { k } ^ { 2 }$ We denote the distortion factor $\delta _ { 2 k }$ for such matrices. Note that $\delta _ { k } \le \delta _ { 2 k } < 1$ .
+
+# Algorithm 1 Model-based IHT
+
+Input: model-RIP matrix $\Phi$ , measure ments $x = \Phi z$ , structured sparse approximation algorithm $\mathbb { M }$   
+Output: $k$ -sparse approximation $_ z$   
+1: Initialize $z _ { \mathrm { 0 } } = \mathrm { 0 }$ , ${ \pmb d } = { \pmb x }$ , $i = 0$   
+2: while stopping criteria not met do   
+3: $\begin{array} { r l } & { i  i + 1 } \\ & { b  z _ { i - 1 } + \Phi ^ { T } d } \\ & { z _ { i }  \mathbb { M } ( b , k ) } \\ & { d  x - \Phi z _ { i } } \end{array}$   
+4:   
+5:   
+6:   
+7: end while   
+8: return $z  z _ { i }$
+
+Many efficient algorithms have been proposed for sparse coding and compressive sensing (Olshausen et al., 1996; Mallat and Zhang, 1993; Beck and Teboulle, 2009). As with traditional compressive sensing, there are efficient algorithms for recovering model- $k$ -sparse signals from measurements (see Baraniuk et al. (2010)), assuming the existence of an efficient structured sparse approximation algorithm M, that given an input vector and the sparsity parameter, returns the vector closest to the input with the specified sparsity structure.
+
+In convolutional neural networks, the max pooling operator finds the downsampled activations that are closest to the activations of the original size by retaining the most significant values. The max pooling can be viewed as two steps: 1) zeroing out the locally non-maximum values;
+
+2) downsampling the activations with the locally maximum values retained. To study the pooled activations with sparsity structures, we can recover dimension loss from the second step (downsampling step) by an unsampling operator. This procedure defines our structured sparse approximation algorithm $\mathbb { M } ( z , k )$ , where $_ { z }$ is the original (unpooled) code, and $k$ is the sparsity parameter for further sparsification, which guarantees that $\mathbb { M } ( z , k )$ is a model- $k$ -sparse signal. With the standard layered formulation for neural networks, we have
+
+$$
+\mathbb { M } ( z , k ) = \mathrm { b l o c k - s p a r s i f y } ( \operatorname { u p s a m p l e } ( \operatorname { m a x - p o o l } ( z ) , s ) , k ) ,
+$$
+
+where $\pmb { s }$ denotes the upsampling switches that indicate where to place the non-zero values in the upsampled activations. Taking the pooling switches known from the max pooling operation as $\pmb { s }$ , we specifically define $\mathbb { M }$ as the nesting of the max pooling and the unpooling with known switch. We define this special case as
+
+$$
+\mathbb { M } _ { \mathrm { k n o w n } } ( z , k ) = \mathrm { b l o c k - s p a r s i f y } ( \mathrm { u p s a m p l e } ( \operatorname* { m a x } \mathrm { - p o o l } ( z ) , \operatorname* { m a x } \mathrm { - p o o l } \mathrm { - s w i t c h } ( z ) ) , k ) .
+$$
+
+Alternatively, using the fixed uniform switches as $\pmb { s }$ , we specifically define $\mathbb { M }$ as the nesting of the max pooling and the naive unsampling, denoted by $\mathbb { M } _ { \mathrm { f i x e d } }$ . In the rest of this paper, our theoretical analysis are generic to any type of valid upsampling switches6, so we use $\mathbb { M } ( z , k )$ to denote the structured sparse approximation algorithm without worrying about $\pmb { s }$ . The two special cases $\mathbb { M } _ { \mathrm { k n o w n } }$ and $\mathbb { M } _ { \mathrm { f i x e d } }$ are used in the empirical analysis when we need to specify $\mathbb { M } ( z , k )$ as a fully concrete operator.
+
+The main recovery algorithm that we focus on is a model-sparse version of Iterative Hard Thresholding (IHT) (see Blumensath and Davies (2009)), not because we are interested in recovering modelsparse signals, per se, but because one iteration of IHT for our model of sparsity captures exactly a feedforward CNN.7 Algorithm 1 describes the model-based IHT algorithm. In particular, the sequence of steps 4–6 in the middle IHT (without the outer iterative loop) is exactly one layer of a feedforward CNN. As a result, the theoretical analysis of IHT for model-based sparse signal recovery serves as a guide for how to analyze the approximation activations of a CNN.
+
+# 3 ANALYSIS
+
+To motivate our more formal analysis, we begin with a simple example. Suppose that the matrix $W$ is an orthonormal basis for $\mathbb { R } ^ { M D }$ and define $\mathbf { \bar { \Psi } } \mathbf { \Psi } \mathbf { \Psi } \mathbf { \Psi } \mathbf { \Psi } \mathbf { \bar { \Psi } } \mathbf { \Psi } \mathbf { \Psi } \mathbf { \Psi } \mathbf { \bar { \Psi } } - \mathbf { \bar { \Psi } } \mathbf { \Psi } \mathbf { \Psi } ^ { T } ]$ .
+
+Proposition 1. A one-layer CNN using the matrix $\Psi ^ { T }$ , with no pooling, gives perfect reconstruction (with the matrix Ψ) for any input vector x ∈ RMD.
+
+Proof. Because we have both the positive and the negative dot products of the signal with the basis vectors in ReL $\operatorname { U } ( \Psi ^ { T } \pmb { x } ) = \operatorname { R e L U } \bigg ( \bigg [ \pmb { W } \pmb { x } \bigg ] \bigg )$ , we have positive and negative versions of the hidden units $\pmb { h } _ { + } = \mathrm { R e L U } ( W \pmb { x } )$ and $\pmb { h } _ { - } = \mathrm { R e L U } ( - W \pmb { x } )$ where we decompose $\pmb { h } = \pmb { W } \pmb { x } = \pmb { h } _ { + } - \pmb { h } _ { - }$ into the difference of two non-negative vectors, the positive and the negative entries of $^ { h }$ . From this decomposition, we can easily reconstruct the original signal via
+
+$$
+\Psi \left[ \stackrel { h _ { + } } { h } \right] = \left[ W ^ { T } \quad - W ^ { T } \right] \left[ \stackrel { h _ { + } } { h } \right] = W ^ { T } ( h _ { + } - h _ { - } ) = W ^ { T } h = W ^ { T } W x = x .
+$$
+
+In the example above, we have pairs of vectors $( { \pmb w } , - { \pmb w } )$ in our matrix $\Psi$ . This settings allow us to turn what would ordinarily be a nonlinear function, ReLU, into a linear one. In fact, the assumption that trained CNN filters come in positive and negative is validated by Shang et al. (2016), which makes a CNN much easier to analyze within the model compressed sensing framework.
+
+Suppose that we have a vector $_ { z }$ that we split into positive and negative components, $z = z _ { + } - z _ { - }$ , and that we synthesize (or construct) a signal $_ { \textbf { \em x } }$ from $_ z$ using the matrix $\begin{array} { r l } { \left[ \bar { W ^ { T } } \right. } & { { } \left. - W ^ { T } \right] } \end{array}$ . Then, we have
+
+$$
+\left[ \begin{array} { l l } { \boldsymbol { W } ^ { T } } & { - \boldsymbol { W } ^ { T } } \end{array} \right] \left[ \begin{array} { l } { \boldsymbol { z } _ { + } } \\ { \boldsymbol { z } _ { - } } \end{array} \right] = \boldsymbol { W } ^ { T } ( \boldsymbol { z } _ { + } - \boldsymbol { z } _ { - } ) = \mathbf { W } ^ { T } \boldsymbol { z } = \boldsymbol { x } .
+$$
+
+Next, suppose that we multiply $\mathbf { x } = \mathbf { W } ^ { T } z$ by the transpose of the same matrix, we find $\left[ { \frac { W } { - W } } \right] x =$ $\left[ \begin{array} { c } { W W ^ { T } z } \\ { - W W ^ { T } z } \end{array} \right]$ and, if we apply ReLU to this vector, we produce $\left[ \begin{array} { l } { ( W W ^ { T } z ) _ { + } } \\ { ( W W ^ { T } z ) _ { - } } \end{array} \right]$ a vector that is split into its positive and negative components. To determine whether or not we have “reconstructed” the vector $_ z$ , the structure of the product $W W ^ { T }$ is crucial. In addition, this calculation shows that if we have both positive and negative pairs of filters or vectors, then the ReLU function applied to both the positive and negative dot products simply splits the vector into the positive and negative components. These components are then reassembled in the next computation. For this reason, in the analysis in the following sections, it is sufficient to consider $\mathbf { \boldsymbol { W } } ^ { T } \boldsymbol { z } = \mathbf { \boldsymbol { x } }$ and $W x = h$ with max pooling alone applied to $^ { h }$ , assuming that all of the entries in the vectors are real numbers, rather than only non-negative.
+
+# 3.1 MODEL-RIP AND RANDOM FILTERS
+
+Our first main result says that if we use Gaussian random filters in our CNN, then, with high probability, the transpose of the matrix $W$ formed by the convolutions with these filters has the model-RIP property. In other words, Gaussian random filters generate a matrix whose transpose $W ^ { T }$ is almost an orthonormal transform for sparse signals with a particular sparsity pattern (that is consistent with our pooling procedure). The bounds in the theorem tell us that we must balance the size of the filters $\ell$ and the number of channels $M$ against the sparsity of the hidden units $k$ , the number of the filter banks $K$ , the number of shifts $n$ , the distortion parameter $\delta _ { k }$ , and the failure probability $\epsilon$ . The proof is in Appendix A.
+
+Theorem 3.1. Assume that we have $M K$ vectors ${ \pmb w } _ { i , m }$ of length $\ell$ in which each entry is a scaled i.i.d. (sub-)Gaussian random variable with mean zero and variance $^ { l }$ (the scaling factor is $1 / { \sqrt { M \ell } } )$ . Let t be the stride length (where $n = ( D - \ell ) / t + 1 )$ and build the structured random matrix $W$ as the weight matrix in a single layer CNN for $M$ -channel input dimension $D$ . If
+
+$$
+\frac { M \ell ^ { 2 } } { D } \geq \frac { C k } { \delta _ { k } ^ { 2 } } \Big ( \log ( K ) + \log ( n ) - \log ( \epsilon ) \Big ) ,
+$$
+
+then, with probability $1 - \epsilon$ , the $M D \times K n$ matrix $W ^ { T }$ satisfies the model-RIP for model $\mathcal { M } _ { k }$ with parameter $\delta _ { k }$ .
+
+We also note that the same analysis can be applied to the sum of two model- $k$ -sparse signals, with changes in the constants (that we do not track here).
+
+Corollary 3.2. Random matrices with the CNN structure have, with high probability, the model-RIP property for $\mathcal { M } _ { k } ^ { 2 }$ .
+
+Other examples of matrices that satisfy model-RIP (both empirically and via a less sophisticated analysis on the dot products between any two columns) include wavelets and localized Fourier bases; both examples that can be easily and efficiently implemented via convolutions in a CNN.
+
+# 3.2 RECONSTRUCTION BOUNDS
+
+To distinguish the true sparse code $_ z$ and its reconstruction, we use $\hat { z } = \mathbb { M } ( \boldsymbol { h } , \boldsymbol { k } ) = \mathbb { M } ( W \boldsymbol { x } , \boldsymbol { k } )$ for the reconstruction by CNN. Our next result tells us that if we compute the hidden units $^ { h }$ from an input signal $_ { \textbf { \em x } }$ using a weight matrix $W$ whose transpose has the model-RIP and using max pooling over each filter $( \hat { z } )$ , then we can reconstruct (approximately) the input signal $_ { \textbf { \em x } }$ simply by multiplying the hidden units by $W$ . This result bounds the relative error between the approximate reconstruction $\hat { \pmb x }$ and the input as a function of the distortion for the model-RIP. In our analysis, we assume that the input signal $\mathbf { \bar { x } } = \mathbf { W } ^ { T } \boldsymbol { z }$ is a sparse linear combination of hidden activations, captured approximately by the filters in $W$ . See Appendix B for the detailed proofs. Part of our analysis also shows that the hidden units $\hat { z }$ are approximately the putative coefficient vector $_ z$ in the sparse linear representation for the input signal.
+
+Theorem 3.3. We assume that $W ^ { T }$ satisfies the $\mathcal { M } _ { k } ^ { 2 }$ -RIP with constant $\delta _ { k } \leq \delta _ { 2 k } < 1 .$ . If we use $W$ in a single layer CNN both to compute the hidden units $\hat { z }$ and to reconstruct the input $_ { \textbf { \em x } }$ from these hidden units as $\hat { \pmb x }$ so that $\hat { \pmb { x } } = \pmb { W } ^ { \hat { T } } \mathbb { M } ( \pmb { W } \pmb { x } , \boldsymbol { k } )$ , the error in our reconstruction is
+
+$$
+\| \hat { \pmb x } - \pmb x \| _ { 2 } \le \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \frac { \sqrt { 1 + \delta _ { 2 k } } } { \sqrt { 1 - \delta _ { 2 k } } } \| \pmb x \| _ { 2 } .
+$$
+
+Recall that the structured sparsity approximation algorithm $\mathbb { M }$ includes the downsampling caused by pooling and an unsampling operator. Theorem 3.3 is applicable to any type of upsampling switches, so our reconstruction bound is generic to the particular design choice on how to recover the activation size in a decoding neural network.
+
+# 4 EXPERIMENTAL EVIDENCE AND ANALYSIS
+
+In this section, we provide experimental validation of our theoretical model and analysis. We first validate experimentally the relevance of our assumption by examining the effectiveness of random filter CNNs. We then provide an experimental validation of our theoretical analysis on the synthetic 1D case, then we provide experimental results on more realistic scenarios. In particular, we study popular deep neural networks trained for image classification on the ImageNet ILSVRC 2012 dataset (Deng et al., 2009). We calculate empirical model-RIP bounds for $\mathbf { \bar { W } } ^ { T }$ , showing that they are consistent with theory. Our results are also consistent with a long line of research shows that it is reasonable to model real, natural images as sparse linear combinations over learned dictionaries (e.g., Boureau et al. (2008); Le et al. (2013); Lee et al. (2008); Olshausen et al. (1996); Ranzato et al. (2007); Yang et al. (2010)). In addition, we verify our theoretical bounds for the reconstruction error $\| \pmb { x } - \pmb { W } ^ { T } \hat { \pmb { z } } \| _ { 2 } / \| \pmb { x } \| _ { 2 }$ on real images. (This is the relative $\ell _ { 2 }$ distance between the original image and the reconstruction.) We investigate both randomly sampled filters and empirically learned filters in these experiments. Our implementation is based on the Caffe (Jia et al., 2014) and MatConvNet (Vedaldi and Lenc, 2015) toolboxes.
+
+# 4.1 EVALUATION OF GAUSSIAN RANDOM CNNS ON CIFAR-10
+
+To show the practical relevance of our theoretical assumptions on using random filters for CNNs as stated in Section 2.1, we evaluate simple CNNs with Gaussian random filters (with i.i.d. zeromean unit-variance entries) on the CIFAR-10 dataset. The goal of this experiment is not to achieve state-of-the-art results, but to examine practical relevance of our assumption on random filter CNNs. Once the CNNs weights are initialized (randomly), they are fixed during the training of the classifiers. Specifically, we test random CNNs with 1, 2, and 3 convolutional layers, where we use ReLU as the activation. A $2 \times 2$ max pooling layer follows each convolutional layer to down-sample the feature map.8 We experiment with different filter sizes $( 3 , 5 , 7 )$ and numbers of channels (64, 128, 256, 1024, 2048) and report the classification accuracy of the best-performing architectures based on cross-validation in Table 1. We also report the best performance using learnable filters for comparison. More details about the architectures can be found in Section C.1 of the supplementary materials. We observe the CNNs with Gaussian random filters achieve surprisingly good classification performance (implying that they serve as reasonable representation of input data), although fully learnable CNN counterparts perform better. Our experimental results are also consistent with the observations made by Jarrett et al. (2009) and Saxe et al. (2011). Overall, these results seem to suggest that the CNNs with Gaussian random filters might be a reasonable setup which is amenable to mathematical analysis while not being too far off in terms of practical relevance.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>1 layer</td><td rowspan=1 colspan=1>2 layers</td><td rowspan=1 colspan=1>3layers</td></tr><tr><td rowspan=1 colspan=1>Random filters</td><td rowspan=1 colspan=1>66.5%</td><td rowspan=1 colspan=1>74.6%</td><td rowspan=1 colspan=1>74.8%</td></tr><tr><td rowspan=1 colspan=1>Learned filters</td><td rowspan=1 colspan=1>68.1%</td><td rowspan=1 colspan=1>83.3%</td><td rowspan=1 colspan=1>89.3%</td></tr></table>
+
+Table 1: Classification accuracy of CNNs with random and learnable filters on CIFAR-10. A typical layer consists of four operators: convolution, ReLU, batch normalization and max pooling. Networks with optimal filter size and numbers of output channels are used (see Section C.1 in the supplementary materials for the architecture details). The random filters, assumed in our theoretical analysis, perform reasonably well, not far off the learned filters.
+
+# 4.2 EXPERIMENTAL VALIDATION OF THE ANALYSIS IN 1D SYNTHETIC DATA
+
+We use 1-D synthetic data to empirically show the basic validity of our theory in terms of the modelRIP condition in Equation (1) and reconstruction bound in Theorem 3.3. We plot the histograms√ of the empirical model-RIP values of 1D Gaussian random filters $W$ ( scaled by $1 / \sqrt { l M }$ ) with size $l \times 1 \times M \times K = 5 \times 1 \times 3 2 \times 9 6$ on 1D $\mathcal { M } _ { k }$ sparse signal $_ z$ with size $D = 3 2$ and sparsity $k = 1 0$ , whose non-zero elements are drawn from a uniform distribution on $[ - 1 , 1 ]$ . The histograms in Figure 2a and 2b are tightly centered around 1, suggesting that $W ^ { T }$ satisfies the model-RIP condition in Equation (1) and its corollary from Lemma B.1 in the supplementary materials. We also empirically show the reconstruction bound in Theorem 3.3 on synthetic vectors $\mathbf { \Psi } _ { \pmb { x } } = \mathbf { W } ^ { T } \boldsymbol { z }$ (Figure 2c). The reconstruction error is concentrated at around 0.1–0.2 and bound under 0.5. Results in Figure 2 suggests the practical validity of our theory when the model assumptions hold.
+
+# 4.3 ARCHITECTURES AND DATASET
+
+We conduct the rest of our experimental evaluations on the 16-layer VGGNet (Model D in Simonyan and Zisserman (2015)),9 where the computation is carried out on images; e.g., convolution with a 2-D filter bank and pooling on square regions. In contrast to the theory, the realistic network does not pool activations over all the possible shifts for each filter, but rather on non-overlapping patches. The networks are trained for the large-scale ImageNet classification task, which is important for extending to other supervised tasks in vision. The main findings on VGGNet are presented in the rest of this section; we also provide some analysis on AlexNet (Krizhevsky et al., 2012) in the supplementary materials.
+
+![](images/008e336bf956f0a2eb88da5c96920cb856459bc5f3d19ed12bb8980dd3079c5c.jpg)  
+Figure 2: For 1D scaled Gaussian random filters $W$ , we plot the histogram of ratios (a) $\| \boldsymbol { W } ^ { T } \boldsymbol { z } \| _ { 2 } / \| \boldsymbol { z } \| _ { 2 }$ (modelRIP condition in Equation (1); supposed to be concentrated at 1), (b) $\| W W ^ { T } z \| _ { 2 } / \| z \| _ { 2 }$ (model-RIP corollary from Lemma B.1 in the supplementary materials; supposed to be concentrated at 1), and (c) $\| \hat { \pmb x } - \pmb x \| _ { 2 } / \| \pmb x \| _ { 2 }$ (reconstruction bound in Theorem 3.3, supposed to be small), where $_ { z }$ is a $\mathcal { M } _ { k }$ sparse signal that generates the vector $_ { \pmb { x } }$ and $\pmb { \hat { x } } = \pmb { W } ^ { T } \mathbb { M } _ { \mathrm { f i x e d } } ( \pmb { W } \pmb { x } , \hat { k } )$ is the reconstruction of $_ { \textbf { \em x } }$ , where we use the naive unsampling to recover the reduced dimension due to pooling (see Section 2.3).
+
+<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>c(1,1)</td><td rowspan=1 colspan=1>c(1,2)</td><td rowspan=1 colspan=1>p(1)</td><td rowspan=1 colspan=1>c(2,1)</td><td rowspan=1 colspan=1>c(2,2)</td><td rowspan=1 colspan=1>p(2)</td><td rowspan=1 colspan=1>c(3,1)</td><td rowspan=1 colspan=1>c(3,2)</td><td rowspan=1 colspan=1>c(3,3)</td><td rowspan=1 colspan=1>p(3)</td></tr><tr><td rowspan=1 colspan=1>% of non-zeros</td><td rowspan=1 colspan=1>49.1</td><td rowspan=1 colspan=1>69.7</td><td rowspan=1 colspan=1>80.8</td><td rowspan=1 colspan=1>67.4</td><td rowspan=1 colspan=1>49.7</td><td rowspan=1 colspan=1>70.7</td><td rowspan=1 colspan=1>53.4</td><td rowspan=1 colspan=1>51.9</td><td rowspan=1 colspan=1>28.7</td><td rowspan=1 colspan=1>45.9</td></tr><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>c(4,1)</td><td rowspan=1 colspan=1>c(4,2)</td><td rowspan=1 colspan=1>c(4,3)</td><td rowspan=1 colspan=1>p(4)</td><td rowspan=1 colspan=1>c(5,1)</td><td rowspan=1 colspan=1>c(5,2)</td><td rowspan=1 colspan=1>c(5,3)</td><td rowspan=2 colspan=3>p(5)13.1</td></tr><tr><td rowspan=1 colspan=1>% of non-zeros</td><td rowspan=1 colspan=1>35.6</td><td rowspan=1 colspan=1>29.6</td><td rowspan=1 colspan=1>12.6</td><td rowspan=1 colspan=1>23.1</td><td rowspan=1 colspan=1>23.9</td><td rowspan=1 colspan=1>20.6</td><td rowspan=1 colspan=1>7.3</td></tr></table>
+
+Table 2: Layer-wise sparsity of VGGNet on ILSVRC-2012 validation set. “c” stands for convolutional layers while “p” represents pooling layers. CNN with random filters in Section 4.4 can be simulated with the same sparsity.
+
+VGGNet contains five groups of convolution and pooling layers, each group has 2\~3 convolutional layers followed by a pooling layer. We denote the $j$ -th convolutional layer in the $i$ -th group “conv $( i , j )$ ,” and the pooling layer “pool(i).” When we say the activations/features are from $i$ -th layer, we mean they are the output of $\mathsf { p o o l } ( i )$ . Our analysis is for single convolutional layers. When evaluating the $i$ -th layer, we take the activations from the $( i - 1 )$ -th layer, and investigate the filters and output of $\mathrm { c o n v } ( i , 1 )$ .
+
+# 4.4 2D MODEL-RIP
+
+The key to our reconstruction bound is Theorem 3.3 is the model-RIP condition for our particular model of sparsity in Equation (1). We empirically evaluate the model-RIP property, i.e., $\| \boldsymbol { W } ^ { \hat { T } } \boldsymbol { z } \| / \| \boldsymbol { z } \|$ , for real CNN filters of the pretrained VGGNet. We use two-dimensional coefficients (or hidden units) $_ z$ (each block of coefficients is of size $D \times D ,$ ), $K$ filters of size $\ell \times \ell$ , and pool the coefficients over smaller pooling regions (i.e., not over all possible shifts of each filter). The following experimental evidence suggest that the sparsity model and the model-RIP property of the filters are consistent with what we conclude from the mathematical analysis on the simpler one-dimensional case.
+
+To check the significance of the model-RIP property (i.e., how close $\| \mathbfcal { W } ^ { T } z \| / \| z \|$ is to 1) in controlled settings, we first synthesize the hidden activations $_ z$ with sparse uniform random variables, which fully agree with our model assumptions. The sparsity of $_ { z }$ is constrained to the average level of the real CNN activations (refer to Table 2). Given the filters of a certain convolutional layer, we use the synthetic $_ z$ (in equal position to this layer’s output activations) to get statistics for the model-RIP property. To be consistent with succeeding experiments, we choose conv $( 5 , 2 )$ , while other layers show similar results. Figure 3 (a) summarizes the distribution of empirical model-RIP values, which is clearly centered around 1 and satisfies Equation (1) with a short tail roughly bounded by $\delta _ { k } < 1$ For more details of the algorithm, we normalize the filters from the conv $( 5 , 2 )$ layer, which are $\ell \times \ell$ $\ell = 3$ ). All $K = 5 1 2$ filters with $M = 5 1 2$ input channels are used.10 We set $D = 1 5$ (the same as the output activations of conv $( 5 , 2 )$ ) and use $2 \times 2$ pooling regions11 (commonly used in recent deep networks). We generate $1 0 0 0 \mathcal { M } _ { k }$ randomly sampled sparse activation $( z )$ maps by first sampling their non-zero supports and then filling elements on the supports uniformly from $[ - 1 , 1 ]$ . The sparsity is the same as that in $\mathrm { c o n v } ( 5 , 1 )$ activations.
+
+![](images/41941e45c936558ec0669584eb138f406609034351bd2117f34c7b9d9998ab09.jpg)  
+Figure 3: For VGGNet’s conv $( 5 , 2 )$ filters $W$ , we plot the histogram of ratios $\| \boldsymbol { W } ^ { T } \boldsymbol { z } \| _ { 2 } / \| \boldsymbol { z } \| _ { 2 }$ (the model-RIP value derived from Equation (1); supposed to be concentrated at 1) where $_ { z }$ is a $\mathcal { M } _ { k }$ sparse signal. (a) $_ { z }$ is randomly generated with the same sparsity as the conv $( 5 , 2 )$ activations and from a uniform distribution for the non-zero magnitude. (b) $_ { z }$ is recovered by Algorithm 2 from the conv(5,1) activations before applying ReLU. (c) $_ { z }$ is recovered by Algorithm 2 from the conv(5,1) activations after applying ReLU. The learned filters admits similar model-RIP value distributions to the random filters except for a bit larger bandwidth, which means the model-RIP condition in Equation (1) can empirically hold even when the filters do not necessarily subject to the i.i.d Gaussian random assumption.
+
+To conduct more realistic experiments, we observe the actual conv $( 5 , 2 )$ activations from VGGNet are not necessarily drawn from a model-sparse uniform distribution. This motivates us to evaluate the empirical model-RIP property on the hidden activations $_ z$ that reconstruct the actual input activations $_ { \textbf { \em x } }$ from conv $( 5 , 1 )$ by $\dot { W } ^ { T } z$ . Per theory, the $_ { \textbf { \em x } }$ is given by a max pooling layer, so we constrain the sparsity
+
+Algorithm 2 Sparse hidden activation recovery
+
+Input: convolution matrix $W$ , input activation/image $_ { \textbf { \em x } }$
+
+Output: hidden code $_ z$ , satisfying our model-RIP assumption with $\mathcal { M } _ { k }$ and reconstructing $_ { \textbf { \em x } }$ with $W$ $\begin{array} { r } { ! \ : \ z ^ { \mathrm { i n i t } } = \arg \operatorname* { m i n } _ { z } \left\| x - W ^ { T } z \right\| _ { 2 } ^ { 2 } + \lambda \| z \| _ { 1 } } \end{array}$   
+2: $z ^ { \mathrm { m o d e l } } = \mathbb { M } _ { \mathrm { k n o w n } } ( z ^ { \mathrm { i n i t } } , k )$   
+3: $\begin{array} { r } { z = \mathrm { a r g m i n } _ { z } \left\| \boldsymbol { x } - \boldsymbol { W } ^ { T } \boldsymbol { z } \right\| _ { 2 } ^ { 2 } + \lambda \| \boldsymbol { z } \| _ { 1 } , } \end{array}$ s.t. $z _ { i } = 0$ if $z _ { i } ^ { \mathrm { m o d e l } } = 0$
+
+(i.e., the size of the support set is no more than 1 in a pooling region for a single channel). We use a simple and efficient algorithm to recover $_ z$ from $_ { \textbf { \em x } }$ in Algorithm 2. The algorithm is inspired by $^ { 6 6 } \ell _ { 1 }$ heuristic" method that are commonly used in practice (e.g. Boyd (2015)). As shown in Algorithm 2, we first do $\ell _ { 1 }$ -regularized least squares without constraining the support set. Max pooling is then applied to figure out the support set for each pooling region. In particular, we use $\mathbb { M } _ { \mathrm { k n o w n } }$ , defined in (3), to zero out the locally non-maximum values without messing up the support structures. We perform $\ell _ { 1 }$ -regularized least squares again on the fixed support set to recover the hidden activations satisfying the model sparsity. As shown in Figures 3 (b)–(c), the empirical model-RIP property values for visual activations $_ { \textbf { \em x } }$ from conv $( 5 , 1 )$ with/without ReLU are both close to 1. The center offset to 1 is less than 0.05 and the range bound $\delta _ { k }$ is rough less then 0.05, which agrees with the theoretical bound (1) quite well.
+
+To gain more insight, we summarize the learned filter coherence in Table 4 for all the convolutional layers in VGGNet.12 This measures the correlation or similarity between the columns of $W ^ { T }$ and is a proxy for the value of the model-RIP parameter $\delta _ { k }$ (which we can only estimate computationally). The smaller the coherence, the smaller $\delta _ { k }$ is, and the better the reconstruction. The coherence of the learned filters is not low, which is inconsistent with our theoretical assumptions. However, the model-RIP property turns out to be robust to this mismatch. It also demonstrates the strong invertibility of CNN in practice.
+
+# 4.5 RECONSTRUCTION BOUNDS
+
+With model-RIP as a sufficient condition, Theorem 3.3 provides theoretical bounds for layer-wise reconstruction via $\pmb { \hat { x } } = \pmb { W } ^ { T } \mathbb { M } ( \pmb { W } \pmb { x } , \boldsymbol { k } )$ . This operator consists of the projection and reconstruction in one IHT iteration. Without confusion, we refer to it as IHT for notational convenience. We investigate the practical reconstruction errors on Layer 1\~4 activations (i.e., pool(1)\~(4)) of VGGNet.
+
+To encode and reconstruct intermediate activations of CNNs, we employ IHT with sparsity estimated from the real CNN activations on ILSVRC-2012 validation set (see Table 2). We also reconstruct input images, since CNN inversion is not limited to a single layer, and images are easier to visualize than hidden activations. To implement image reconstruction, we project the reconstructed activations into the image space via a pretrained decoding network as in (Zhang et al., 2016), which extends a similar autoencoder architecture as in (Dosovitskiy and Brox, 2016) to a stacked “what-where” autoencoder (Zhao et al., 2016). The reconstructed activations were scaled to have the same norm as the original activations so that we can feed them into the decoding network.
+
+![](images/375179f41ca88f7856684055b31eed5eaeed185090332eaf25420aa0904b1243.jpg)  
+Figure 4: Visualization of images reconstructed by a pretrained decoding network with VGGNet’s pool(4) activation reconstructed using different methods: (a) original image, (b) output of the 5-layer decoding network with original activation, (c) output of the decoding net with reconstructed activation by IHT with learned filters, (d) output of the decoding net with reconstructed activation by IHT with Gaussian random filters, (e) output of the decoding net with Gaussian random activation.
+
+As an example, Figure 4 illustrates the image reconstruction results for the hidden activations of the 4-th layer, the ground truth of which is obtained by feeding natural images to the CNNs. Interestingly, the decoding network itself is powerful, since it can reconstruct the glimpse of images with Gaussian random input, as shown in Figure 4 (e). Object shapes are recovered by using the pooling switches only in the “what-where” autoencoder. This result suggests that it is important to determine which pooling units are active and then to estimate these values accurately. These steps are consistent with the steps in the inner loop of any iterative sparse signal reconstruction algorithm.
+
+In Figure 4 (c), we take the pretrained conv $( 5 , 1 )$ filters for IHT. The images recovered from the IHT reconstructed 4-th layer activations are reasonable and the reconstruction quality is significantly better than the random input baseline. We also try Gaussian random filters (Figure 4 (d)), which agree more with the model assumptions (e.g., lower coherence, see Table 4). The learned filters from VGGNet perform equally well visually. IHT ties the encoder and decoder weights (no filter learning for the decoder), so it does not perform as well as the decoding network trained with a huge batch of data (Figure 4 (b)). Nevertheless, we show both theoretically and experimentally decent reconstruction bounds for these simple reconstruction methods on real CNNs. More visualization results for more layers are in the supplementary materials (Figure 5 in Section C.3).
+
+In Table 3, we summarize reconstruction performance for all 4 layers. With random filters, the model assumptions hold and the IHT reconstruction is the best quantitatively. IHT with real CNN filters performs comparable to the best case and much better than the baseline established by the randomly sampled activations.
+
+Additionally, reconstruction performance of IHT is strongly related to the filter coherence, summarized in Table 4. Lower coherence agrees more closely with the model assumptions and leads to higher reconstruction quality. Higher coherence yields worse recovery of the hidden activation (i.e., large $\lVert \hat { z } - z \rVert$ , where $\hat { z }$ is the hidden activations recovered by IHT, $_ z$ is the true activation). Compared to Algorithm 2, (one-step) IHT is not so robust to high coherence.
+
+In summary, when the assumption of i.i.d Gaussian randomness of the CNN filters holds, our theoretical reconstruction bound strictly match with the empirical observations. More importantly, we demonstrate that the bound can still reasonably hold in practice for discriminatively learned CNN layers, which is particularly true for layers with relatively lower coherence.
+
+# 5 CONCLUSION
+
+We introduce three concepts that tie together a particular model of compressive sensing (and the associated recovery algorithms), the properties of learned filters, and the empirical observation that CNNs are (approximately) invertible. Our experiments show that filters in trained CNNs are consistent with the mathematical properties we present while the hidden units exhibit a much richer structure than mathematical analysis suggests. Perhaps simply moving towards a compressive, rather than exactly sparse, model for the hidden units will capture the sophisticated structure in these layers of a CNN or, perhaps, we need a more sophisticated model. Our experiments also demonstrate that there is considerable information captured in the switch units (or the identities of the non-zeros in the hidden units after pooling) that no mathematical model has yet expressed or explored thoroughly.
+
+Table 3: Layer-wise relative reconstruction errors by different methods in activation space and image space between reconstructed and original activations. For layer $_ { i }$ , we take its activation after pooling from that layer and reconstruct it with different methods (using learned filters from the layer above or scaled Gaussian random filters) and feed the reconstructed activation to a pretrained corresponding decoding network.13   
+
+<table><tr><td rowspan=2 colspan=1>layer</td><td rowspan=1 colspan=3>image space relative error</td><td rowspan=1 colspan=3>activation space relative error</td></tr><tr><td rowspan=1 colspan=1>learnedfilters</td><td rowspan=1 colspan=1>randomfilters</td><td rowspan=1 colspan=1>randomactivations</td><td rowspan=1 colspan=1>learnedfilters</td><td rowspan=1 colspan=1>randomfilters</td><td rowspan=1 colspan=1>randomactivations</td></tr><tr><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0.423</td><td rowspan=1 colspan=1>0.380</td><td rowspan=1 colspan=1>0.610</td><td rowspan=1 colspan=1>0.895</td><td rowspan=1 colspan=1>0.872</td><td rowspan=1 colspan=1>1.414</td></tr><tr><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>0.692</td><td rowspan=1 colspan=1>0.438</td><td rowspan=1 colspan=1>0.864</td><td rowspan=1 colspan=1>0.961</td><td rowspan=1 colspan=1>0.926</td><td rowspan=1 colspan=1>1.414</td></tr><tr><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>0.326</td><td rowspan=1 colspan=1>0.345</td><td rowspan=1 colspan=1>0.652</td><td rowspan=1 colspan=1>0.912</td><td rowspan=1 colspan=1>0.862</td><td rowspan=1 colspan=1>1.414</td></tr><tr><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>0.379</td><td rowspan=1 colspan=1>0.357</td><td rowspan=1 colspan=1>0.436</td><td rowspan=1 colspan=1>1.051</td><td rowspan=1 colspan=1>0.992</td><td rowspan=1 colspan=1>1.414</td></tr></table>
+
+Table 4: Comparison of coherence between learned filters in each convolutional layer of VGGNet and Gaussian random filters with corresponding sizes.   
+
+<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>(1,1)</td><td rowspan=1 colspan=1>(1,2)</td><td rowspan=1 colspan=1>(2,1)</td><td rowspan=1 colspan=1>(2,2)</td><td rowspan=1 colspan=1>(3,1)</td><td rowspan=1 colspan=1>(3,2)</td><td rowspan=1 colspan=1>(3.3)</td></tr><tr><td rowspan=1 colspan=1>coherence of learned flters</td><td rowspan=1 colspan=1>0.9427</td><td rowspan=1 colspan=1>0.7340</td><td rowspan=1 colspan=1>0.6435</td><td rowspan=1 colspan=1>0.7465</td><td rowspan=1 colspan=1>0.5838</td><td rowspan=1 colspan=1>0.4844</td><td rowspan=1 colspan=1>0.5194</td></tr><tr><td rowspan=1 colspan=1>coherence of random filters</td><td rowspan=1 colspan=1>0.6701</td><td rowspan=1 colspan=1>0.1218</td><td rowspan=1 colspan=1>0.1546</td><td rowspan=1 colspan=1>0.1053</td><td rowspan=1 colspan=1>0.1099</td><td rowspan=1 colspan=1>0.0895</td><td rowspan=1 colspan=1>0.0802</td></tr><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>(4,1)</td><td rowspan=1 colspan=1>(4,2)</td><td rowspan=1 colspan=1>(4,3)</td><td rowspan=1 colspan=1>(5,1)</td><td rowspan=1 colspan=1>(5,2)</td><td rowspan=3 colspan=2>(5.3)0.40460.0674</td></tr><tr><td rowspan=1 colspan=1>coherence of learned filters</td><td rowspan=1 colspan=1>0.4596</td><td rowspan=1 colspan=1>0.4574</td><td rowspan=1 colspan=1>0.4043</td><td rowspan=1 colspan=1>0.4099</td><td rowspan=1 colspan=1>0.4099</td><td rowspan=1 colspan=1>0.4046</td></tr><tr><td rowspan=1 colspan=1>coherence of random filters</td><td rowspan=1 colspan=1>0.0920</td><td rowspan=1 colspan=1>0.0619</td><td rowspan=1 colspan=1>0.0617</td><td rowspan=1 colspan=1>0.0696</td><td rowspan=1 colspan=1>0.0674</td><td rowspan=1 colspan=1>0.0674</td></tr></table>
+
+# REFERENCES
+
+S. Arora, A. Bhaskara, R. Ge, and T. Ma. Provable Bounds for Learning Some Deep Representations. ICML, pages 584–592, 2014.   
+S. Arora, Y. Liang, and T. Ma. Why are deep nets reversible: A simple theory, with implications for training. arXiv:1511.05653, 2015.   
+P. Baldi, P. Sadowski, and D. Whiteson. Searching for exotic particles in high-energy physics with deep learning. Nature communications, 5, 2014.   
+R. G. Baraniuk, V. Cevher, M. F. Duarte, and C. Hegde. Model-Based Compressive Sensing. IEEE Transactions on Information Theory, 56(4):1982–2001, 2010.   
+A. Beck and M. Teboulle. A fast iterative shrinkage-thresholding algorithm for linear inverse problems. SIAM Journal of Imaging Science, 2:183–202, 2009.   
+Y. Bengio, A. Courville, and P. Vincent. Representation Learning: A Review and New Perspectives. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8), 2013.   
+T. Blumensath and M. E. Davies. Iterative hard thresholding for compressed sensing. Applied and Computational Harmonic Analysis, 27(3):265–274, 2009.   
+Y.-l. Boureau, Y. L. Cun, et al. Sparse feature learning for deep belief networks. In NIPS, 2008.   
+S. Boyd. l1-norm methods for convex-cardinality problems, ee364b: Convex optimization ii lecture notes, 2014-2015 spring. 2015.   
+J. Bruna, A. Szlam, and Y. LeCun. Signal recovery from pooling representations. In ICML, pages 307–315, 2014.   
+E. J. Candés. The restricted isometry property and its implications for compressed sensing. Comptes Rendus Mathematique, 346(9):589–592, 2008.   
+D. Chicco, P. Sadowski, and P. Baldi. Deep autoencoder neural networks for gene ontology annotation predictions. In Proceedings of the 5th ACM Conference Bioinformatics, Computational Biology, and Health Informatics, pages 533–540, 2014.   
+K. Cho, B. Van Merriënboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.   
+R. Collobert, J. Weston, L. Bottou, M. Karlen, K. Kavukcuoglu, and P. Kuksa. Natural language processing (almost) from scratch. Journal of Machine Learning Research, 12(Aug):2493–2537, 2011.   
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255, June 2009.   
+A. Dosovitskiy and T. Brox. Inverting visual representations with convolutional networks. CVPR, 2016.   
+R. Giryes, G. Sapiro, and A. M. Bronstein. Deep neural networks with random gaussian weights: A universal classification strategy? IEEE Transactions on Signal Processing, 64(13):3444–3457, 2016.   
+A. Hannun, C. Case, J. Casper, B. Catanzaro, G. Diamos, E. Elsen, R. Prenger, S. Satheesh, S. Sengupta, A. Coates, et al. Deep speech: Scaling up end-to-end speech recognition. arXiv preprint arXiv:1412.5567, 2014.   
+K. He, Y. Wang, and J. Hopcroft. A powerful generative model using random weights for the deep image representation. arXiv preprint arXiv:1606.04801, 2016.   
+G. Hinton, L. Deng, D. Yu, G. E. Dahl, A.-r. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.   
+K. Jarrett, K. Kavukcuoglu, M. Ranzato, and Y. LeCun. What is the best multi-stage architecture for object recognition? In ICCV, pages 2146–2153, 2009.   
+Y. Jia, E. Shelhamer, J. Donahue, S. Karayev, J. Long, R. Girshick, S. Guadarrama, and T. Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv:1408.5093, 2014.   
+A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In NIPS, pages 1097–1105, 2012.   
+Q. V. Le, M. Ranzato, R. Monga, M. Devin, K. Chen, G. S. Corrado, J. Dean, and A. Y. Ng. Building high-level features using large scale unsupervised learning. In ICML, 2013.   
+Y. LeCun, B. Boser, J. S. Denker, D. Henderson, R. E. Howard, W. Hubbard, and L. D. Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.   
+H. Lee, C. Ekanadham, and A. Y. Ng. Sparse deep belief net model for visual area v2. In NIPS, 2008.   
+S. Mallat and Z. Zhang. Matching pursuits with time-frequency dictionaries. IEEE Transactions on Signal Processing, 41:3397 – 3415, 1993.   
+T. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pages 3111–3119, 2013.   
+B. A. Olshausen et al. Emergence of simple-cell receptive field properties by learning a sparse code for natural images. Nature, 381(6583):607–609, 1996.   
+J. Y. Park, H. L. Yap, C. Rozell, and M. B. Wakin. Concentration of Measure for Block Diagonal Matrices With Applications to Compressive Signal Processing. IEEE Transactions on Signal Processing, 59(12):5859–5875, 2011.   
+A. Paul and S. Venkatasubramanian. Why does Deep Learning work? - A perspective from Group Theory. arXiv.org, Dec. 2014.   
+M. A. Ranzato, F. J. Huang, Y.-L. Boureau, and Y. LeCun. Unsupervised learning of invariant feature hierarchies with applications to object recognition. In CVPR, 2007.   
+A. Saxe, P. W. Koh, Z. Chen, M. Bhand, B. Suresh, and A. Y. Ng. On random weights and unsupervised feature learning. In ICML, pages 1089–1096, 2011.   
+J. Schmidhuber. Deep learning in neural networks: An overview. Neural Networks, 2015.   
+W. Shang, K. Sohn, D. Almeida, and H. Lee. Understanding and improving convolutional neural networks via concatenated rectified linear units. In ICML, 2016.   
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.   
+C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, and A. Rabinovich. Going deeper with convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 1–9, 2015.   
+A. Vedaldi and K. Lenc. Matconvnet – convolutional neural networks for matlab. In Proceeding of the ACM Int. Conf. on Multimedia, 2015.   
+R. Vershynin. Introduction to the non-asymptotic analysis of random matrices. arXiv.org, Nov. 2010.   
+J. Yang, J. Wright, T. S. Huang, and Y. Ma. Image super-resolution via sparse representation. Image Processing, IEEE Transactions on, 19(11):2861–2873, 2010.   
+Y. Zhang, K. Lee, and H. Lee. Augmenting neural networks with reconstructive decoding pathways for large-scale image classification. In ICML, 2016.   
+J. Zhao, M. Mathieu, R. Goroshin, and Y. Lecun. Stacked what-where auto-encoders. arXiv:1506.02351, 2016.
+
+# Supplementary Materials: Towards Understanding the Invertibility of Convolutional Neural Networks
+
+A MATHEMATICAL ANALYSIS: MODEL-RIP AND RANDOM FILTERS
+
+Theorem 3.1(Restated) Assume that we have $M K$ vectors ${ \pmb w } _ { i , m }$ of length $\ell$ in which each entry is a scaled i.i.d. (sub-)Gaussian random variable with mean zero and variance√ $^ { l }$ (the scaling factor is $1 / \sqrt { M \ell } )$ . Let t be the stride length (where $n = ( D - \ell ) / t + 1 )$ and build the structured random matrix $W$ as the weight matrix in a single layer CNN for $M$ -channel input dimension $D$ . If
+
+$$
+\frac { M \ell ^ { 2 } } { D } \geq \frac { C k } { \delta _ { k } ^ { 2 } } \Big ( \log ( K ) + \log ( n ) - \log ( \epsilon ) \Big ) ,
+$$
+
+then, with probability $1 - \epsilon ,$ , the $M D \times K n$ matrix $W ^ { T }$ satisfies the model-RIP for model $\mathcal { M } _ { k }$ with parameter $\delta _ { k }$ .
+
+Proof. We note that this result follows the same structure of that for many proofs of the RIP for (structured) random matrices (see Park et al. (2011); Vershynin (2010) for details) although we make minor tweaks to account for the particular structure of $W ^ { \overline { { T } } }$ .
+
+Suppose that $z \in \mathcal { M } _ { k }$ which means that $_ z$ consists of at most $k$ non-zero entries that each appear in a distinct block of size $n$ (there are a total of $K$ blocks). First, we observe that the norm of $\dot { W } ^ { T } z$ is preserved in expectation.
+
+# Lemma A.1.
+
+$$
+\mathbb { E } ( \| \boldsymbol { W } ^ { T } \boldsymbol { z } \| _ { 2 } ^ { 2 } ) = \| \boldsymbol { z } \| _ { 2 } ^ { 2 }
+$$
+
+Proof. Note that each entry of $W ^ { T }$ is either zero or Gaussian random variable $w \sim N ( 0 , 1 )$ (suitably normalized). Therefore, it is obvious that $\mathbb { E } ( W W ^ { T } ) = I$ since each row of $W$ satisfies $\mathbb { E } \left( \left( \boldsymbol { \omega } _ { i , m _ { 1 } } ^ { j _ { 1 } } \right) ^ { T } \left( \boldsymbol { \omega } _ { i , m _ { 2 } } ^ { j _ { 2 } } \right) \right) = 0$ if $j _ { 1 } \neq j _ { 2 }$ or $m _ { 1 } \neq m _ { 2 }$ , and we normalized the random variables so that $\mathbb { E } \left( \left\| \left[ \left( \boldsymbol { w } _ { i , 1 } ^ { j } \right) ^ { T } , \ldots , \left( \boldsymbol { w } _ { i , M } ^ { j } \right) ^ { T } \right] \right\| _ { 2 } \right) = 1$ for all $j$ . Finally, we have
+
+$$
+\begin{array} { r } { \mathbb { E } \left( \| \boldsymbol { W } ^ { T } \boldsymbol { z } \| _ { 2 } ^ { 2 } \right) = \mathbb { E } \left( \boldsymbol { z } ^ { T } \boldsymbol { W } \boldsymbol { W } ^ { T } \boldsymbol { z } \right) = \boldsymbol { z } ^ { T } \mathbb { E } \left( \boldsymbol { W } \boldsymbol { W } ^ { T } \right) \boldsymbol { z } = \boldsymbol { z } ^ { T } \boldsymbol { z } = \| \boldsymbol { z } \| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Let $\begin{array} { r } { \pmb { y } = \pmb { W } ^ { T } \pmb { z } } \end{array}$ . We aim to show that the square norm of the random variable $\| \boldsymbol { y } \| _ { 2 } ^ { 2 }$ concentrates tightly about its mean; i.e., with exceedingly low probability
+
+$$
+\left| \| \pmb { y } \| _ { 2 } ^ { 2 } - \| \pmb { z } \| _ { 2 } ^ { 2 } \right| > \delta \| \pmb { z } \| _ { 2 } ^ { 2 } .
+$$
+
+To do so, we need several properties of sub-Gaussian and sub-exponential random variables. A mean-zero sub-Gaussian random variable $Z$ has a moment generating function that satisfies
+
+$$
+\mathbb { E } ( \exp ( t Z ) ) \le \exp ( t ^ { 2 } C ^ { 2 } )
+$$
+
+for all $t \in \mathbb { R }$ and some constant $C$ . The sub-Gaussian norm of $Z$ , denoted $\| Z \| _ { \psi _ { 2 } }$ is
+
+$$
+\| Z \| _ { \psi _ { 2 } } = \operatorname* { s u p } _ { p \geq 1 } { \frac { 1 } { \sqrt { p } } } \Bigl ( \mathbb { E } | Z | ^ { p } \Bigr ) ^ { 1 / p } .
+$$
+
+If $Z \sim N ( 0 , \sigma ^ { 2 } )$ , then $\| Z \| _ { \psi _ { 2 } } \leq c \sigma$ .
+
+A sub-exponential random variable $X$ satisfies14
+
+$$
+\mathbb { P } \Big ( | X | > t \Big ) \le \exp ( 1 - t / C )
+$$
+
+for all $t \geq 0$ .
+
+Let $\mathbf { \nabla } _ { \mathbf { \boldsymbol { y } } _ { i } }$ denote the $i$ th entry of the vector $\begin{array} { r } { \pmb { y } = \pmb { W } ^ { T } \pmb { z } } \end{array}$ . We can write
+
+$$
+\mathbf { \boldsymbol { y } } _ { i } = \sum _ { j = 1 } ^ { K n } \mathbf { \boldsymbol { W } } _ { i , j } ^ { T } \mathbf { \boldsymbol { z } } _ { j }
+$$
+
+and observe that $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \psi _ { i }$ is a linear combination of i.i.d. sub-Gaussian random variables (or it is identically equal to 0) and, as such, is itself a sub-Gaussian random variable with mean zero and sub-Gaussian√ norm $\| \pmb { y _ { i } } \| _ { \psi _ { 2 } } \le C / \sqrt { M \ell } \| w \| _ { \psi _ { 2 } } \| z \| _ { 2 }$ (see Vershynin (2010), Lemma 5.9). The structure of the random matrix and how many non-zero entries are in row $i$ of $W$ do enter the more refined bound on the sub-Gaussian norm of $\left\| \boldsymbol { y } _ { i } \right\| _ { \psi _ { 2 } }$ (again, see Vershynin (2010), Lemma 5.9 for details) but we ignore such details for this estimate as they are not necessary for the next estimate.
+
+To obtain a concentration bound for $\| \pmb { y } _ { i } \| _ { 2 } ^ { 2 }$ , we recall from Park et al. (2011); Vershynin (2010) that the sum of squares of sub-Gaussian random variables tightly concentrate.
+
+Theorem A.2. Let $Y _ { 1 } , \dots , Y _ { M D }$ be independent sub-Gaussian random variables with sub-Gaussian norms $\| Y _ { i } \| _ { \psi _ { 2 } }$ for all $i = 1 , \ldots , M D$ . Let $T = \operatorname* { m a x } _ { i } \| Y _ { i } \| _ { \psi _ { 2 } }$ . The for every $t \geq 0$ and every a ∈ RMD,
+
+$$
+\mathbb { P } \Bigg ( \Big \vert \sum _ { i = 1 } ^ { M D } \pmb { a } _ { i } ( Y _ { i } - \mathbb { E } Y _ { i } ^ { 2 } ) \Big \vert \geq t \Bigg ) \leq 2 \exp \Bigg ( - C \operatorname* { m i n } \Big ( \frac { C t ^ { 2 } } { T ^ { 2 } \| \pmb { a } \| _ { 2 } ^ { 2 } } , \frac { C t } { T \| \pmb { a } \| _ { \infty } } \Big ) \Bigg ) .
+$$
+
+We note that although some entries $\mathbf { \nabla } _ { \mathbf { \psi } _ { 3 } } \psi _ { i }$ may be identically zero, depending on the sparsity pattern of $_ { z }$ , not all entries are. Let us define $\begin{array} { r } { \tilde { \pmb { y } } _ { i } = \frac { \pmb { y } _ { i } } { \lVert \pmb { y } _ { i } \rVert _ { \psi _ { 2 } } } } \end{array}$ so that $\| \tilde { \pmb y } _ { i } \| _ { \psi _ { 2 } } = 1$ and observe that
+
+$$
+\mathbb { P } \bigg ( \Big | \| \pmb { y } \| _ { 2 } ^ { 2 } - \| \pmb { z } \| _ { 2 } ^ { 2 } \Big | > \delta \| \pmb { z } \| _ { 2 } ^ { 2 } \bigg ) = \mathbb { P } \Bigg ( \Big | \sum _ { i = 1 } ^ { M D } \| \pmb { y } _ { i } \| _ { \psi _ { 2 } } ^ { 2 } \big ( \tilde { \pmb { y } } _ { i } ^ { 2 } - \mathbb { E } \tilde { \pmb { y } } _ { i } ^ { 2 } \big ) \Big | > \delta \| \pmb { z } \| _ { 2 } ^ { 2 } \Bigg ) .
+$$
+
+We apply Theorem A.2 to the sub-Gaussian random variables $\tilde { \mathbf { \ b { y } } } _ { i }$ with the weights $\| \pmb { y } _ { i } \| _ { \psi _ { 2 } } ^ { 2 }$ . We have
+
+$$
+\| \pmb { a } \| _ { 2 } ^ { 2 } = \sum _ { i = 1 } ^ { M D } \| \pmb { y } _ { i } \| _ { \psi _ { 2 } } ^ { 4 } \leq \frac { C D \| w \| _ { \psi _ { 2 } } ^ { 4 } \| \pmb { z } \| _ { 2 } ^ { 4 } } { M \ell ^ { 2 } } \quad \mathrm { a n d } \quad \| \pmb { a } \| _ { \infty } \leq \frac { C \| w \| _ { \psi _ { 2 } } ^ { 2 } \| \pmb { z } \| _ { 2 } ^ { 2 } } { M \ell } .
+$$
+
+If we set $T = 1$ , $t = \delta \| z \| _ { 2 } ^ { 2 }$ , and use the above estimates for the norms of $^ { a }$ , we have
+
+$$
+\mathbb { P } \bigg ( \Big | \| y \| _ { 2 } ^ { 2 } - \| z \| _ { 2 } ^ { 2 } \Big | > \delta \| z \| _ { 2 } ^ { 2 } \bigg ) \leq 2 \exp \bigg ( - C \operatorname* { m i n } \Big ( \frac { C \delta ^ { 2 } M \ell ^ { 2 } } { D \| w \| _ { \psi _ { 2 } } ^ { 4 } } , \frac { C \delta M \ell } { \| w \| _ { \psi _ { 2 } } ^ { 2 } } \Big ) \bigg ) .
+$$
+
+Finally, we use the concentration of measure result in a crude union bound to bound the failure probability over all vectors $z \in \mathcal { M } _ { k }$ . We take $n ^ { k } { \binom { K } { k } } \approx ( n K ) ^ { k }$ and $\epsilon$ for a desired constant failure probability. Using the smaller term in Equation (4), (note that $\delta < 1$ , $\ell / D < 1$ , and $\| w \| _ { \psi _ { 2 } } \geq 1 \qquad $ ) we have
+
+$$
+\exp \Big ( - C \frac { M \ell ^ { 2 } \delta ^ { 2 } } { D \| w \| _ { \psi _ { 2 } } ^ { 4 } } \Big ) \exp \Big ( k ( \log ( K ) + \log ( n ) ) \Big ) \leq \exp ( \log ( \epsilon ) )
+$$
+
+which implies
+
+$$
+\frac { M \ell ^ { 2 } } { D } \geq \frac { k } { \delta ^ { 2 } } \| w \| _ { \psi _ { 2 } } ^ { 4 } \bigg ( \log ( K ) + \log ( n ) - \log ( \epsilon ) \bigg ) = C \frac { k } { \delta ^ { 2 } } \Big ( \log ( K ) + \log ( n ) - \log ( \epsilon ) \Big ) .
+$$
+
+Therefore, if design our matrix $W$ as described and with the parameter relationship as above, the matrix $W ^ { T }$ with satisfy the model-RIP for $\mathcal { M } _ { k }$ and parameter $\delta$ with probability $1 - \epsilon$ . □
+
+Let us discuss the relationship amongst the parameters in our result. First, if we have only one channel $M = 1$ and the filter length $\ell = D$ , then our bound on the number of measurements $D$ matches those of traditional (model-based) compressive sensing; namely,
+
+$$
+D \geq C { \frac { k } { \delta ^ { 2 } } } \left( \log ( K ) + \log ( n ) - \log ( \epsilon ) \right) .
+$$
+
+If $\ell < D$ (i.e., the filters are much shorter than the length of the input signal as in a CNN), then we can compensate by adding more channels; i.e., the filter length $\ell$ needs to be larger than $\sqrt { D }$ , or, if add more channels, $\sqrt { D / M }$ .
+
+# B MATHEMATICAL ANALYSIS: RECONSTRUCTION BOUNDS
+
+The consequences of having model-RIP are two-fold. The first is that if we assume that an input image is the structured sparse linear combination of filters, $\begin{array} { r } { \pmb { x } = \pmb { W } ^ { T } \pmb { z } } \end{array}$ (where $z \in \mathcal { M } _ { k }$ and $\dot { W } ^ { T }$ satisfies the model-RIP property), then we know an upper and lower bound on the norm of $_ { \textbf { \em x } }$ in terms of the norm of its sparse coefficients, $\| \pmb { x } \| _ { 2 } \le ( 1 \pm \bar { \delta } ) \| \geqslant \| _ { 2 }$ . Additionally,
+
+$$
+\| z \| _ { 2 } \leq { \frac { 1 } { \sqrt { 1 - \delta } } } \| x \| _ { 2 } .
+$$
+
+More importantly, when we calculate the hidden units of $_ { \textbf { \em x } }$ ,
+
+$$
+\pmb { h } = \mathrm { R e L U } ( \pmb { W } \pmb { x } ) = \mathrm { R e L U } ( \pmb { W } \pmb { W } ^ { T } \pmb { z } )
+$$
+
+we can see that the computation of $^ { h }$ is nothing other than the first step of a reconstruction algorithm analogous to that of model-based compressed sensing. As a result, we have a bound on the error between $^ { h }$ and $_ { z }$ and we see that we can analyze the approximation properties of a feedfoward CNN and its linear reconstruction algorithm. In particular, we can conclude that a feedforward CNN and a linear reconstruction algorithm provide a good approximation to the original input image.
+
+Theorem 3.3(Restated) We assume that $W ^ { T }$ satisfies the $\mathcal { M } _ { k } ^ { 2 }$ -RIP with constant $\delta _ { k } \le \delta _ { 2 k } < 1$ . If we use $W$ in a single layer CNN both to compute the hidden units $\hat { z }$ and to reconstruct the input $_ { \textbf { \em x } }$ from these hidden units as $\hat { \pmb x }$ so that $\hat { \pmb { x } } = \pmb { W } ^ { \hat { T } } \mathbb { M } ( \pmb { W } \pmb { x } , \boldsymbol { k } )$ , the error in our reconstruction is
+
+$$
+\| \hat { \pmb x } - \pmb x \| _ { 2 } \le \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \frac { \sqrt { 1 + \delta _ { 2 k } } } { \sqrt { 1 - \delta _ { 2 k } } } \| \pmb x \| _ { 2 } .
+$$
+
+Proof. To show this result, we recall the two following lemmas from Baraniuk et al. (2010) and rephrase them in the setting of a feedforward CNN.
+
+Lemma B.1. Suppose $W ^ { T }$ has $\mathcal { M } _ { k }$ -RIP with constant $\delta _ { k }$ . Let $\Omega$ be a support corresponding to a subspace in $\mathcal { M } _ { k }$ . Then we have the following bounds:
+
+$$
+\begin{array} { r } { \| \pmb { W } _ { \Omega } \pmb { x } \| _ { 2 } \le \sqrt { 1 + \delta _ { k } } \| \pmb { x } \| _ { 2 } } \\ { \| \pmb { W } _ { \Omega } \pmb { W } _ { \Omega } ^ { T } \pmb { z } \| _ { 2 } \le ( 1 + \delta _ { k } ) \| \pmb { z } \| _ { 2 } } \\ { \| \pmb { W } _ { \Omega } \pmb { W } _ { \Omega } ^ { T } \pmb { z } \| _ { 2 } \ge ( 1 - \delta _ { k } ) \| \pmb { z } \| _ { 2 } } \end{array}
+$$
+
+Lemma B.2. Suppose that $W ^ { T }$ has $\mathcal { M } _ { k } ^ { 2 }$ -RIP with constant $\delta _ { 2 k }$ . Let $\Omega$ be a support corresponding to a subspace of $\mathcal { M } _ { k }$ and suppose that $\boldsymbol { z } \in \mathcal { M } _ { k }$ (not necessarily supported on $\Omega$ ). Then
+
+$$
+\begin{array} { r } { \| { W _ { \Omega } } { W ^ { T } } { z } | _ { \Omega ^ { c } } \| _ { 2 } \leq \delta _ { 2 k } \| { z } | _ { \Omega ^ { c } } \| _ { 2 } . } \end{array}
+$$
+
+Let $\Pi$ denote the support of the $\mathcal { M } _ { k }$ sparse vector $_ { z }$ . Set $h = W x$ and set $\hat { z }$ to be the result of max pooling applied to the vector $^ { h }$ , or the best fit (with respect to the $\ell _ { 2 }$ norm) to $^ { h }$ in the model $\mathcal { M } _ { k }$ Let $\Omega$ denote the support set of $\hat { z } \in \mathcal { M } _ { k }$ . For simplicity, we assume $| \Pi | = k = | \Omega |$ .
+
+Lemma B.3 (Identification). The support set, $\Omega$ , of the switch units captures a significant fraction of the total energy in the coefficient vector $_ z$
+
+$$
+\| z | _ { \Omega ^ { c } } \| _ { 2 } \leq \frac { 2 \delta _ { 2 k } } { 1 - \delta _ { k } } \| z \| _ { 2 } .
+$$
+
+Proof. Let $h _ { \Omega }$ and $h _ { \mathrm { I I } }$ be the vector $^ { h }$ restricted to the support sets $\Omega$ and $\Pi$ , respectively. Since both are support sets for $\mathcal { M } _ { k }$ and since $\Omega$ is the best support set for $^ { h }$ ,
+
+$$
+\| h - h _ { \Omega } \| _ { 2 } \leq \| h - h _ { \Pi } \| _ { 2 } ,
+$$
+
+and, after several calculations, we have
+
+$$
+\| h | _ { \Omega \backslash \Pi } \| _ { 2 } ^ { 2 } \geq \| h | _ { \Pi \backslash \Omega } \| _ { 2 } ^ { 2 } .
+$$
+
+Using Lemma B.2 and the size $| ( \Omega \setminus \Pi ) \bigcup \Pi | \leq 2 k$ , we have
+
+$$
+\begin{array} { r } { \| h _ { \Omega \setminus \Pi } \| _ { 2 } = \| W _ { \Omega \setminus \Pi } W ^ { T } z \| _ { 2 } \leq \delta _ { 2 k } \| z \| _ { 2 } . } \end{array}
+$$
+
+We can bound the other side of the inequality as
+
+$$
+\begin{array} { r l } & { \| \pmb { h } _ { \Pi \setminus \Omega } \| _ { 2 } \geq \| \pmb { W } _ { \Pi \setminus \Omega } ( \pmb { W } ^ { T } z | _ { \Pi \setminus \Omega } ) \| _ { 2 } - \| \pmb { W } _ { \Pi \setminus \Omega } ( \pmb { W } ^ { T } z | _ { \Omega } ) \| _ { 2 } } \\ & { \qquad \geq ( 1 - \delta _ { k } ) \| z | _ { \Pi \setminus \Omega } \| _ { 2 } - \delta _ { 2 k } \| z | _ { \Omega } \| _ { 2 } . } \end{array}
+$$
+
+Since the support of $_ z$ is the set $\Pi$ $, \Pi \setminus \Omega = \Omega ^ { c }$ and we can conclude that
+
+$$
+\begin{array} { r } { \delta _ { 2 k } \| z \| _ { 2 } \geq ( 1 - \delta _ { k } ) \| z | _ { \Omega ^ { c } } \| _ { 2 } - \delta _ { 2 k } \| z | _ { \Omega } \| _ { 2 } , } \end{array}
+$$
+
+and with some rearrangement, we have
+
+$$
+\| z | _ { \Omega ^ { c } } \| _ { 2 } \leq \frac { 2 \delta _ { 2 k } } { 1 - \delta _ { k } } \| z \| _ { 2 } .
+$$
+
+To set the value of $\hat { z }$ on its support set $\Omega$ , we simply set $\hat { z } = h | _ { \Omega }$ and $\hat { z } | _ { \Omega ^ { c } } = 0$ . Then
+
+Lemma B.4 (Estimation).
+
+$$
+\| z - \hat { z } \| _ { 2 } \leq \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \| z \| _ { 2 }
+$$
+
+Proof. First, note that $\lVert \pmb { I } - \pmb { W } _ { \Omega } \pmb { W } _ { \Omega } ^ { T } \rVert _ { 2 } \leq \delta _ { k }$ since
+
+$$
+( 1 - \delta _ { k } ) \leq \operatorname* { s u p } _ { \| \boldsymbol { z } \| \neq 0 } \frac { \| \boldsymbol { W } _ { \Omega } ^ { T } \boldsymbol { z } \| _ { 2 } ^ { 2 } } { \| \boldsymbol { z } \| _ { 2 } ^ { 2 } } \left( = \sigma _ { \operatorname* { m a x } } ^ { 2 } ( \boldsymbol { W } _ { \Omega } ^ { T } ) = \sigma _ { \operatorname* { m a x } } ( \boldsymbol { W } _ { \Omega } \boldsymbol { W } _ { \Omega } ^ { T } ) \right) \leq ( 1 + \delta _ { k } ) ,
+$$
+
+where $\sigma _ { \mathrm { m a x } }$ is the maximum singular value. Therefore,
+
+$$
+\begin{array} { r l } { \| z - \hat { z } \| _ { 2 } \leq \| z | _ { \Omega ^ { c } } \| _ { 2 } + \| z | _ { \Omega } - \hat { z } | _ { \Omega } \| _ { 2 } } \\ & { \qquad = \| z | _ { \Omega ^ { c } } \| _ { 2 } + \| z | _ { \Omega } - W _ { \Omega } ( W ^ { T } z | _ { \Omega } + W ^ { T } z | _ { \Omega ^ { c } } ) \| _ { 2 } } \\ & { \qquad \leq \| z \| _ { \Omega ^ { c } } \| _ { 2 } + \| ( I - W _ { \Omega } W _ { \Omega } ^ { T } ) z | _ { \Omega } \| _ { 2 } + \| W _ { \Omega } W ^ { T } z | _ { \Omega ^ { c } } \| _ { 2 } } \\ & { \qquad \leq \| z \| _ { \Omega ^ { c } } \| _ { 2 } + \| I - W _ { \Omega } W _ { \Omega } ^ { T } \| _ { 2 } \| z \| _ { \Omega } \| _ { 2 } + \delta _ { 2 k } \| z | _ { \Omega ^ { c } } \| _ { 2 } } \\ & { \qquad \leq \| z | _ { \Omega ^ { c } } \| _ { 2 } + \delta _ { k } \| z | _ { \Omega } \| _ { 2 } + \delta _ { 2 k } \| z \| _ { \Omega ^ { c } } \| _ { 2 } } \\ & { \qquad \leq \Big ( ( 1 + \delta _ { 2 k } ) \frac { 2 \delta _ { 2 k } } { 1 - \delta _ { k } } + \delta _ { k } \Big ) \| z \| _ { 2 } } \\ & { \qquad \leq \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \| z \| _ { 2 } . } \end{array}
+$$
+
+Finally, if we use the autoencoder formulation to reconstruct the original image $_ { \textbf { \em x } }$ by setting ${ \hat { \mathbf { x } } } =$ $W ^ { T } \hat { z }$ , we can estimate the reconstruction error. We note that $\hat { z }$ is $\mathcal { M } _ { k }$ -sparse by construction and remind the reader that $W ^ { T }$ satisfies $\mathcal { M } _ { k } ^ { 2 }$ -model-RIP with constants $\delta _ { k } \le \delta _ { 2 k } \ll 1$ . Then, using Lemma B.4 as well as the $\mathcal { M } _ { k } ^ { 2 }$ -sparse properties of $W ^ { T }$ ,
+
+$$
+\begin{array} { r l } & { \| \boldsymbol { x } - \hat { \boldsymbol { x } } \| _ { 2 } = \| \boldsymbol { W } ^ { T } ( \boldsymbol { z } - \hat { \boldsymbol { z } } ) \| _ { 2 } \leq \sqrt { 1 + \delta _ { 2 k } } \| \boldsymbol { z } - \hat { \boldsymbol { z } } \| _ { 2 } } \\ & { \qquad \leq \displaystyle \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \sqrt { 1 + \delta _ { 2 k } } \| \boldsymbol { z } \| _ { 2 } } \\ & { \qquad \leq \displaystyle \frac { 5 \delta _ { 2 k } } { 1 - \delta _ { k } } \frac { \sqrt { 1 + \delta _ { 2 k } } } { \sqrt { 1 - \delta _ { 2 k } } } \| \boldsymbol { x } \| _ { 2 } . } \end{array}
+$$
+
+This proves that a feedforward CNN with a linear reconstruction algorithm is an approximate autoencoder and bounds the reconstruction error of the input image in terms of the geometric properties of the filters. □
+
+# C MORE EXPERIMENTAL RESULTS
+
+# C.1 MORE DETAILS ON EVALUATION OF CNNS WITH GAUSSIAN RANDOM FILTERS
+
+In this section, we provide more details on the network architectures that we used in Table 1. In particular, we describe the best performing architectures for all cases in Table 5.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>#Layers</td><td rowspan=1 colspan=1>1 layers</td><td rowspan=1 colspan=1>2 layers</td><td rowspan=1 colspan=1>3layers</td></tr><tr><td rowspan=2 colspan=1>Random filters</td><td rowspan=1 colspan=1>Bestparam.</td><td rowspan=1 colspan=1>(2048)5c-2pmax-4pave</td><td rowspan=1 colspan=1>(2048)3c-2pmax-(2048)3c-2pmax-2pave</td><td rowspan=1 colspan=1>(2048)3c-2pmax-(2048)3c-2pmax-(1024)3c-2pmax</td></tr><tr><td rowspan=1 colspan=1>Accuracy</td><td rowspan=1 colspan=1>66.5%</td><td rowspan=1 colspan=1>74.6%</td><td rowspan=1 colspan=1>74.8%</td></tr><tr><td rowspan=1 colspan=1>Learned filters</td><td rowspan=1 colspan=1>Bestparam.</td><td rowspan=1 colspan=1>(1024)5c-2pmax-4pave</td><td rowspan=1 colspan=1>(1024)3c-2pmax-(1024)3c-2pmax-2pave</td><td rowspan=1 colspan=1>(1024)3c-2pmax-(1024)3c-2pmax-(1024)3c-2pmax</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Accuracy</td><td rowspan=1 colspan=1>68.1%</td><td rowspan=1 colspan=1>83.3%</td><td rowspan=1 colspan=1>89.3%</td></tr></table>
+
+Table 5: Best-performing architecture and classification accuracy of random CNNs on CIFAR-10. “ $\mathbf { \bar { \rho } } ( [ \mathbf { n } ] ) [ \mathbf { k } ] \mathbf { c } ^ { \prime }$ denotes a convolution layer with a stride 1, a kernel size [k] and $[ \mathbf { n } ]$ output channels, “ $\mathbf { \hat { \rho } } [ \mathbf { k } ] \mathbf { p } _ { \mathrm { m a x } } \mathbf { \hat { \rho } } ^ { \mathrm { , , } }$ denotes a max pooling layer with a kernel size [k] and a stride [k], and “ $[ \mathbf { k } ] \mathbf { p } _ { \mathrm { a v e } }$ ” denotes a average pooling layer. A typical layer consists of four operations, namely convolution, ReLU, batch normalization, and max pooling.
+
+# C.2 LAYER-WISE COHERENCE AND SPARSITY FOR ALEXNET
+
+We present coherence (see Table 6) and sparsity level (see Table 7) for each layer in AlexNet.   
+
+<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>coherence of learned filters</td><td rowspan=1 colspan=1>0.9172</td><td rowspan=1 colspan=1>0.6643</td><td rowspan=1 colspan=1>0.6200</td><td rowspan=1 colspan=1>0.6382</td><td rowspan=1 colspan=1>0.3390</td></tr><tr><td rowspan=1 colspan=1>coherence of random filters</td><td rowspan=1 colspan=1>0.1996</td><td rowspan=1 colspan=1>0.1263</td><td rowspan=1 colspan=1>0.0929</td><td rowspan=1 colspan=1>0.1073</td><td rowspan=1 colspan=1>0.1026</td></tr></table>
+
+Table 6: Comparison of coherence between learned filters in each layer of AlexNet and Gaussian random filters with corresponding sizes.
+
+Table 7: Layer-wise sparsity of AlexNet on ILSVRC-2012 validation set.   
+
+<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=1>conv1</td><td rowspan=1 colspan=1>pool1</td><td rowspan=1 colspan=1>conv2</td><td rowspan=1 colspan=1>pool2</td><td rowspan=1 colspan=1>conv3</td><td rowspan=1 colspan=1>conv4</td><td rowspan=1 colspan=1>conv5</td><td rowspan=1 colspan=1>pool5</td></tr><tr><td rowspan=1 colspan=1>% of non-zeros</td><td rowspan=1 colspan=1>49.41</td><td rowspan=1 colspan=1>87.79</td><td rowspan=1 colspan=1>18.97</td><td rowspan=1 colspan=1>44.13</td><td rowspan=1 colspan=1>31.08</td><td rowspan=1 colspan=1>30.95</td><td rowspan=1 colspan=1>9.78</td><td rowspan=1 colspan=1>28.15</td></tr></table>
+
+# C.3 VISUALIZATION OF IMAGE RECONSTRUCTION FOR VGGNET
+
+In Figure 5, we show reconstructed images from each layer using different reconstruction methods via a pretrained decoding network.
+
+![](images/0fb08787f047b1f3867e5502fbd4913d09fb911922d33549974279eeab7ad304.jpg)  
+Figure 5: Visualization of images reconstructed by a pretrained decoding network with VGGNet’s pool(4) activation reconstructed using different methods: (a) original image, (b) output of the 5-layer decoding network with original activation, (c) output of the decoding net with reconstructed activation by IHT with learned filters, (d) output of the decoding net with reconstructed activation by IHT with Gaussian random filters, (e) output of the decoding net with Gaussian random activation.

parse/train/HJxdTxHYvB/HJxdTxHYvB.md

@@ -0,0 +1,261 @@
+# BREAKING CERTIFIED DEFENSES: SEMANTIC ADVERSARIAL EXAMPLES WITH SPOOFED ROBUSTNESS CERTIFICATES
+
+Amin Ghiasi ∗, Ali Shafahi∗& Tom Goldstein University of Maryland {amin,ashafahi,tomg}@cs.umd.edu
+
+# ABSTRACT
+
+To deflect adversarial attacks, a range of “certified” classifiers have been proposed. In addition to labeling an image, certified classifiers produce (when possible) a certificate guaranteeing that the input image is not an $\ell _ { p }$ -bounded adversarial example. We present a new attack that exploits not only the labelling function of a classifier, but also the certificate generator. The proposed method applies large perturbations that place images far from a class boundary while maintaining the imperceptibility property of adversarial examples. The proposed “Shadow Attack” causes certifiably robust networks to mislabel an image and simultaneously produce a “spoofed” certificate of robustness.
+
+# 1 INTRODUCTION
+
+Conventional training of neural networks has been shown to produce classifiers that are highly sensitive to adversarial perturbations (Szegedy et al., 2013; Biggio et al., 2013), “natural looking” images that have been manipulated to cause misclassification by a neural network (Figure 1). While a wide range of defenses exist that harden neural networks against such attacks (Madry et al., 2017; Shafahi et al., 2019), defenses based on heuristics and tricks are often easily breakable Athalye et al. (2018). This has motivated work on certifiably secure networks — classifiers that produce a label for an image, and also (when possible) a rigorous guarantee that the input is not adversarially manipulated (Cohen et al., 2019; Zhang et al., 2019b).
+
+![](images/6fc58ab73a4902f4dbbe81e77916649e9c2d1bb3d02936255f50a90ec669d0c1.jpg)  
+Figure 1: All adversarial examples have the goal of fooling classifiers while looking “natural”. Standard attacks limit the $\ell _ { p }$ -norm of the perturbation, while semantic attacks have large $\ell _ { p }$ -norm while still producing natural looking images. Our attack produces large but visually subtle semantic perturbations that not only cause misclassification, but also cause a certified defense to issue a “spoofed” high-confidence certificate. In this case, a certified Gaussian smoothing classifier mislabels the image, and yet issues a certificate with radius 0.24, which is a larger certified radius than its corresponding unmodified ImageNet image which is 0.13.
+
+To date, all work on certifiable defenses has focused on deflecting $\ell _ { p }$ -bounded attacks, where $p = 2$ or $\infty$ (Cohen et al., 2019; Gowal et al., 2018; Wong et al., 2018). After labelling an image, these defenses then check whether there exists an image of a different label within $\epsilon$ units (in the $\ell _ { p }$ metric) of the input, where $\epsilon$ is a security parameter chosen by the user. If the classifier assigns all images within the $\epsilon$ ball the same class label, then a certificate is issued, and the input image known not to be an $\ell _ { p }$ adversarial example.
+
+In this work, we demonstrate how a system that relies on certificates as a measure of label security can be exploited. We present a new class of adversarial examples that target not only the classifier output label, but also the certificate. We do this by adding adversarial perturbations to images that are large in the $\ell _ { p }$ norm (larger than the $\epsilon$ used by the certificate generator), and produce attack images that are surrounded by a large ball exclusively containing images of the same label. The resulting attacks produce a “spoofed” certificate with a seemingly strong security guarantee despite being adversarially manipulated. Note that the statement made by the certificate (i.e., that the input image is not an $\epsilon$ adversarial example in the chosen norm) is still technically correct, however in this case the adversary is hiding behind a certificate to avoid detection by a certifiable defense.
+
+In summary, we consider methods that attack a certified classifier in the following sense:
+
+• Imperceptibility: the adversarial example “looks like” its corresponding natural base example,   
+• Misclassification: the certified classifier assigns an incorrect label to the adversarial example, and   
+• Strongly certified: the certified classifier provides a strong/large-radius certificate for the adversarial example.
+
+While the existence of such an attack does not invalidate the certificates produced by certifiable systems, it should serve as a warning that certifiable defenses are not inherently secure, and one should take caution when relying on certificates as an indicator of label correctness.
+
+# BACKGROUND
+
+In the white-box setting, where the attacker knows the victim’s network and parameters, adversarial perturbation are often constructed using first-order gradient information (Carlini & Wagner, 2017; Kurakin et al., 2016; Moosavi-Dezfooli et al., 2016) or using approximations of the gradient (Uesato et al., 2018; Athalye et al., 2018). The prevailing formulation for crafting attacks uses an additive adversarial perturbation, and perceptibility is minimized using an $\ell _ { p }$ -norm constraint. For example, $\ell _ { \infty }$ -bounded attacks limit how much each pixel can move, while $\ell _ { 0 }$ adversarial attacks limit the number of pixels that can be modified, without limiting the size of the change to each pixel (Wiyatno & Xu, 2018).
+
+It is possible to craft imperceptible attacks without using $\ell _ { p }$ bounds (Brown et al., 2018). For example, Hosseini & Poovendran (2018) use shifting color channels, Wong et al. (2019) use the Wasserstein ball/distance, and Engstrom et al. (2017) use rotation and translation to craft “semantic” adversarial examples. In Figure 1, we produce semantic adversarial examples using the method of Hosseini & Poovendran (2018) which is a greedy approach that transforms the image into HSV space, and then, while keeping V constant, tries to find the smallest S perturbation causing misclassification1. Other variants use generative models to construct natural looking images causing misclassification (Song et al., 2018; Dunn et al., 2019).
+
+In practice, many of the defenses which top adversarial defense leader-board challenges are noncertified defenses (Madry et al., 2017; Zhang et al., 2019a; Shafahi et al., 2019). The majority of these defenses make use of adversarial training, in which attack images are crafted during training and injected into the training set. These non-certified defenses are mostly evaluated against PGDbased attacks, resulting in an upper-bound on robustness.
+
+Certified defenses, on the other-hand, provably make networks resist $\ell _ { p }$ -bounded perturbations of a certain radius. For instance, randomized smoothing (Cohen et al., 2019) is a certifiable defense against $\ell _ { 2 }$ -norm bounded attacks, and CROWN-IBP (Zhang et al., 2019b) is a certifiable defense against $l _ { \infty }$ -norm bounded perturbations. Both of these defenses produce a class label, and also a guarantee that the image could not have been crafted by making small perturbations to an image of a different label. Certified defenses can also benefit from adversarial training. For example, Salman et al. (2019) recently improved the certified radii of randomized smoothing (Cohen et al., 2019) by training on adversarial examples generated for the smoothed classifier.
+
+To the best of our knowledge, prior works have focused on making adversarial examples that satisfy the imperceptibility and misclassification conditions, but none have investigated manipulating certificates, which is our focus here.
+
+The reminder of this paper is organized as follows. In section 2 we introduce our new approach Shadow Attack for generating adversarial perturbations. This is a hybrid model that allows various kinds of attacks to be compounded together, resulting in perturbations of large radii. In section 3 we present an attack on “randomized smoothing” certificates (Cohen et al., 2019). Section 4 shows an ablation study which illustrates why the elements of the Shadow Attack are important for successfully manipulating certified models. In section 5 we generate adversarial examples for “CROWN-IBP” (Zhang et al., 2019b). Finally, we discuss results and wrap up in section 6.
+
+# 2 THE SHADOW ATTACK
+
+Because certificate spoofing requires large perturbations (larger than the $\ell _ { p }$ ball of the certificate), we propose a simple attack that ensembles numerous modes to create large perturbations. Our attack can be seen as the generalization of the well-known PGD attack, which creates adversarial images by modifying a clean base image. Given a loss function $L$ and an $\ell _ { p }$ -norm bound $\epsilon$ for some $p \geq 0$ , PGD attacks solve the following optimization problem:
+
+$$
+\operatorname* { m a x } _ { \delta } L ( \theta , x + \delta )
+$$
+
+$$
+s . t . \parallel \delta \parallel _ { p } \leq \epsilon ,
+$$
+
+where $\theta$ are the network parameters and $\delta$ is the adversarial perturbation to be added to the clean input image $x$ . Constraint 2 promotes imperceptibility of the resulting perturbation to the human eye by limiting the perturbation size. In the shadow attack, instead of solving the above constrained optimization problem, we solve the following problem with a range of penalties:
+
+$$
+\operatorname* { m a x } _ { \delta } L ( \theta , x + \delta ) - \lambda _ { c } C ( \delta ) - \lambda _ { t v } T V ( \delta ) - \lambda _ { s } D i s s i m ( \delta ) ,
+$$
+
+where $\lambda _ { c } , \lambda _ { t v } , \lambda _ { s }$ are scalar penalty weights. Penalty $T V ( \delta )$ forces the perturbation $\delta$ to have small total variation $( T V )$ , and so appear more smooth and natural. Penalty $C ( \delta )$ limits the perturbation $\delta$ globally by constraining the change in the mean of each color channel $c$ . This constraint is needed since total variation is invariant to constant/scalar additions to each color channel, and it is desirable to suppress extreme changes in the color balances of images.
+
+Penalty $D i s s i m ( \delta )$ promotes perturbations $\delta$ that assume similar values in each color channel. In the case of an RGB image of shape $3 \times W \times H$ , if $D i s s i m ( \delta )$ is small, the perturbations to red, green, and blue channels are similar, i.e., $\delta _ { R , w , h } \approx \delta _ { G , w , h } \approx \delta _ { B , w , h } , \forall ( w , h ) \in W \times H$ . This amounts to making the pixels darker/lighter, without changing the color balance of the image. Later, in section 3, we suggest two ways of enforcing such similarity between RGB channels and we find both of them effective:
+
+• 1-channel attack strictly enforces $\delta _ { R , i } \approx \delta _ { G , i } \approx \delta _ { B , i } , \forall i$ by using just one array to simultaneously represent each color channel $\delta _ { W \times H }$ . On the forward pass, we duplicate $\delta$ to make a 3-channel image. In this case, $D i s s i m ( \delta ) = 0$ , and the perturbation is greyscale. • 3-channel attack uses a 3-channel perturbation $\delta _ { 3 \times W \times H }$ , along with the dissimilarity metric $D i s s i m ( \delta ) = \| \delta _ { R } - \delta _ { B } \| _ { p } + \| \delta _ { R } - \delta _ { G } \| _ { p } + \| \delta _ { B } - \delta _ { G } \| _ { p }$ .
+
+All together, the three penalties minimize perceptibility of perturbations by forcing them to be $( a )$ small, $( b )$ smooth, and $( c )$ without dramatic color changes (e.g. swapping blue to red). At the same time, these penalties allow perturbations that are very large in $\ell _ { p }$ -norm.
+
+# 2.1 CREATING UNTARGETED ATTACKS
+
+We focus on spoofing certificates for untargeted attacks, in which the attacker does not specify the class into which the attack image moves. To achieve this, we generate an adversarial perturbation for all possible wrong classes $\bar { y }$ and choose the best one as our strong attack:
+
+$$
+\operatorname* { m a x } _ { \bar { y } \neq y , \delta } - L ( \theta , x + \delta \| \bar { y } ) - \lambda _ { c } C ( \delta ) - \lambda _ { t v } T V ( \delta ) - \lambda _ { s } D i s s i m ( \delta )
+$$
+
+where $y$ is the true label/class for the clean image $x$ , and $L$ is a spoofing loss that promotes a strong certificate. We examine different choices for $L$ for different certificates below.
+
+# 3 ATTACKS ON RANDOMIZED SMOOTHING
+
+The Randomized Smoothing method, first proposed by Lecuyer et al. (2018) and later improved by Li et al. (2018), is an adversarial defense against $\ell _ { 2 }$ -norm bounded attacks. Cohen et al. (2019) prove a tight robustness guarantee under the $\ell _ { 2 }$ norm for smoothing with Gaussian noise. Their study was the first certifiable defense for the ImageNet dataset (Deng et al., 2009). The method constructs certificates by first creating many copies of an input image contaminated with random Gaussian noise of standard deviation $\sigma$ . Then, it uses a base classifier (a neural net) to make a prediction for all of the images in the randomly augmented batch. Depending on the level of the consensus of the class labels at these random images, a certified radius is calculated that can be at most $4 \sigma$ (in the case of perfect consensus).
+
+Intuitively, if the image is far away from the decision boundary, the base classifier should predict the same label for each noisy copy of the test image, in which case the certificate is strong. On the other hand, if the image is adjacent to the decision boundary, the base classifier’s predictions for the Gaussian augmented copies may vary. If the variation is large, the smoothed classifier abstains from making a prediction.
+
+To spoof strong certificates (large certified radius) for an incorrect class, we must make sure that the majority of a batch of noisy images around the adversarial image are assigned the same (wrong) label. We do this by minimizing the cross entropy loss relative to a chosen (incorrect) label, averaged over a large set of randomly perturbed images. To this end, we minimize equation 4, where $L$ is chosen to be the average cross-entropy over a batch of Gaussian perturbed copies. This method is analogous to the technique presented by Shafahi et al. (2018) for generating universal perturbations that are effective when added to a large number of different images.
+
+# RESULTS
+
+Cohen et al. (2019) show the performance of the Gaussian smoothed classifier on CIFAR-10 (Krizhevsky et al.) and ImageNet (Deng et al., 2009). To attack the CIFAR-10 and ImageNet smoothed classifiers, we use 400 randomly sampled Gaussian images, $\lambda _ { t v } = 0 . 3$ , $\lambda _ { c } = 1 . 0$ , and perform 300 steps of SGD with learning rate 0.1. We choose the functional regularizers $C ( \delta )$ and $T V ( \delta )$ to be
+
+$$
+C ( \delta ) = \| \operatorname { A v g } ( | \delta _ { R } | ) , \operatorname { A v g } ( | \delta _ { G } | ) , \operatorname { A v g } ( | \delta _ { B } | ) \| _ { 2 } ^ { 2 } , \quad \mathrm { a n d } \quad T V ( \delta _ { i , j } ) = \mathrm { a n i s o t r o p i c - T V } ( \delta _ { i , j } ) ^ { 2 } ,
+$$
+
+where $| \cdot |$ is the element-wise absolute value operator, and Avg computes the average. For the Dissim regularizer, we experiment with both the 1-Channel attack that ensures $D i s s i m ( \delta ) = 0$ , and the 3-Channel attack by setting $D i s s i m ( \delta ) \ : = \ : \lVert ( \delta _ { R } - \delta _ { G } ) ^ { 2 } , ( \delta _ { R } - \delta _ { B } ) ^ { 2 } , ( \delta _ { G } - \delta _ { B } ) ^ { 2 } \rVert _ { 2 }$ and $\lambda _ { s } ~ = ~ 0 . 5$ . For the validation examples on which the smoothed classifier does not abstain (see Cohen et al. (2019) for more details), the less-constrained 3-channel attack is always able to find an adversarial example while the 1-channel attack also performs well, achieving $9 8 . 5 \%$ success. 2 In section 4 we will discuss in more detail other differences between 1-channel and 3-channel attacks. The results are summarized in Table 1. For the various base-models and choices of $\sigma$ , our adversarial examples are able to produce certified radii that are on average larger than the certified radii produced for natural images. For ImageNet, since attacking all 999 remaining target classes is computationally expensive, we only attacked target class IDs 100, 200, 300, 400, 500, 600, 700, 800, 900, and 1000.
+
+Table 1: Certified radii produced by the Randomized Smoothing method for Shadow Attack images and also natural images (larger radii means a stronger/more confident certificate).   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">g(l2)</td><td colspan="2">Unmodified/Natural Images</td><td colspan="2">Shadow Attack</td></tr><tr><td>Mean</td><td>STD</td><td>Mean</td><td>STD</td></tr><tr><td rowspan="4">CIFAR-10</td><td>0.12</td><td>0.14</td><td>0.056</td><td>0.22</td><td>0.005</td></tr><tr><td>0.25</td><td>0.30</td><td>0.111</td><td>0.35</td><td>0.062</td></tr><tr><td>0.50</td><td>0.47</td><td>0.234</td><td>0.65</td><td>0.14</td></tr><tr><td>1.00</td><td>0.78</td><td>0.556</td><td>0.85</td><td>0.442</td></tr><tr><td rowspan="3">ImageNet</td><td>0.25</td><td>0.30</td><td>0.109</td><td>0.31</td><td>0.109</td></tr><tr><td>0.50</td><td>0.61</td><td>0.217</td><td>0.38</td><td>0.191</td></tr><tr><td>1.00</td><td>1.04</td><td>0.519</td><td>0.64</td><td>0.322</td></tr></table>
+
+![](images/fc84d5db0b10201ae1b67b97307b4ea040d8acf621a920e268218446d3dd9330.jpg)  
+Figure 2: An adversarial example built using our Shadow Attack for the smoothed ImageNet classifier for which the certifiable classifier produces a large certified radii. The adversarial perturbation is smooth and natural looking even-though it is large when measured using $\ell _ { p }$ -metrics. Also see Figure 16 in the appendix.
+
+Figure 2 depicts a sample adversarial example built for the smoothed ImageNet classifier that produces a strong certificate. The adversarial perturbation causes the batch of Gaussian augmented black swan images to get misclassified as hooks. For more, see appendix 16.
+
+# 4 ABLATION STUDY OF THE ATTACK PARAMETERS
+
+In this section we perform an ablation study on the parameters of the Shadow Attack to evaluate $( i )$ the number of SGD steps needed, $( i i )$ the importance of $\lambda _ { s }$ (or alternatively using 1-channel attacks), and $( i i i )$ the effect of $\lambda _ { t v }$ .
+
+The default parameters for all of the experiments are as follows unless explicitly mentioned: We use 30 SGD steps with learning rate 0.1 for the optimization. All experiments except part $( i i )$ use 1-channel attacks for the sake of simplicity and efficiency (since it has less parameters). We assume $\lambda _ { t v } = 0 . 3$ , $\lambda _ { c } = 2 0$ , and use batch-size 50. We present results using the first example from each class of the CIFAR-10 validation set.
+
+Figure 3 shows how the adversarial example evolves during the first few steps of optimization (See appendix 13 for more examples). Also, figures 4, 5, and 6 show the evolution of $L ( \delta )$ , $T V ( \delta )$ , and $\bar { C } \bar { ( \delta ) }$ , respectively (Note that we use 1-channel attacks, so $D i s s i m ( \delta )$ is always 0). We find that taking just 10 SGD steps is enough for convergence on CIFAR-10, but for our main results (i.e. attacking Randomized Smoothing in section 3 and attacking CROWN-IBP in section 5) we take 300 steps to be safe.
+
+![](images/06896354aa897e71ad464ff338e02180acd639c0b924e325783b1c8a3dd998c9.jpg)  
+Figure 3: The first 10 steps of optimization (beginning with a randomly perturbed image copy).
+
+![](images/5f654668f167ce857cd1a65e3dc06a5d881a1b575148684fe8485fe507e774e1.jpg)  
+Figure 9: Histogram of randomized smoothed certificate radii for 100 randomly sampled CIFAR-10 validation images vs those calculated for their adversarial examples crafted using our 1-channel and 3- channel adversarial Shadow Attack attacks. The “robust” victim classifier is based off Resnet-110, and smoothed with $\sigma = 0 . 5 0$ . 1-channel attacks are almost as good as the less-restricted 3-channel attacks.
+
+![](images/20b0585db38a51f88ba2fe2f975e26e2664bfa056c241232db33209383603542.jpg)  
+Figure 4: Average $L _ { b } ( \delta )$ in the first 10 steps.
+
+![](images/ed8360582f6789035034591491c8a59e60b1f7bc6ce16b046db67da3396effda.jpg)  
+Figure 5: Average $T V ( \delta )$ in the first 10 steps.
+
+![](images/576f9a7e05690dbed7eec18b645131799913a3615487705255f0af1050b0a5c1.jpg)  
+Figure 6: Average $C ( \delta )$ in the first 10 steps.
+
+![](images/b5ff85f3e580e8529c53fc20bcba81dced2826ca740797c4b30175693434a25e.jpg)  
+Figure 7: The effect of $\lambda _ { s }$ on the resulting $D i s s i m ( \delta )$
+
+![](images/93f51feafa913752183e135ca6c9eafcae0039af6dd29556964c39fb39596c1f.jpg)  
+Figure 8: The effect of $\lambda _ { t v }$ on the resulting $T V ( \delta )$
+
+![](images/c034ce0f1c1431c9a7df409bb4d212480ccfe1b9e8bfc31a043b7d0611506a50.jpg)  
+Figure 10: The visual effect of Shadow Attack on 9 randomly selected CIFAR-10 examples using 1-Channel and 3-Channel attacks.
+
+![](images/be81020d44f96313e583d56feed9be268ca6c3615f7d1bd1f81f132998bc4e03.jpg)  
+Figure 11: The visual effect of $\lambda _ { s }$ on perceptibility of the perturbations. The first row shows the value of $\lambda _ { s }$ .
+
+Also, figure 7 shows the mean $D i s s i m ( \delta )$ for different values of $\lambda _ { s } ( 0 \leq \lambda _ { s } \leq 5 . 0 )$ . We also plot the histogram of the certificate radii in figure 9. Figure 10 compares 1-Channel vs 3-Channel attacks for some of randomly selected CIFAR-10 images. Finally, we explore the effect of $\lambda _ { t v }$ on imperceptibility of the perturbations in Figure 12. See table 15 for more images, and figure 8 for the impact of parameters on $T V ( \delta )$ .
+
+# 5 ATTACKS ON CROWN-IBP
+
+Interval Bound Propagation (IBP) methods have been recently studied as a defense against $\ell _ { \infty }$ - bounded attacks. Many recent studies such as Gowal et al. (2018); Xiao et al. (2018); Wong et al. (2018); Mirman et al. (2018) have investigated IBP methods to train provably robust networks. To the best of our knowledge, the CROWN-IBP method by Zhang et al. (2019b) achieves state-ofthe-art performance for MNIST (LeCun & Cortes, 2010), Fashion-MNIST (Xiao et al., 2017), and CIFAR-10 datasets among certifiable $\ell _ { \infty }$ defenses. In this section we focus on attacking Zhang et al. (2019b) using CIFAR-10.
+
+IBP methods (over)estimate how much a small $\ell _ { \infty }$ -bounded noise in the input can impact the classification layer. This is done by propagating errors from layer to layer, computing bounds on the maximum possible perturbation to each activation. During testing, the user chooses an $\ell _ { \infty }$ perturbation bound $\epsilon$ , and error propagation is used to bound the magnitude of the largest achievable perturbation in network output. If the output perturbation is not large enough to flip the image label, then a certificate is produced. If the output perturbation is large enough to flip the image label, then a certificate is not produced. During network training, IBP methods include a term in the loss function that promotes tight error bounds that result in certificates. Our attack directly uses the loss function term used during IBP network training in addition to the Shadow Attack penalties; we search for an image that is visually similar to the base image, while producing a bound on the output perturbation that is too small to flip the image label. Note that there is a subtle difference between crafting conventional adversarial examples which ultimately targets misclassification and our adversarial examples which aim to produce adversarial examples which cause misclassification and produce strong certificates. In the former case, we only need to attack the cross-entropy loss. If we use our Shadow Attack to craft adversarial examples based on the cross-entropy loss, the robustness errors are on average roughly $50 \%$ larger than those reported in table 2 (i.e., simple adversarial examples produce weaker certificates.)
+
+![](images/fd183f30a6c50eaea65e9d318bc4cea9dd52bf2d2a0b4f40f9d6a92c659a448c.jpg)  
+Figure 12: The visual effect of $\lambda _ { t v }$ on the on imperceptibility of the perturbations. The first row shows the value of $\lambda _ { t v }$
+
+Table 2: “Robust error” for natural images, and “attack error” for Shadow Attack images using the CIFAR-10 dataset, and CROWN-IBP models. Smaller is better.   
+
+<table><tr><td rowspan="2">∈(lo）</td><td rowspan="2">Model Family</td><td rowspan="2">Method</td><td colspan="3">Robustness Errors</td></tr><tr><td>Min</td><td>Mean</td><td>Max</td></tr><tr><td rowspan="4">2/255</td><td rowspan="2">9 small models</td><td>CROWN-IPB</td><td>52.46</td><td>57.55</td><td>60.67</td></tr><tr><td>Shadow Attack</td><td>45.90</td><td>53.89</td><td>65.74</td></tr><tr><td rowspan="2">8 large models</td><td>CROWN-IBP</td><td>52.52</td><td>53.9</td><td>56.05</td></tr><tr><td>Shadow Attack</td><td>46.21</td><td>49.77</td><td>51.79</td></tr><tr><td rowspan="4">8/255</td><td rowspan="2">9 small models</td><td>CROWN-IBP</td><td>71.28</td><td>72.15</td><td>73.66</td></tr><tr><td>Shadow Attack</td><td>63.43</td><td>66.94</td><td>71.02</td></tr><tr><td rowspan="2">8 large models</td><td>CROWN-IBP</td><td>70.79</td><td>71.17</td><td>72.29</td></tr><tr><td>Shadow Attack</td><td>64.04</td><td>67.32</td><td>71.16</td></tr></table>
+
+We attack 4 classes of networks released by Zhang et al. (2019b) for CIFAR-10. There are two classes of IBP architectures, one of them consists of 9 small models and the other consists of 8 larger models. For each class of architecture, there are two sets of pre-trained models: one for $\epsilon = 2 / 2 5 5$ and one for $\epsilon = 8 / 2 5 5$ . We use $\lambda _ { t v } = 0 . 0 0 0 0 0 9$ , $\lambda _ { c } = 0 . 0 2$ , $C ( \delta ) = \| \delta \| _ { 2 }$ and set the learning rate to 200 and for the rest of the regularizers and hyper-paramters we use the same hyperparameters and regularizers as in 3. For the sake of efficiency, we only do 1-channel attacks. We attack the 4 classes of models and for each class, we report the min, mean, and max of the robustness errors and compare them with those of the CROWN-IBP paper.
+
+To quantify the success of our attack, we define two metrics of error. For natural images, we report the rate of “robust errors,” which are images that are either (i) incorrectly labeled, or (ii) correctly labelled but without a certificate. In contrast, for attack images, we report the rate of “attack errors,” which are either (i) correctly classified or (ii) incorrectly classified but without a certificate. Table 2 shows the robust error on natural images, and the attack error on Shadow Attack images for the CROWN-IBP models. With $\epsilon = 2 / 2 5 \bar { 5 }$ , our attack finds adversarial examples that certify roughly $15 \%$ of the time (i.e., attack error ${ < } 8 5 \%$ ). With $\epsilon = 8 / 2 5 5$ , our attack finds adversarial examples that are incorrectly classified, and yet certify even more often than natural images.
+
+# 6 CONCLUSION
+
+We demonstrate that it is possible to produce adversarial examples with “spoofed” certified robustness by using large-norm perturbations. Our adversarial examples are built using our Shadow Attack that produces smooth and natural looking perturbations that are often less perceptible than those of the commonly used $\ell _ { p }$ -bounded perturbations, while being large enough in norm to escape the certification regions of state of the art principled defenses. This work suggests that the certificates produced by certifiably robust classifiers, while mathematically rigorous, are not always good indicators of robustness or accuracy.
+
+Acknowledgements: Goldstein and his students were supported by the DARPA QED for RML program, the DARPA GARD program, and the National Science Foundation.
+
+# REFERENCES
+
+Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018.
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pp. 387–402. Springer, 2013.
+
+Tom B Brown, Nicholas Carlini, Chiyuan Zhang, Catherine Olsson, Paul Christiano, and Ian Goodfellow. Unrestricted adversarial examples. arXiv preprint arXiv:1809.08352, 2018.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 3–14. ACM, 2017.
+
+Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019.
+
+J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009.
+
+Isaac Dunn, Tom Melham, and Daniel Kroening. Generating realistic unrestricted adversarial inputs using dual-objective gan training. arXiv preprint arXiv:1905.02463, 2019.
+
+Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017.
+
+Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018.
+
+Hossein Hosseini and Radha Poovendran. Semantic adversarial examples. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1614–1619, 2018.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/˜kriz/cifar.html.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Cassidy Laidlaw and Soheil Feizi. Functional adversarial attacks. arXiv preprint arXiv:1906.00001, 2019.
+
+Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.
+
+Mathias Lecuyer, Vaggelis Atlidakis, Roxana Geambasu, Daniel Hsu, and Suman Jana. Certified robustness to adversarial examples with differential privacy. arXiv preprint arXiv:1802.03471, 2018.
+
+Bai Li, Changyou Chen, Wenlin Wang, and Lawrence Carin. Second-order adversarial attack and certifiable robustness. CoRR, abs/1809.03113, 2018. URL http://arxiv.org/abs/ 1809.03113.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016.
+
+Hadi Salman, Greg Yang, Jerry Li, Pengchuan Zhang, Huan Zhang, Ilya Razenshteyn, and Sebastien Bubeck. Provably robust deep learning via adversarially trained smoothed classifiers. arXiv preprint arXiv:1906.04584, 2019.
+
+Ali Shafahi, Mahyar Najibi, Zheng Xu, John Dickerson, Larry S Davis, and Tom Goldstein. Universal adversarial training. arXiv preprint arXiv:1811.11304, 2018.
+
+Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019.
+
+Yang Song, Rui Shu, Nate Kushman, and Stefano Ermon. Constructing unrestricted adversarial examples with generative models. In Advances in Neural Information Processing Systems, pp. 8312–8323, 2018.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018.
+
+Rey Wiyatno and Anqi Xu. Maximal jacobian-based saliency map attack. arXiv preprint arXiv:1808.07945, 2018.
+
+Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, pp. 8400–8409, 2018.
+
+Eric Wong, Frank R Schmidt, and J Zico Kolter. Wasserstein adversarial examples via projected sinkhorn iterations. arXiv preprint arXiv:1902.07906, 2019.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. arXiv preprint arXiv:1809.03008, 2018.
+
+Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. arXiv preprint arXiv:1901.08573, 2019a.
+
+Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. arXiv preprint arXiv:1906.06316, 2019b.
+
+# A APPENDIX
+
+In this section, we include the complete results of our ablation study. As we mentioned in section 4, we use is a subset of CIFAR-10 dataset, including one example per each class. For the sake of simplicity, we call the dataset Tiny-CIFAR-10. Here, we show the complete results for the ablation experiments on all of Tiny-CIFAR-10 examples. Figure 13 shows that taking a few optimization steps is enough for the resulting images to look natural-looking. Figure 14 and 15, respectively show the effect of $\lambda _ { s }$ and $\lambda _ { T V }$ on the imperceptability of the perturbations.
+
+![](images/4e318ad399b6a9920a96865cfafefb95dac1dea8697d18cc2132b9c8528c042f.jpg)  
+Figure 13: The first 10 steps of the optimization vs the original image for Tiny-CIFAR-10. See section 4 for the details of the experiments.
+
+![](images/a7083b05ac85595444ad846253e87552a5cc66b4751f9f7fd1ce2f15682e8328.jpg)  
+Figure 14: The visual effect of $\lambda _ { s }$ on $D i s s i m ( \delta )$ on Tiny-CIFAR-10. See section 4 for the details of the experiments.
+
+![](images/773cfd90ee4f02cda6951516af5243e28356f25270610bb6923ea3c4d053ae6f.jpg)  
+Figure 15: The visual effect of $\lambda _ { t v }$ on the perturbation Tiny-CIFAR-10. See section 4 for the details of the experiments.
+
+Table 3: Certified radii statistics produced by the Adversarially Trained Randomized Smoothing method for our adversarial examples crafted using Shadow Attack and the natural examples (larger radii are better).   
+
+<table><tr><td>Dataset</td><td>σ(l2)</td><td>Adversarially Trained Randomized Smoothed Mean</td><td>STD</td><td>Shadow Attack Mean</td><td>STD</td></tr><tr><td>CIFAR-10</td><td>0.5</td><td>0.60</td><td>0.34</td><td>0.65</td><td>0.16</td></tr></table>
+
+# IMAGENET RESULTS
+
+Many of the recent studies have explored the semantic attacks. Semantic attacks are powerful for attacking defenses (Engstrom et al., 2017; Hosseini & Poovendran, 2018; Laidlaw & Feizi, 2019). Many of semantic attacks are applicable to Imagenet, however, none of them consider increasing the radii of the certificates generated by the certifiable defenses.
+
+Some other works focus on using generative models to generate adversarial examples (Song et al., 2018), but unfortunately none of the GAN’s are expressive enough to capture the manifold of the ImageNet.
+
+Figure 16 illustrates some of our successful examples generated by Shadow Attack to attack Randomized Smoothed classifiers for ImageNet.
+
+# B CERTIFICATE SPOOFING ATTACKS ON ADVERSARIALLY TRAINED SMOOTH CLASSIFIERS
+
+Recently, Salman et al. (2019) significantly improved the robustness of Gaussian smoothed classifiers by generating adversarial examples for the smoothed classifier and training on them. In this section, we use our Shadow Attack to generate adversarial examples using the loss in eq. 4 for the SmoothAdv classifier 4. Due to computation limitations, we attack a sample of $40 \%$ of the same validation images used for evaluating the randomized smooth classifier in section 3. The results are summarized in table 3. Comparing the results of table 1 to table 3, we can see that the SmoothAdv classifier, does produce stronger certified radii for natural examples (many of the examples in fact have the maximum radii) compared to the original randomized smoothing classifier. This can be associate to the excessive invariance introduced as a result of adversarial training. However, table 3 empirically verifies that its certificates are still subject to attacks and the certificate should not be used as a measure for robustness.
+
+![](images/321bee1545259a95016ff53f96cd726ebe40301a2e72b8985b88bb656579a4a7.jpg)  
+Figure 16: Natural looking Imperceptible ImageNet adversarial images which produce large certified radii for the ImageNet Gaussian smoothed classifier.

parse/train/HJxdTxHYvB/HJxdTxHYvB_content_list.json

@@ -0,0 +1,1382 @@
+[
+    {
+        "type": "text",
+        "text": "BREAKING CERTIFIED DEFENSES: SEMANTIC ADVERSARIAL EXAMPLES WITH SPOOFED ROBUSTNESS CERTIFICATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Amin Ghiasi ∗, Ali Shafahi∗& Tom Goldstein University of Maryland {amin,ashafahi,tomg}@cs.umd.edu ",
+        "bbox": [
+            183,
+            195,
+            488,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            273,
+            544,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To deflect adversarial attacks, a range of “certified” classifiers have been proposed. In addition to labeling an image, certified classifiers produce (when possible) a certificate guaranteeing that the input image is not an $\\ell _ { p }$ -bounded adversarial example. We present a new attack that exploits not only the labelling function of a classifier, but also the certificate generator. The proposed method applies large perturbations that place images far from a class boundary while maintaining the imperceptibility property of adversarial examples. The proposed “Shadow Attack” causes certifiably robust networks to mislabel an image and simultaneously produce a “spoofed” certificate of robustness. ",
+        "bbox": [
+            233,
+            306,
+            764,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            457,
+            336,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conventional training of neural networks has been shown to produce classifiers that are highly sensitive to adversarial perturbations (Szegedy et al., 2013; Biggio et al., 2013), “natural looking” images that have been manipulated to cause misclassification by a neural network (Figure 1). While a wide range of defenses exist that harden neural networks against such attacks (Madry et al., 2017; Shafahi et al., 2019), defenses based on heuristics and tricks are often easily breakable Athalye et al. (2018). This has motivated work on certifiably secure networks — classifiers that produce a label for an image, and also (when possible) a rigorous guarantee that the input is not adversarially manipulated (Cohen et al., 2019; Zhang et al., 2019b). ",
+        "bbox": [
+            173,
+            488,
+            825,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fc58ab73a4902f4dbbe81e77916649e9c2d1bb3d02936255f50a90ec669d0c1.jpg",
+        "image_caption": [
+            "Figure 1: All adversarial examples have the goal of fooling classifiers while looking “natural”. Standard attacks limit the $\\ell _ { p }$ -norm of the perturbation, while semantic attacks have large $\\ell _ { p }$ -norm while still producing natural looking images. Our attack produces large but visually subtle semantic perturbations that not only cause misclassification, but also cause a certified defense to issue a “spoofed” high-confidence certificate. In this case, a certified Gaussian smoothing classifier mislabels the image, and yet issues a certificate with radius 0.24, which is a larger certified radius than its corresponding unmodified ImageNet image which is 0.13. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            621,
+            818,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To date, all work on certifiable defenses has focused on deflecting $\\ell _ { p }$ -bounded attacks, where $p = 2$ or $\\infty$ (Cohen et al., 2019; Gowal et al., 2018; Wong et al., 2018). After labelling an image, these defenses then check whether there exists an image of a different label within $\\epsilon$ units (in the $\\ell _ { p }$ metric) of the input, where $\\epsilon$ is a security parameter chosen by the user. If the classifier assigns all images within the $\\epsilon$ ball the same class label, then a certificate is issued, and the input image known not to be an $\\ell _ { p }$ adversarial example. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we demonstrate how a system that relies on certificates as a measure of label security can be exploited. We present a new class of adversarial examples that target not only the classifier output label, but also the certificate. We do this by adding adversarial perturbations to images that are large in the $\\ell _ { p }$ norm (larger than the $\\epsilon$ used by the certificate generator), and produce attack images that are surrounded by a large ball exclusively containing images of the same label. The resulting attacks produce a “spoofed” certificate with a seemingly strong security guarantee despite being adversarially manipulated. Note that the statement made by the certificate (i.e., that the input image is not an $\\epsilon$ adversarial example in the chosen norm) is still technically correct, however in this case the adversary is hiding behind a certificate to avoid detection by a certifiable defense. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, we consider methods that attack a certified classifier in the following sense: ",
+        "bbox": [
+            169,
+            325,
+            753,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Imperceptibility: the adversarial example “looks like” its corresponding natural base example,   \n• Misclassification: the certified classifier assigns an incorrect label to the adversarial example, and   \n• Strongly certified: the certified classifier provides a strong/large-radius certificate for the adversarial example. ",
+        "bbox": [
+            215,
+            352,
+            825,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "While the existence of such an attack does not invalidate the certificates produced by certifiable systems, it should serve as a warning that certifiable defenses are not inherently secure, and one should take caution when relying on certificates as an indicator of label correctness. ",
+        "bbox": [
+            176,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            276,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the white-box setting, where the attacker knows the victim’s network and parameters, adversarial perturbation are often constructed using first-order gradient information (Carlini & Wagner, 2017; Kurakin et al., 2016; Moosavi-Dezfooli et al., 2016) or using approximations of the gradient (Uesato et al., 2018; Athalye et al., 2018). The prevailing formulation for crafting attacks uses an additive adversarial perturbation, and perceptibility is minimized using an $\\ell _ { p }$ -norm constraint. For example, $\\ell _ { \\infty }$ -bounded attacks limit how much each pixel can move, while $\\ell _ { 0 }$ adversarial attacks limit the number of pixels that can be modified, without limiting the size of the change to each pixel (Wiyatno & Xu, 2018). ",
+        "bbox": [
+            174,
+            544,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It is possible to craft imperceptible attacks without using $\\ell _ { p }$ bounds (Brown et al., 2018). For example, Hosseini & Poovendran (2018) use shifting color channels, Wong et al. (2019) use the Wasserstein ball/distance, and Engstrom et al. (2017) use rotation and translation to craft “semantic” adversarial examples. In Figure 1, we produce semantic adversarial examples using the method of Hosseini & Poovendran (2018) which is a greedy approach that transforms the image into HSV space, and then, while keeping V constant, tries to find the smallest S perturbation causing misclassification1. Other variants use generative models to construct natural looking images causing misclassification (Song et al., 2018; Dunn et al., 2019). ",
+        "bbox": [
+            174,
+            661,
+            825,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In practice, many of the defenses which top adversarial defense leader-board challenges are noncertified defenses (Madry et al., 2017; Zhang et al., 2019a; Shafahi et al., 2019). The majority of these defenses make use of adversarial training, in which attack images are crafted during training and injected into the training set. These non-certified defenses are mostly evaluated against PGDbased attacks, resulting in an upper-bound on robustness. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Certified defenses, on the other-hand, provably make networks resist $\\ell _ { p }$ -bounded perturbations of a certain radius. For instance, randomized smoothing (Cohen et al., 2019) is a certifiable defense against $\\ell _ { 2 }$ -norm bounded attacks, and CROWN-IBP (Zhang et al., 2019b) is a certifiable defense against $l _ { \\infty }$ -norm bounded perturbations. Both of these defenses produce a class label, and also a guarantee that the image could not have been crafted by making small perturbations to an image of a different label. Certified defenses can also benefit from adversarial training. For example, Salman et al. (2019) recently improved the certified radii of randomized smoothing (Cohen et al., 2019) by training on adversarial examples generated for the smoothed classifier. ",
+        "bbox": [
+            176,
+            857,
+            823,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, prior works have focused on making adversarial examples that satisfy the imperceptibility and misclassification conditions, but none have investigated manipulating certificates, which is our focus here. ",
+        "bbox": [
+            176,
+            180,
+            821,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The reminder of this paper is organized as follows. In section 2 we introduce our new approach Shadow Attack for generating adversarial perturbations. This is a hybrid model that allows various kinds of attacks to be compounded together, resulting in perturbations of large radii. In section 3 we present an attack on “randomized smoothing” certificates (Cohen et al., 2019). Section 4 shows an ablation study which illustrates why the elements of the Shadow Attack are important for successfully manipulating certified models. In section 5 we generate adversarial examples for “CROWN-IBP” (Zhang et al., 2019b). Finally, we discuss results and wrap up in section 6. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 THE SHADOW ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            349,
+            395,
+            366
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Because certificate spoofing requires large perturbations (larger than the $\\ell _ { p }$ ball of the certificate), we propose a simple attack that ensembles numerous modes to create large perturbations. Our attack can be seen as the generalization of the well-known PGD attack, which creates adversarial images by modifying a clean base image. Given a loss function $L$ and an $\\ell _ { p }$ -norm bound $\\epsilon$ for some $p \\geq 0$ , PGD attacks solve the following optimization problem: ",
+        "bbox": [
+            174,
+            382,
+            825,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4c6c591227bf59a1aa3cd1c30eefc8ecd5a98dc9088b55f6ffe67353286f562e.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\delta } L ( \\theta , x + \\delta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            462,
+            557,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f40e7f163861a9d6f28b0503ebde8a9463af232443d634507afd41c28989c06.jpg",
+        "text": "$$\ns . t . \\parallel \\delta \\parallel _ { p } \\leq \\epsilon ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            452,
+            496,
+            544,
+            515
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta$ are the network parameters and $\\delta$ is the adversarial perturbation to be added to the clean input image $x$ . Constraint 2 promotes imperceptibility of the resulting perturbation to the human eye by limiting the perturbation size. In the shadow attack, instead of solving the above constrained optimization problem, we solve the following problem with a range of penalties: ",
+        "bbox": [
+            174,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/05515cb9a846c4ba3d39886cfffd7b0f2de09f875f01731e5aba7ec642696cb2.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\delta } L ( \\theta , x + \\delta ) - \\lambda _ { c } C ( \\delta ) - \\lambda _ { t v } T V ( \\delta ) - \\lambda _ { s } D i s s i m ( \\delta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            585,
+            692,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { c } , \\lambda _ { t v } , \\lambda _ { s }$ are scalar penalty weights. Penalty $T V ( \\delta )$ forces the perturbation $\\delta$ to have small total variation $( T V )$ , and so appear more smooth and natural. Penalty $C ( \\delta )$ limits the perturbation $\\delta$ globally by constraining the change in the mean of each color channel $c$ . This constraint is needed since total variation is invariant to constant/scalar additions to each color channel, and it is desirable to suppress extreme changes in the color balances of images. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Penalty $D i s s i m ( \\delta )$ promotes perturbations $\\delta$ that assume similar values in each color channel. In the case of an RGB image of shape $3 \\times W \\times H$ , if $D i s s i m ( \\delta )$ is small, the perturbations to red, green, and blue channels are similar, i.e., $\\delta _ { R , w , h } \\approx \\delta _ { G , w , h } \\approx \\delta _ { B , w , h } , \\forall ( w , h ) \\in W \\times H$ . This amounts to making the pixels darker/lighter, without changing the color balance of the image. Later, in section 3, we suggest two ways of enforcing such similarity between RGB channels and we find both of them effective: ",
+        "bbox": [
+            173,
+            694,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• 1-channel attack strictly enforces $\\delta _ { R , i } \\approx \\delta _ { G , i } \\approx \\delta _ { B , i } , \\forall i$ by using just one array to simultaneously represent each color channel $\\delta _ { W \\times H }$ . On the forward pass, we duplicate $\\delta$ to make a 3-channel image. In this case, $D i s s i m ( \\delta ) = 0$ , and the perturbation is greyscale. • 3-channel attack uses a 3-channel perturbation $\\delta _ { 3 \\times W \\times H }$ , along with the dissimilarity metric $D i s s i m ( \\delta ) = \\| \\delta _ { R } - \\delta _ { B } \\| _ { p } + \\| \\delta _ { R } - \\delta _ { G } \\| _ { p } + \\| \\delta _ { B } - \\delta _ { G } \\| _ { p }$ . ",
+        "bbox": [
+            214,
+            790,
+            825,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All together, the three penalties minimize perceptibility of perturbations by forcing them to be $( a )$ small, $( b )$ smooth, and $( c )$ without dramatic color changes (e.g. swapping blue to red). At the same time, these penalties allow perturbations that are very large in $\\ell _ { p }$ -norm. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 CREATING UNTARGETED ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            452,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We focus on spoofing certificates for untargeted attacks, in which the attacker does not specify the class into which the attack image moves. To achieve this, we generate an adversarial perturbation for all possible wrong classes $\\bar { y }$ and choose the best one as our strong attack: ",
+        "bbox": [
+            173,
+            128,
+            823,
+            171
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f2e385ccb90969adf854ce58e4750c12eedd8df4ea5ebaf271980745253ac60.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\bar { y } \\neq y , \\delta } - L ( \\theta , x + \\delta \\| \\bar { y } ) - \\lambda _ { c } C ( \\delta ) - \\lambda _ { t v } T V ( \\delta ) - \\lambda _ { s } D i s s i m ( \\delta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            176,
+            709,
+            202
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y$ is the true label/class for the clean image $x$ , and $L$ is a spoofing loss that promotes a strong certificate. We examine different choices for $L$ for different certificates below. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 ATTACKS ON RANDOMIZED SMOOTHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            255,
+            545,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Randomized Smoothing method, first proposed by Lecuyer et al. (2018) and later improved by Li et al. (2018), is an adversarial defense against $\\ell _ { 2 }$ -norm bounded attacks. Cohen et al. (2019) prove a tight robustness guarantee under the $\\ell _ { 2 }$ norm for smoothing with Gaussian noise. Their study was the first certifiable defense for the ImageNet dataset (Deng et al., 2009). The method constructs certificates by first creating many copies of an input image contaminated with random Gaussian noise of standard deviation $\\sigma$ . Then, it uses a base classifier (a neural net) to make a prediction for all of the images in the randomly augmented batch. Depending on the level of the consensus of the class labels at these random images, a certified radius is calculated that can be at most $4 \\sigma$ (in the case of perfect consensus). ",
+        "bbox": [
+            173,
+            285,
+            825,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, if the image is far away from the decision boundary, the base classifier should predict the same label for each noisy copy of the test image, in which case the certificate is strong. On the other hand, if the image is adjacent to the decision boundary, the base classifier’s predictions for the Gaussian augmented copies may vary. If the variation is large, the smoothed classifier abstains from making a prediction. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To spoof strong certificates (large certified radius) for an incorrect class, we must make sure that the majority of a batch of noisy images around the adversarial image are assigned the same (wrong) label. We do this by minimizing the cross entropy loss relative to a chosen (incorrect) label, averaged over a large set of randomly perturbed images. To this end, we minimize equation 4, where $L$ is chosen to be the average cross-entropy over a batch of Gaussian perturbed copies. This method is analogous to the technique presented by Shafahi et al. (2018) for generating universal perturbations that are effective when added to a large number of different images. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            238,
+            623
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Cohen et al. (2019) show the performance of the Gaussian smoothed classifier on CIFAR-10 (Krizhevsky et al.) and ImageNet (Deng et al., 2009). To attack the CIFAR-10 and ImageNet smoothed classifiers, we use 400 randomly sampled Gaussian images, $\\lambda _ { t v } = 0 . 3$ , $\\lambda _ { c } = 1 . 0$ , and perform 300 steps of SGD with learning rate 0.1. We choose the functional regularizers $C ( \\delta )$ and $T V ( \\delta )$ to be ",
+        "bbox": [
+            173,
+            635,
+            825,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be674872e734fc14ed493ea69fc840ffba5fa5c4f24446ad608628dc388a8df9.jpg",
+        "text": "$$\nC ( \\delta ) = \\| \\operatorname { A v g } ( | \\delta _ { R } | ) , \\operatorname { A v g } ( | \\delta _ { G } | ) , \\operatorname { A v g } ( | \\delta _ { B } | ) \\| _ { 2 } ^ { 2 } , \\quad \\mathrm { a n d } \\quad T V ( \\delta _ { i , j } ) = \\mathrm { a n i s o t r o p i c - T V } ( \\delta _ { i , j } ) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            710,
+            794,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $| \\cdot |$ is the element-wise absolute value operator, and Avg computes the average. For the Dissim regularizer, we experiment with both the 1-Channel attack that ensures $D i s s i m ( \\delta ) = 0$ , and the 3-Channel attack by setting $D i s s i m ( \\delta ) \\ : = \\ : \\lVert ( \\delta _ { R } - \\delta _ { G } ) ^ { 2 } , ( \\delta _ { R } - \\delta _ { B } ) ^ { 2 } , ( \\delta _ { G } - \\delta _ { B } ) ^ { 2 } \\rVert _ { 2 }$ and $\\lambda _ { s } ~ = ~ 0 . 5$ . For the validation examples on which the smoothed classifier does not abstain (see Cohen et al. (2019) for more details), the less-constrained 3-channel attack is always able to find an adversarial example while the 1-channel attack also performs well, achieving $9 8 . 5 \\%$ success. 2 In section 4 we will discuss in more detail other differences between 1-channel and 3-channel attacks. The results are summarized in Table 1. For the various base-models and choices of $\\sigma$ , our adversarial examples are able to produce certified radii that are on average larger than the certified radii produced for natural images. For ImageNet, since attacking all 999 remaining target classes is computationally expensive, we only attacked target class IDs 100, 200, 300, 400, 500, 600, 700, 800, 900, and 1000. ",
+        "bbox": [
+            173,
+            734,
+            826,
+            900
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/4ddc3c4cb9fa22c1bdb39a4593a750c552448ba991cae9372d95fe9296d15da7.jpg",
+        "table_caption": [
+            "Table 1: Certified radii produced by the Randomized Smoothing method for Shadow Attack images and also natural images (larger radii means a stronger/more confident certificate). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Dataset</td><td rowspan=\"2\">g(l2)</td><td colspan=\"2\">Unmodified/Natural Images</td><td colspan=\"2\">Shadow Attack</td></tr><tr><td>Mean</td><td>STD</td><td>Mean</td><td>STD</td></tr><tr><td rowspan=\"4\">CIFAR-10</td><td>0.12</td><td>0.14</td><td>0.056</td><td>0.22</td><td>0.005</td></tr><tr><td>0.25</td><td>0.30</td><td>0.111</td><td>0.35</td><td>0.062</td></tr><tr><td>0.50</td><td>0.47</td><td>0.234</td><td>0.65</td><td>0.14</td></tr><tr><td>1.00</td><td>0.78</td><td>0.556</td><td>0.85</td><td>0.442</td></tr><tr><td rowspan=\"3\">ImageNet</td><td>0.25</td><td>0.30</td><td>0.109</td><td>0.31</td><td>0.109</td></tr><tr><td>0.50</td><td>0.61</td><td>0.217</td><td>0.38</td><td>0.191</td></tr><tr><td>1.00</td><td>1.04</td><td>0.519</td><td>0.64</td><td>0.322</td></tr></table>",
+        "bbox": [
+            246,
+            146,
+            750,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc84d5db0b10201ae1b67b97307b4ea040d8acf621a920e268218446d3dd9330.jpg",
+        "image_caption": [
+            "Figure 2: An adversarial example built using our Shadow Attack for the smoothed ImageNet classifier for which the certifiable classifier produces a large certified radii. The adversarial perturbation is smooth and natural looking even-though it is large when measured using $\\ell _ { p }$ -metrics. Also see Figure 16 in the appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            296,
+            802,
+            468
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 depicts a sample adversarial example built for the smoothed ImageNet classifier that produces a strong certificate. The adversarial perturbation causes the batch of Gaussian augmented black swan images to get misclassified as hooks. For more, see appendix 16. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 ABLATION STUDY OF THE ATTACK PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            670,
+            607,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we perform an ablation study on the parameters of the Shadow Attack to evaluate $( i )$ the number of SGD steps needed, $( i i )$ the importance of $\\lambda _ { s }$ (or alternatively using 1-channel attacks), and $( i i i )$ the effect of $\\lambda _ { t v }$ . ",
+        "bbox": [
+            174,
+            713,
+            825,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The default parameters for all of the experiments are as follows unless explicitly mentioned: We use 30 SGD steps with learning rate 0.1 for the optimization. All experiments except part $( i i )$ use 1-channel attacks for the sake of simplicity and efficiency (since it has less parameters). We assume $\\lambda _ { t v } = 0 . 3$ , $\\lambda _ { c } = 2 0$ , and use batch-size 50. We present results using the first example from each class of the CIFAR-10 validation set. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows how the adversarial example evolves during the first few steps of optimization (See appendix 13 for more examples). Also, figures 4, 5, and 6 show the evolution of $L ( \\delta )$ , $T V ( \\delta )$ , and $\\bar { C } \\bar { ( \\delta ) }$ , respectively (Note that we use 1-channel attacks, so $D i s s i m ( \\delta )$ is always 0). We find that taking just 10 SGD steps is enough for convergence on CIFAR-10, but for our main results (i.e. attacking Randomized Smoothing in section 3 and attacking CROWN-IBP in section 5) we take 300 steps to be safe. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/06896354aa897e71ad464ff338e02180acd639c0b924e325783b1c8a3dd998c9.jpg",
+        "image_caption": [
+            "Figure 3: The first 10 steps of optimization (beginning with a randomly perturbed image copy). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            98,
+            812,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f654668f167ce857cd1a65e3dc06a5d881a1b575148684fe8485fe507e774e1.jpg",
+        "image_caption": [
+            "Figure 9: Histogram of randomized smoothed certificate radii for 100 randomly sampled CIFAR-10 validation images vs those calculated for their adversarial examples crafted using our 1-channel and 3- channel adversarial Shadow Attack attacks. The “robust” victim classifier is based off Resnet-110, and smoothed with $\\sigma = 0 . 5 0$ . 1-channel attacks are almost as good as the less-restricted 3-channel attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            275,
+            527,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/20b0585db38a51f88ba2fe2f975e26e2664bfa056c241232db33209383603542.jpg",
+        "image_caption": [
+            "Figure 4: Average $L _ { b } ( \\delta )$ in the first 10 steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            507,
+            375,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed8360582f6789035034591491c8a59e60b1f7bc6ce16b046db67da3396effda.jpg",
+        "image_caption": [
+            "Figure 5: Average $T V ( \\delta )$ in the first 10 steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            405,
+            507,
+            589,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/576f9a7e05690dbed7eec18b645131799913a3615487705255f0af1050b0a5c1.jpg",
+        "image_caption": [
+            "Figure 6: Average $C ( \\delta )$ in the first 10 steps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            620,
+            507,
+            805,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/b5ff85f3e580e8529c53fc20bcba81dced2826ca740797c4b30175693434a25e.jpg",
+        "image_caption": [
+            "Figure 7: The effect of $\\lambda _ { s }$ on the resulting $D i s s i m ( \\delta )$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            676,
+            470,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/93f51feafa913752183e135ca6c9eafcae0039af6dd29556964c39fb39596c1f.jpg",
+        "image_caption": [
+            "Figure 8: The effect of $\\lambda _ { t v }$ on the resulting $T V ( \\delta )$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            676,
+            686,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c034ce0f1c1431c9a7df409bb4d212480ccfe1b9e8bfc31a043b7d0611506a50.jpg",
+        "image_caption": [
+            "Figure 10: The visual effect of Shadow Attack on 9 randomly selected CIFAR-10 examples using 1-Channel and 3-Channel attacks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            776,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/be81020d44f96313e583d56feed9be268ca6c3615f7d1bd1f81f132998bc4e03.jpg",
+        "image_caption": [
+            "Figure 11: The visual effect of $\\lambda _ { s }$ on perceptibility of the perturbations. The first row shows the value of $\\lambda _ { s }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            273,
+            812,
+            376
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Also, figure 7 shows the mean $D i s s i m ( \\delta )$ for different values of $\\lambda _ { s } ( 0 \\leq \\lambda _ { s } \\leq 5 . 0 )$ . We also plot the histogram of the certificate radii in figure 9. Figure 10 compares 1-Channel vs 3-Channel attacks for some of randomly selected CIFAR-10 images. Finally, we explore the effect of $\\lambda _ { t v }$ on imperceptibility of the perturbations in Figure 12. See table 15 for more images, and figure 8 for the impact of parameters on $T V ( \\delta )$ . ",
+        "bbox": [
+            173,
+            450,
+            825,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ATTACKS ON CROWN-IBP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            573,
+            434,
+            589
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interval Bound Propagation (IBP) methods have been recently studied as a defense against $\\ell _ { \\infty }$ - bounded attacks. Many recent studies such as Gowal et al. (2018); Xiao et al. (2018); Wong et al. (2018); Mirman et al. (2018) have investigated IBP methods to train provably robust networks. To the best of our knowledge, the CROWN-IBP method by Zhang et al. (2019b) achieves state-ofthe-art performance for MNIST (LeCun & Cortes, 2010), Fashion-MNIST (Xiao et al., 2017), and CIFAR-10 datasets among certifiable $\\ell _ { \\infty }$ defenses. In this section we focus on attacking Zhang et al. (2019b) using CIFAR-10. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "IBP methods (over)estimate how much a small $\\ell _ { \\infty }$ -bounded noise in the input can impact the classification layer. This is done by propagating errors from layer to layer, computing bounds on the maximum possible perturbation to each activation. During testing, the user chooses an $\\ell _ { \\infty }$ perturbation bound $\\epsilon$ , and error propagation is used to bound the magnitude of the largest achievable perturbation in network output. If the output perturbation is not large enough to flip the image label, then a certificate is produced. If the output perturbation is large enough to flip the image label, then a certificate is not produced. During network training, IBP methods include a term in the loss function that promotes tight error bounds that result in certificates. Our attack directly uses the loss function term used during IBP network training in addition to the Shadow Attack penalties; we search for an image that is visually similar to the base image, while producing a bound on the output perturbation that is too small to flip the image label. Note that there is a subtle difference between crafting conventional adversarial examples which ultimately targets misclassification and our adversarial examples which aim to produce adversarial examples which cause misclassification and produce strong certificates. In the former case, we only need to attack the cross-entropy loss. If we use our Shadow Attack to craft adversarial examples based on the cross-entropy loss, the robustness errors are on average roughly $50 \\%$ larger than those reported in table 2 (i.e., simple adversarial examples produce weaker certificates.) ",
+        "bbox": [
+            174,
+            708,
+            825,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd183f30a6c50eaea65e9d318bc4cea9dd52bf2d2a0b4f40f9d6a92c659a448c.jpg",
+        "image_caption": [
+            "Figure 12: The visual effect of $\\lambda _ { t v }$ on the on imperceptibility of the perturbations. The first row shows the value of $\\lambda _ { t v }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            813,
+            812,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7562164da1d0db0ad24a7dc0c343e5706b73bf17b4748641046d79162ed113c0.jpg",
+        "table_caption": [
+            "Table 2: “Robust error” for natural images, and “attack error” for Shadow Attack images using the CIFAR-10 dataset, and CROWN-IBP models. Smaller is better. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">∈(lo）</td><td rowspan=\"2\">Model Family</td><td rowspan=\"2\">Method</td><td colspan=\"3\">Robustness Errors</td></tr><tr><td>Min</td><td>Mean</td><td>Max</td></tr><tr><td rowspan=\"4\">2/255</td><td rowspan=\"2\">9 small models</td><td>CROWN-IPB</td><td>52.46</td><td>57.55</td><td>60.67</td></tr><tr><td>Shadow Attack</td><td>45.90</td><td>53.89</td><td>65.74</td></tr><tr><td rowspan=\"2\">8 large models</td><td>CROWN-IBP</td><td>52.52</td><td>53.9</td><td>56.05</td></tr><tr><td>Shadow Attack</td><td>46.21</td><td>49.77</td><td>51.79</td></tr><tr><td rowspan=\"4\">8/255</td><td rowspan=\"2\">9 small models</td><td>CROWN-IBP</td><td>71.28</td><td>72.15</td><td>73.66</td></tr><tr><td>Shadow Attack</td><td>63.43</td><td>66.94</td><td>71.02</td></tr><tr><td rowspan=\"2\">8 large models</td><td>CROWN-IBP</td><td>70.79</td><td>71.17</td><td>72.29</td></tr><tr><td>Shadow Attack</td><td>64.04</td><td>67.32</td><td>71.16</td></tr></table>",
+        "bbox": [
+            250,
+            147,
+            743,
+            290
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            333,
+            825,
+            486
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We attack 4 classes of networks released by Zhang et al. (2019b) for CIFAR-10. There are two classes of IBP architectures, one of them consists of 9 small models and the other consists of 8 larger models. For each class of architecture, there are two sets of pre-trained models: one for $\\epsilon = 2 / 2 5 5$ and one for $\\epsilon = 8 / 2 5 5$ . We use $\\lambda _ { t v } = 0 . 0 0 0 0 0 9$ , $\\lambda _ { c } = 0 . 0 2$ , $C ( \\delta ) = \\| \\delta \\| _ { 2 }$ and set the learning rate to 200 and for the rest of the regularizers and hyper-paramters we use the same hyperparameters and regularizers as in 3. For the sake of efficiency, we only do 1-channel attacks. We attack the 4 classes of models and for each class, we report the min, mean, and max of the robustness errors and compare them with those of the CROWN-IBP paper. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            604
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To quantify the success of our attack, we define two metrics of error. For natural images, we report the rate of “robust errors,” which are images that are either (i) incorrectly labeled, or (ii) correctly labelled but without a certificate. In contrast, for attack images, we report the rate of “attack errors,” which are either (i) correctly classified or (ii) incorrectly classified but without a certificate. Table 2 shows the robust error on natural images, and the attack error on Shadow Attack images for the CROWN-IBP models. With $\\epsilon = 2 / 2 5 \\bar { 5 }$ , our attack finds adversarial examples that certify roughly $15 \\%$ of the time (i.e., attack error ${ < } 8 5 \\%$ ). With $\\epsilon = 8 / 2 5 5$ , our attack finds adversarial examples that are incorrectly classified, and yet certify even more often than natural images. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            316,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that it is possible to produce adversarial examples with “spoofed” certified robustness by using large-norm perturbations. Our adversarial examples are built using our Shadow Attack that produces smooth and natural looking perturbations that are often less perceptible than those of the commonly used $\\ell _ { p }$ -bounded perturbations, while being large enough in norm to escape the certification regions of state of the art principled defenses. This work suggests that the certificates produced by certifiably robust classifiers, while mathematically rigorous, are not always good indicators of robustness or accuracy. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: Goldstein and his students were supported by the DARPA QED for RML program, the DARPA GARD program, and the National Science Foundation. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anish Athalye, Nicholas Carlini, and David Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. arXiv preprint arXiv:1802.00420, 2018. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European conference on machine learning and knowledge discovery in databases, pp. 387–402. Springer, 2013. ",
+        "bbox": [
+            173,
+            175,
+            825,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tom B Brown, Nicholas Carlini, Chiyuan Zhang, Catherine Olsson, Paul Christiano, and Ian Goodfellow. Unrestricted adversarial examples. arXiv preprint arXiv:1809.08352, 2018. ",
+        "bbox": [
+            169,
+            241,
+            823,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 3–14. ACM, 2017. ",
+        "bbox": [
+            173,
+            279,
+            823,
+            321
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeremy M Cohen, Elan Rosenfeld, and J Zico Kolter. Certified adversarial robustness via randomized smoothing. arXiv preprint arXiv:1902.02918, 2019. ",
+        "bbox": [
+            168,
+            329,
+            825,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A Large-Scale Hierarchical Image Database. In CVPR09, 2009. ",
+        "bbox": [
+            169,
+            366,
+            825,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Isaac Dunn, Tom Melham, and Daniel Kroening. Generating realistic unrestricted adversarial inputs using dual-objective gan training. arXiv preprint arXiv:1905.02463, 2019. ",
+        "bbox": [
+            169,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Engstrom, Brandon Tran, Dimitris Tsipras, Ludwig Schmidt, and Aleksander Madry. A rotation and a translation suffice: Fooling cnns with simple transformations. arXiv preprint arXiv:1712.02779, 2017. ",
+        "bbox": [
+            173,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sven Gowal, Krishnamurthy Dvijotham, Robert Stanforth, Rudy Bunel, Chongli Qin, Jonathan Uesato, Timothy Mann, and Pushmeet Kohli. On the effectiveness of interval bound propagation for training verifiably robust models. arXiv preprint arXiv:1810.12715, 2018. ",
+        "bbox": [
+            174,
+            491,
+            823,
+            535
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hossein Hosseini and Radha Poovendran. Semantic adversarial examples. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pp. 1614–1619, 2018. ",
+        "bbox": [
+            169,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/˜kriz/cifar.html. ",
+        "bbox": [
+            171,
+            579,
+            823,
+            609
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Cassidy Laidlaw and Soheil Feizi. Functional adversarial attacks. arXiv preprint arXiv:1906.00001, 2019. ",
+        "bbox": [
+            171,
+            654,
+            823,
+            683
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/. ",
+        "bbox": [
+            173,
+            690,
+            821,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mathias Lecuyer, Vaggelis Atlidakis, Roxana Geambasu, Daniel Hsu, and Suman Jana. Certified robustness to adversarial examples with differential privacy. arXiv preprint arXiv:1802.03471, 2018. ",
+        "bbox": [
+            176,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bai Li, Changyou Chen, Wenlin Wang, and Lawrence Carin. Second-order adversarial attack and certifiable robustness. CoRR, abs/1809.03113, 2018. URL http://arxiv.org/abs/ 1809.03113. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Matthew Mirman, Timon Gehr, and Martin Vechev. Differentiable abstract interpretation for provably robust neural networks. In International Conference on Machine Learning, pp. 3575–3583, 2018. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hadi Salman, Greg Yang, Jerry Li, Pengchuan Zhang, Huan Zhang, Ilya Razenshteyn, and Sebastien Bubeck. Provably robust deep learning via adversarially trained smoothed classifiers. arXiv preprint arXiv:1906.04584, 2019. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, Mahyar Najibi, Zheng Xu, John Dickerson, Larry S Davis, and Tom Goldstein. Universal adversarial training. arXiv preprint arXiv:1811.11304, 2018. ",
+        "bbox": [
+            171,
+            205,
+            823,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Shafahi, Mahyar Najibi, Amin Ghiasi, Zheng Xu, John Dickerson, Christoph Studer, Larry S Davis, Gavin Taylor, and Tom Goldstein. Adversarial training for free! arXiv preprint arXiv:1904.12843, 2019. ",
+        "bbox": [
+            174,
+            243,
+            823,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yang Song, Rui Shu, Nate Kushman, and Stefano Ermon. Constructing unrestricted adversarial examples with generative models. In Advances in Neural Information Processing Systems, pp. 8312–8323, 2018. ",
+        "bbox": [
+            171,
+            295,
+            823,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            173,
+            347,
+            823,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Uesato, Brendan O’Donoghue, Aaron van den Oord, and Pushmeet Kohli. Adversarial risk and the dangers of evaluating against weak attacks. arXiv preprint arXiv:1802.05666, 2018. ",
+        "bbox": [
+            173,
+            385,
+            825,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rey Wiyatno and Anqi Xu. Maximal jacobian-based saliency map attack. arXiv preprint arXiv:1808.07945, 2018. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Frank Schmidt, Jan Hendrik Metzen, and J Zico Kolter. Scaling provable adversarial defenses. In Advances in Neural Information Processing Systems, pp. 8400–8409, 2018. ",
+        "bbox": [
+            174,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Frank R Schmidt, and J Zico Kolter. Wasserstein adversarial examples via projected sinkhorn iterations. arXiv preprint arXiv:1902.07906, 2019. ",
+        "bbox": [
+            173,
+            497,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Y Xiao, Vincent Tjeng, Nur Muhammad Shafiullah, and Aleksander Madry. Training for faster adversarial robustness verification via inducing relu stability. arXiv preprint arXiv:1809.03008, 2018. ",
+        "bbox": [
+            174,
+            574,
+            823,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hongyang Zhang, Yaodong Yu, Jiantao Jiao, Eric P Xing, Laurent El Ghaoui, and Michael I Jordan. Theoretically principled trade-off between robustness and accuracy. arXiv preprint arXiv:1901.08573, 2019a. ",
+        "bbox": [
+            173,
+            626,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huan Zhang, Hongge Chen, Chaowei Xiao, Bo Li, Duane Boning, and Cho-Jui Hsieh. Towards stable and efficient training of verifiably robust neural networks. arXiv preprint arXiv:1906.06316, 2019b. ",
+        "bbox": [
+            174,
+            676,
+            821,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we include the complete results of our ablation study. As we mentioned in section 4, we use is a subset of CIFAR-10 dataset, including one example per each class. For the sake of simplicity, we call the dataset Tiny-CIFAR-10. Here, we show the complete results for the ablation experiments on all of Tiny-CIFAR-10 examples. Figure 13 shows that taking a few optimization steps is enough for the resulting images to look natural-looking. Figure 14 and 15, respectively show the effect of $\\lambda _ { s }$ and $\\lambda _ { T V }$ on the imperceptability of the perturbations. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e318ad399b6a9920a96865cfafefb95dac1dea8697d18cc2132b9c8528c042f.jpg",
+        "image_caption": [
+            "Figure 13: The first 10 steps of the optimization vs the original image for Tiny-CIFAR-10. See section 4 for the details of the experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            241,
+            812,
+            699
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7083b05ac85595444ad846253e87552a5cc66b4751f9f7fd1ce2f15682e8328.jpg",
+        "image_caption": [
+            "Figure 14: The visual effect of $\\lambda _ { s }$ on $D i s s i m ( \\delta )$ on Tiny-CIFAR-10. See section 4 for the details of the experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            256,
+            812,
+            713
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/773cfd90ee4f02cda6951516af5243e28356f25270610bb6923ea3c4d053ae6f.jpg",
+        "image_caption": [
+            "Figure 15: The visual effect of $\\lambda _ { t v }$ on the perturbation Tiny-CIFAR-10. See section 4 for the details of the experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            256,
+            812,
+            713
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/35db09145b659fb6450768f35a651ae2772e1f75460ee18e7df15607962a5cf8.jpg",
+        "table_caption": [
+            "Table 3: Certified radii statistics produced by the Adversarially Trained Randomized Smoothing method for our adversarial examples crafted using Shadow Attack and the natural examples (larger radii are better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>σ(l2)</td><td>Adversarially Trained Randomized Smoothed Mean</td><td>STD</td><td>Shadow Attack Mean</td><td>STD</td></tr><tr><td>CIFAR-10</td><td>0.5</td><td>0.60</td><td>0.34</td><td>0.65</td><td>0.16</td></tr></table>",
+        "bbox": [
+            184,
+            160,
+            813,
+            207
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "IMAGENET RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            320,
+            251
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Many of the recent studies have explored the semantic attacks. Semantic attacks are powerful for attacking defenses (Engstrom et al., 2017; Hosseini & Poovendran, 2018; Laidlaw & Feizi, 2019). Many of semantic attacks are applicable to Imagenet, however, none of them consider increasing the radii of the certificates generated by the certifiable defenses. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            319
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Some other works focus on using generative models to generate adversarial examples (Song et al., 2018), but unfortunately none of the GAN’s are expressive enough to capture the manifold of the ImageNet. ",
+        "bbox": [
+            176,
+            327,
+            820,
+            368
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Figure 16 illustrates some of our successful examples generated by Shadow Attack to attack Randomized Smoothed classifiers for ImageNet. ",
+        "bbox": [
+            174,
+            375,
+            821,
+            404
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B CERTIFICATE SPOOFING ATTACKS ON ADVERSARIALLY TRAINED SMOOTH CLASSIFIERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            425,
+            818,
+            457
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Recently, Salman et al. (2019) significantly improved the robustness of Gaussian smoothed classifiers by generating adversarial examples for the smoothed classifier and training on them. In this section, we use our Shadow Attack to generate adversarial examples using the loss in eq. 4 for the SmoothAdv classifier 4. Due to computation limitations, we attack a sample of $40 \\%$ of the same validation images used for evaluating the randomized smooth classifier in section 3. The results are summarized in table 3. Comparing the results of table 1 to table 3, we can see that the SmoothAdv classifier, does produce stronger certified radii for natural examples (many of the examples in fact have the maximum radii) compared to the original randomized smoothing classifier. This can be associate to the excessive invariance introduced as a result of adversarial training. However, table 3 empirically verifies that its certificates are still subject to attacks and the certificate should not be used as a measure for robustness. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            626
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/321bee1545259a95016ff53f96cd726ebe40301a2e72b8985b88bb656579a4a7.jpg",
+        "image_caption": [
+            "Figure 16: Natural looking Imperceptible ImageNet adversarial images which produce large certified radii for the ImageNet Gaussian smoothed classifier. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            92,
+            790,
+            873
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HkwVAXyCW/HkwVAXyCW.md

@@ -0,0 +1,321 @@
+# SKIP RNN: LEARNING TO SKIP STATE UPDATES IN RECURRENT NEURAL NETWORKS
+
+V´ıctor Campos∗†, Brendan $\mathbf { J o u } ^ { \ddag }$ , Xavier Giro-i-Nieto ´ §, Jordi Torres†, Shih-Fu ChangΓ †Barcelona Supercomputing Center, ‡Google Inc, §Universitat Politecnica de Catalunya, \` ΓColumbia University {victor.campos, jordi.torres}@bsc.es, bjou@google.com, xavier.giro@upc.edu, shih.fu.chang@columbia.edu
+
+# ABSTRACT
+
+Recurrent Neural Networks (RNNs) continue to show outstanding performance in sequence modeling tasks. However, training RNNs on long sequences often face challenges like slow inference, vanishing gradients and difficulty in capturing long term dependencies. In backpropagation through time settings, these issues are tightly coupled with the large, sequential computational graph resulting from unfolding the RNN in time. We introduce the Skip RNN model which extends existing RNN models by learning to skip state updates and shortens the effective size of the computational graph. This model can also be encouraged to perform fewer state updates through a budget constraint. We evaluate the proposed model on various tasks and show how it can reduce the number of required RNN updates while preserving, and sometimes even improving, the performance of the baseline RNN models. Source code is publicly available at https://imatge-upc. github.io/skiprnn-2017-telecombcn/.
+
+# 1 INTRODUCTION
+
+Recurrent Neural Networks (RNNs) have become the standard approach for practitioners when addressing machine learning tasks involving sequential data. Such success has been enabled by the appearance of larger datasets, more powerful computing resources and improved architectures and training algorithms. Gated units, such as the Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) (LSTM) and the Gated Recurrent Unit (Cho et al., 2014) (GRU), were designed to deal with the vanishing gradients problem commonly found in RNNs (Bengio et al., 1994). These architectures have been popularized, in part, due to their impressive results on a variety of tasks in machine translation (Bahdanau et al., 2015), language modeling (Zaremba et al., 2015) and speech recognition (Graves et al., 2013).
+
+Some of the main challenges of RNNs are in their training and deployment when dealing with long sequences, due to their inherently sequential behaviour. These challenges include throughput degradation, slower convergence during training and memory leakage, even for gated architectures (Neil et al., 2016). Sequence shortening techniques, which can be seen as a sort of conditional computation (Bengio et al., 2013; Bengio, 2013; Davis & Arel, 2013) in time, can alleviate these issues. The most common approaches, such as cropping discrete signals or reducing the sampling rate in continuous signals, are based on heuristics and can be suboptimal. In contrast, we propose a model that is able to learn which samples (i.e., elements in the input sequence) need to be used in order to solve the target task. Consider a video understanding task as an example: scenes with large motion may benefit from high frame rates, whereas only a few frames are needed to capture the semantics of a mostly static scene.
+
+The main contribution of this work is a novel modification for existing RNN architectures that allows them to skip state updates, decreasing the number of sequential operations performed, without requiring any additional supervision signal. This model, called Skip RNN, adaptively determines whether the state needs to be updated or copied to the next time step. We show how the network can be encouraged to perform fewer state updates by adding a penalization term during training, allowing us to train models under different computation budgets. The proposed modification can generally be integrated with any RNN and we show, in this paper, implementations with well-known RNNs, namely LSTM and GRU. The resulting models show promising results on a series of sequence modeling tasks. In particular, we evaluate the proposed Skip RNN architecture on six sequence learning problems: an adding task, sine wave frequency discrimination, digit classification, sentiment analysis in movie reviews, action classification in video, and temporal action localization in video1.
+
+# 2 RELATED WORK
+
+Conditional computation has been shown to gradually increase model capacity without proportional increases in computational cost by exploiting certain computation paths for each input (Bengio et al., 2013; Liu & Deng, 2017; Almahairi et al., 2016; McGill & Perona, 2017; Shazeer et al., 2017). This idea has been extended in the temporal domain, such as in learning how many times an input needs to be ”pondered” before moving to the next one (Graves, 2016) or designing RNN architectures whose number of layers depend on the input data (Chung et al., 2017). Other works have addressed time-dependent computation in RNNs by updating only a fraction of the hidden states based on the current hidden state and input (Jernite et al., 2017), or following periodic patterns (Koutnik et al., 2014; Neil et al., 2016). However, due to the inherently sequential nature of RNNs and the parallel computation capabilities of modern hardware, reducing the size of the matrices involved in the computations performed at each time step generally has not accelerated inference as dramatically as hoped. The proposed Skip RNN model can be seen as form of conditional computation in time, where the computation associated to the RNN updates may or may not be executed at every time step. This idea is related to the UPDATE and COPY operations in hierarchical multiscale RNNs (Chung et al., 2017), but applied to the whole stack of RNN layers at the same time. This difference is key to allowing our approach to skip input samples, effectively reducing sequential computation and shielding the hidden state over longer time lags. Learning whether to update or copy the hidden state through time steps can be seen as a learnable Zoneout mask (Krueger et al., 2017) which is shared between all the units in the hidden state. Similarly, it can be interpreted as an input-dependent recurrent version of stochastic depth (Huang et al., 2016).
+
+Selecting parts of the input signal is similar in spirit to the hard attention mechanisms that have been applied to image regions (Mnih et al., 2014), where only some patches of the input image are attended in order to generate captions (Xu et al., 2015) or detect objects (Ba et al., 2014). Our model can be understood as generating a hard temporal attention mask on-the-fly given previously seen samples, deciding which time steps should be attended and operating on a subset of input samples. Subsampling input sequences has been explored for visual storylines generation (Sigurdsson et al., 2016b), although jointly optimizing the RNN weights and the subsampling mechanism is often computationally infeasible and they use an Expectation-Maximization algorithm instead. Similar research has been conducted for video analysis tasks, discovering minimally needed evidence for event recognition (Bhattacharya et al., 2014) and training agents that decide which frames need to be observed in order to localize actions in time (Yeung et al., 2016; Su & Grauman, 2016). Motivated by the advantages of training recurrent models on shorter subsequences, efforts have been conducted on learning differentiable subsampling mechanisms (Raffel & Lawson, 2017), although the computational complexity of the proposed method precludes its application to long input sequences. In contrast, our proposed method can be trained with backpropagation and does not degrade the complexity of the baseline RNNs.
+
+Accelerating inference in RNNs is difficult due to their inherently sequential nature, leading to the design of Quasi-Recurrent Neural Networks (Bradbury et al., 2017) and Simple Recurrent Units (Lei & Zhang, 2017), which relax the temporal dependency between consecutive steps. With the goal of speeding up RNN inference, LSTM-Jump (Yu et al., 2017) augments an LSTM cell with a classification layer that will decide how many steps to jump between RNN updates. Despite its promising results on text tasks, the model needs to be trained with REINFORCE (Williams, 1992), which requires defining a reasonable reward signal. Determining these rewards are non-trivial and may not necessarily generalize across tasks. Moreover, the number of tokens read between jumps, the maximum jump distance and the number of jumps allowed all need to be chosen in advance. These hyperparameters define a reduced set of subsequences that the model can sample, instead of allowing the network to learn any arbitrary sampling scheme. Unlike LSTM-Jump, our proposed approach is differentiable, thus not requiring any modifications to the loss function and simplifying the optimization process, and is not limited to a predefined set of sample selection patterns.
+
+# 3 MODEL DESCRIPTION
+
+An RNN takes an input sequence $\mathbf { x } = ( x _ { 1 } , \dots , x _ { T } )$ and generates a state sequence $\mathbf { s } = ( s _ { 1 } , \dots , s _ { T } )$ by iteratively applying a parametric state transition model $S$ from $t = 1$ to $T$ :
+
+$$
+s _ { t } = S ( s _ { t - 1 } , x _ { t } )
+$$
+
+We augment the network with a binary state update gate, $u _ { t } \in \{ 0 , 1 \}$ , selecting whether the state of the RNN will be updated $\mathit { u } _ { t } = 1$ ) or copied from the previous time step ${ { u } _ { t } } = 0$ ). At every time step $t$ , the probability $\tilde { u } _ { t + 1 } \in [ 0 , 1 ]$ of performing a state update at $t + 1$ is emitted. The resulting architecture is depicted in Figure 1 and can be characterized as follows:
+
+$$
+\begin{array} { r l } & { u _ { t } = f _ { b i n a r i z e } ( \tilde { u } _ { t } ) } \\ & { s _ { t } = u _ { t } \cdot S ( s _ { t - 1 } , x _ { t } ) + ( 1 - u _ { t } ) \cdot s _ { t - 1 } } \\ & { \Delta \tilde { u } _ { t } = \sigma ( W _ { p } s _ { t } + b _ { p } ) } \\ & { \tilde { u } _ { t + 1 } = u _ { t } \cdot \Delta \tilde { u } _ { t } + ( 1 - u _ { t } ) \cdot ( \tilde { u } _ { t } + \operatorname* { m i n } ( \Delta \tilde { u } _ { t } , 1 - \tilde { u } _ { t } ) ) } \end{array}
+$$
+
+where $W _ { p }$ is a weights vector, $b _ { p }$ is a scalar bias, $\sigma$ is the sigmoid function and $f _ { b i n a r i z e } : [ 0 , 1 ] $ $\{ 0 , 1 \}$ binarizes the input value. Should the network be composed of several layers, some columns of $W _ { p }$ can be fixed to 0 so that $\Delta \tilde { u } _ { t }$ depends only on the states of a subset of layers (see Section 4.3 for an example with two layers). We implement $f _ { b i n a r i z e }$ as a deterministic step function $u _ { t } =$ round $( \tilde { u } _ { t } )$ , although a stochastic sampling from a Bernoulli distribution $u _ { t } \sim$ Bernoulli $( \tilde { u } _ { t } )$ would be possible as well.
+
+The model formulation encodes the observation that the likelihood of requesting a new input to update the state increases with the number of consecutively skipped samples. Whenever a state update is omitted, the pre-activation of the state update gate for the following time step, $\tilde { u } _ { t + 1 }$ , is incremented by $\Delta \tilde { u } _ { t }$ . On the other hand, if a state update is performed, the accumulated value is flushed and $\tilde { u } _ { t + 1 } = \Delta \tilde { u } _ { t }$ .
+
+The number of skipped time steps can be computed ahead of time. For the particular formulation used in this work, where $f _ { b i n a r i z e }$ is implemented by means of a rounding function, the number of skipped samples after performing a state update at time step $t$ is given by:
+
+$$
+N _ { s k i p } ( t ) = \operatorname* { m i n } \{ n : n \cdot \Delta \tilde { u } _ { t } \geq 0 . 5 \} - 1
+$$
+
+where $n \in \mathbb { Z } ^ { + }$ . This enables more efficient implementations where no computation at all is performed whenever $u _ { t } = 0$ . These computational savings are possible because $\Delta \hat { \boldsymbol u } _ { t } = \sigma ( W _ { p } \boldsymbol s _ { t } + \boldsymbol b _ { p } ) =$ $\sigma ( W _ { p } s _ { t - 1 } + b _ { p } ) = \Delta \tilde { u } _ { t - 1 }$ when $u _ { t } = 0$ and there is no need to evaluate it again, as depicted in Figure 1d.
+
+There are several advantages in reducing the number of RNN updates. From the computational standpoint, fewer updates translates into fewer required sequential operations to process an input signal, leading to faster inference and reduced energy consumption. Unlike some other models that aim to reduce the average number of operations per step (Neil et al., 2016; Jernite et al., 2017), ours enables skipping steps completely. Replacing RNN updates with copy operations increases the memory of the network and its ability to model long term dependencies even for gated units, since the exponential memory decay observed in LSTM and GRU (Neil et al., 2016) is alleviated. During training, gradients are propagated through fewer updating time steps, providing faster convergence in some tasks involving long sequences. Moreover, the proposed model is orthogonal to recent advances in RNNs and could be used in conjunction with such techniques, e.g. normalization (Cooijmans et al., 2017; Ba et al., 2016), regularization (Zaremba et al., 2015; Krueger et al., 2017), variable computation (Jernite et al., 2017; Neil et al., 2016) or even external memory (Graves et al., 2014; Weston et al., 2014).
+
+![](images/4c8bbb74368a7356747a0b01aa4070e7d27939c71f05129ebbb30ef959258167.jpg)  
+Figure 1: Model architecture of the proposed Skip RNN. (a) Complete Skip RNN architecture, where the computation graph at time step $t$ is conditioned on $u _ { t }$ . $\mathbf { ( b ) }$ Architecture when the state is updated, i.e. $u _ { t } = 1$ . (c) Architecture when the update step is skipped and the previous state is copied, i.e. $u _ { t } = 0$ . (d) In practice, redundant computation is avoided by propagating $\Delta \tilde { u } _ { t }$ between time steps when $u _ { t } = 0$ .
+
+# 3.1 ERROR GRADIENTS
+
+The whole model is differentiable except for $f _ { b i n a r i z e }$ , which outputs binary values. A common method for optimizing functions involving discrete variables is REINFORCE (Williams, 1992), although several estimators have been proposed for the particular case of neurons with binary outputs (Bengio et al., 2013). We select the straight-through estimator (Hinton, 2012; Bengio et al., 2013), which consists of approximating the step function by the identity when computing gradients during the backward pass:
+
+$$
+\frac { \partial f _ { b i n a r i z e } \left( x \right) } { \partial x } = 1
+$$
+
+This yields a biased estimator that has proven more efficient than other unbiased but high-variance estimators such as REINFORCE (Bengio et al., 2013) and has been successfully applied in different works (Courbariaux et al., 2016; Chung et al., 2017). By using the straight-through estimator as the backward pass for $f _ { b i n a r i z e }$ , all the model parameters can be trained to minimize the target loss function with standard backpropagation and without defining any additional supervision or reward signal.
+
+# 3.2 LIMITING COMPUTATION
+
+The Skip RNN is able to learn when to update or copy the state without explicit information about which samples are useful to solve the task at hand. However, a different operating point on the trade-off between performance and number of processed samples may be required depending on the application, e.g. one may be willing to sacrifice a few accuracy points in order to run faster on machines with a low computational power, or to reduce energy impact on portable devices. The proposed model can be encouraged to perform fewer state updates through additional loss terms, a common practice in neural networks with dynamically allocated computation (Liu & Deng, 2017; McGill & Perona, 2017; Graves, 2016; Jernite et al., 2017). In particular, we consider a cost per sample condition
+
+$$
+L _ { b u d g e t } = \lambda \cdot \sum _ { t = 1 } ^ { T } u _ { t } ,
+$$
+
+where $L _ { b u d g e t }$ is the cost associated to a single sequence, $\lambda$ is the cost per sample and $T$ is the sequence length. This formulation bears a similarity to weight decay regularization, where the network is encouraged to slowly converge toward a solution where the norm of the weights is small. Similarly, in this case the network is encouraged to converge toward a solution where fewer state updates are required.
+
+Although the above budget formulation is extensively studied in our experiments, other budget loss terms can be used depending on the application. For instance, a specific number of samples may be encouraged by applying a $L _ { 1 }$ or $L _ { 2 }$ loss between the target value and the number of updates per sequence, $et { } { ' } \sum _ { t = 1 } ^ { T } u _ { t }$ .
+
+# 4 EXPERIMENTS
+
+In the following section, we investigate the advantages of adding this state skipping to two common RNN architectures, LSTM and GRU, for a variety of tasks. In addition to the evaluation metric for each task, we report the number of RNN state updates (i.e., the number of elements in the input sequence used by the model) and the number of floating point operations (FLOPs) as measures of the computational load for each model. Since skipping an RNN update results in ignoring its corresponding input, we will refer to the number of updates and the number of used samples (i.e. elements in a sequence) interchangeably. With the goal of studying the effect of skipping state updates on the learning capability of the networks, we also introduce a baseline which skips a state update with probability $p _ { s k i p }$ . We tune the skipping probability to obtain models that perform a similar number of state updates to the Skip RNN models.
+
+Training is performed with Adam (Kingma & Ba, 2014), learning rate of $1 0 ^ { - 4 }$ , $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } =$ 0.999 and $\epsilon = 1 0 ^ { - 8 }$ on batches of 256. Gradient clipping (Pascanu et al., 2013) with a threshold of 1 is applied to all trainable variables. Bias $b _ { p }$ in Equation 4 is initialized to 1, so that all samples are used at the beginning of training2. The initial hidden state $s _ { 0 }$ is learned during training, whereas $\tilde { u } _ { 0 }$ is set to a constant value of 1 in order to force the first update at $t = 1$ .
+
+Experiments are implemented with TensorFlow3 and run on a single NVIDIA K80 GPU.
+
+# 4.1 ADDING TASK
+
+We revisit one of the original LSTM tasks (Hochreiter & Schmidhuber, 1997), where the network is given a sequence of (value, marker) tuples. The desired output is the addition of only two values that are marked with a 1, whereas those marked with a 0 need to be ignored. We follow the experimental setup in Neil et al. (2016), where the first marker is randomly placed among the first $10 \%$ of samples (drawn with uniform probability) and the second one is placed among the last half of samples (drawn with uniform probability). This marker distribution yields sequences where at least $40 \%$ of the samples are distractors and provide no useful information at all. However, it is worth noting that in this task the risk of missing a marker is very large as compared to the benefits of working on shorter subsequences.
+
+Table 1: Results for the adding task, displayed as $m e a n \pm s t d$ over four different runs. The task is considered to be solved if the MSE is at least two orders of magnitude below the variance of the output distribution.   
+
+<table><tr><td>Model</td><td>Task solved</td><td> State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>Yes</td><td>100.0%± 0.0%</td><td>2.46 ×106</td></tr><tr><td>LSTM (pskip = 0.2)</td><td>No</td><td>80.0%±0.1%</td><td>1.97 × 106</td></tr><tr><td>LSTM (Pskip = 0.5)</td><td>No</td><td>50.1%± 0.1%</td><td>1.23 × 106</td></tr><tr><td>Skip LSTM, λ= 0</td><td>Yes</td><td>81.1% ± 3.6%</td><td>2.00 ×106</td></tr><tr><td>Skip LSTM,λ= 10-5</td><td>Yes</td><td>53.9%± 2.1%</td><td>1.33 × 106</td></tr><tr><td>GRU</td><td>Yes</td><td>100.0% ± 0.0%</td><td>1.85 × 106</td></tr><tr><td>GRU (pskip = 0.02)</td><td>No</td><td>98.0%±0.0%</td><td>1.81 × 106</td></tr><tr><td>GRU (pskip = 0.5)</td><td>No</td><td>49.9%± 0.6%</td><td>9.25×105</td></tr><tr><td>Skip GRU, λ = 0</td><td>Yes</td><td>97.9%± 3.2%</td><td>1.81 × 106</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>Yes</td><td>50.7%± 2.6%</td><td>9.40 × 105</td></tr></table>
+
+We train RNN models with 110 units each on sequences of length 50, where the values are uniformly drawn from $\mathcal { U } ( - 0 . 5 , 0 . 5 )$ . The final RNN state is fed to a fully connected layer that regresses the scalar output. The model is trained to minimize the Mean Squared Error (MSE) between the output and the ground truth. We consider that a model is able to solve the task when its MSE on a held-out set of examples is at least two orders of magnitude below the variance of the output distribution. This criterion is a stricter version of the one followed by Hochreiter & Schmidhuber (1997).
+
+While all models learn to solve the task, results in Table 1 show that Skip RNN models are able to do so with roughly half of the updates of their corresponding counterparts. We observed that the models using fewer updates never miss any marker, since the penalization in terms of MSE would be very large (see Section B.1 for examples). This is confirmed by the poor performance of the baselines that randomly skip state updates, which are not able to solve the tasks even when the skipping probability is low. Skip RNN models learn to skip most of the samples in the $40 \%$ of the sequence where there are no markers. Moreover, most updates are skipped once the second marker is found, since all the relevant information in the sequence has already been seen. This last pattern provides evidence that the proposed models effectively learn whether to update or copy the hidden state based on the input sequence, as opposed to learning biases in the dataset only. As a downside, Skip RNN models show some difficulties skipping a large number of updates at once, probably due to the cumulative nature of $\tilde { u } _ { t }$ .
+
+# 4.2 MNIST CLASSIFICATION FROM A SEQUENCE OF PIXELS
+
+The MNIST handwritten digits classification benchmark (LeCun et al., 1998) is traditionally addressed with Convolutional Neural Networks (CNNs) that efficiently exploit spatial dependencies through weight sharing. By flattening the $2 8 \times 2 8$ images into 784-d vectors, however, it can be reformulated as a challenging task for RNNs where long term dependencies need to be leveraged (Le et al., 2015b). We follow the standard data split and set aside 5,000 training samples for validation purposes. After processing all pixels with an RNN with 110 units, the last hidden state is fed into a linear classifier predicting the digit class. All models are trained for 600 epochs to minimize cross-entropy loss.
+
+Table 2 summarizes classification results on the test set after 600 epochs of training. Skip RNNs are not only able to solve the task using fewer updates than their counterparts, but also show a lower variation among runs and train faster (see Figure 2). We hypothesize that skipping updates make the Skip RNNs work on shorter subsequences, simplifying the optimization process and allowing the networks to capture long term dependencies more easily. A similar behavior was observed for Phased LSTM, where increasing the sparsity of cell updates accelerates training for very long sequences (Neil et al., 2016). However, the drop in performance observed in the models where the state updates are skipped randomly suggests that learning which samples to use is a key component in the performance of Skip RNN.
+
+<table><tr><td>Model</td><td>Accuracy</td><td>State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>0.910 ± 0.045</td><td>784.00 ± 0.00</td><td>3.83×107</td></tr><tr><td>LSTM (pskip = 0.5)</td><td>0.893 ± 0.003</td><td>392.03 ± 0.05</td><td>1.91 × 107</td></tr><tr><td>Skip LSTM,X= 10-4</td><td>0.973 ± 0.002</td><td>379.38 ± 33.09</td><td>1.86 ×107</td></tr><tr><td>GRU</td><td>0.968 ± 0.013</td><td>784.00 ±0.00</td><td>2.87×107</td></tr><tr><td>GRU (p skip = 0.5)</td><td>0.912 ±0.004</td><td>391.86 ± 0.14</td><td>1.44 × 107</td></tr><tr><td>Skip GRU,X=10-4</td><td>0.976 ± 0.003</td><td>392.62 ± 26.48</td><td>1.44 × 107</td></tr><tr><td>TANH-RNN (Le et al., 2015a)</td><td>0.350</td><td>784.00</td><td></td></tr><tr><td>iRNN (Le et al., 2015a)</td><td>0.970</td><td>784.00</td><td></td></tr><tr><td>uRNN (Arjovsky et al., 2016)</td><td>0.951</td><td>784.00</td><td></td></tr><tr><td>sTANH-RNN (Zhang et al., 2016)</td><td>0.981</td><td>784.00</td><td></td></tr><tr><td>LSTM (Cooijmans et al., 2017)</td><td>0.989</td><td>784.00</td><td></td></tr><tr><td>BN-LSTM (Cooijmans et al., 2017)</td><td>0.990</td><td>784.00</td><td></td></tr></table>
+
+Table 2: Accuracy, used samples and average FLOPs per sequence at inference on the test set of MNIST after 600 epochs of training. Results are displayed as $m e a n \pm s t d$ over four different runs.
+
+![](images/9fba09fd879c43112caf70dc4538bb8c8e2159ecfd6ea365bece1928549acb1b.jpg)  
+Figure 2: Accuracy evolution during training on the validation set of MNIST. The Skip GRU exhibits lower variance and faster convergence than the baseline GRU. A similar behavior is observed for LSTM and Skip LSTM, but omitted for clarity. Shading shows maximum and minimum over 4 runs, while dark lines indicate the mean.
+
+The performance of RNN models on this task can be boosted through techniques like recurrent batch normalization (Cooijmans et al., 2017) or recurrent skip coefficients (Zhang et al., 2016). Cooijmans et al. (2017) show how an LSTM with specific weight initialization schemes for improved gradient flow (Le et al., 2015a; Arjovsky et al., 2016) can reach accuracy rates of up to $0 . 9 \hat { 8 } 9 \%$ . Note that these techniques are orthogonal to skipping state updates and Skip RNN models could benefit from them as well.
+
+Sequences of pixels can be reshaped back into 2D images, allowing to visualize the samples used by the RNNs as a sort of hard visual attention model ( $\mathrm { { X u } }$ et al., 2015). Examples such as the ones depicted in Figure 3 show how the model learns to skip pixels that are not discriminative, such as the padding regions in the top and bottom of images. Similarly to the qualitative results for the adding task (Section 4.1), attended samples vary depending on the particular input being given to the network.
+
+# 4.3 TEMPORAL ACTION LOCALIZATION ON CHARADES
+
+One popular approach to video analysis tasks today is to extract frame-level features with a CNN and modeling temporal dynamics with an RNN (Donahue et al., 2015; Yue-Hei $\mathrm { N g }$ et al., 2015). Videos are commonly recorded at high sampling rates, generating long sequences with strong temporal redundancies that are challenging for RNNs. Moreover, processing frames with a CNN is computationally expensive and may become prohibitive for high frame rates. These issues have been alleviated in previous works by using short clips (Donahue et al., 2015) or by downsampling the original data in order to cover long temporal spans without increasing the sequence length excessively (Yue-Hei $\mathrm { N g }$ et al., 2015). Instead of addressing the long sequence problem at the input data level, we let the network learn which frames need to be used.
+
+![](images/0f56669854424b159f8ca406c1931ba5f8c9bcb930aef3dbceb93dd4832102ab.jpg)  
+Figure 3: Sample usage examples for the Skip LSTM with $\lambda = 1 0 ^ { - 4 }$ on the test set of MNIST. Red pixels are used, whereas blue ones are skipped.
+
+Charades (Sigurdsson et al., 2016a) is a dataset containing 9,848 videos annotated for 157 action classes in a per-frame fashion. Frames are encoded using $f c 7$ features from the RGB stream of a Two-Stream CNN provided by the organizers of the challenge4, extracted at 6 fps. The encoded frames are fed into two stacked RNN layers with 256 units each and the hidden state in the last RNN layer is used to compute the update probability for the Skip RNN models. Since each frame may be annotated with zero or more classes, the networks are trained to minimize element-wise binary cross-entropy at every time step. Unlike the previous sequence tagging tasks, this setup allows us to evaluate the performance of Skip RNN on a task where the output is a sequence as well.
+
+Evaluation is performed following the setup by Sigurdsson et al. (2016c), but evaluating on 100 equally spaced frames instead of 25, and results are reported in Table 3. It is surprising that the GRU baselines that randomly skip state updates perform on par with their Skip GRU counterparts for low skipping probabilities. We hypothesize several reasons for this behavior, which was not observed in previous experiments: (1) there is a supervision signal at every time step and the inputs and (2) outputs are strongly correlated in consecutive frames. On the other hand, Skip RNN models clearly outperform the random methods when fewer updates are allowed. Note that this setup is far more challenging because of the longer time spans between updates, so properly distributing the state updates along the sequence is key to the performance of the models. Interestingly, Skip RNN models learn which frames need to be attended from RGB data and without having access to explicit motion information.
+
+Skip GRU tends to perform fewer state updates than Skip LSTM when the cost per sample is low or none. This behavior is the opposite of the one observed in the adding task (Section 4.1), which may be related to the observation that determining the best performing gated unit depends on the task at hand Chung et al. (2014). Indeed, GRU models consistently outperform LSTM ones on this task. This mismatch in the number of used samples is not observed for large values of $\lambda$ , as both Skip LSTM and Skip GRU converge to a comparable number of used samples.
+
+A previous work reports better action localization performance by integrating RGB and optical flow information as an input to an LSTM, reaching $9 . { \bar { 6 } } 0 \%$ mAP (Sigurdsson et al., 2016c). This boost in performance comes at the cost of roughly doubling the number of FLOPs and memory footprint of the CNN encoder, plus requiring the extraction of flow information during a preprocessing step. Interestingly, our model learns which frames need to be attended from RGB data and without having access to explicit motion information.
+
+<table><tr><td>Model</td><td>mAP(%)</td><td>State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>8.40</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>LSTM (pskip = 0.75)</td><td>8.11</td><td>43.3 ± 13.2</td><td>6.63 × 1011</td></tr><tr><td>LSTM (pskip = 0.90)</td><td>7.21</td><td>17.2 ± 6.1</td><td>2.65×1011</td></tr><tr><td>Skip LSTM,λ= 0</td><td>8.32</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>Skip LSTM,λ= 10-4</td><td>8.61</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>Skip LSTM,λ= 10-3</td><td>8.32</td><td>41.9 ± 11.3</td><td>6.41 × 1011</td></tr><tr><td>Skip LSTM,X = 10-2</td><td>7.86</td><td>17.4 ± 4.4</td><td>2.66 × 1011</td></tr><tr><td>GRU</td><td>8.70</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>GRU (pskip = 0.10)</td><td>8.94</td><td>155.6 ± 42.9</td><td>2.39 ×1012</td></tr><tr><td>GRU (pskip = 0.40)</td><td>8.81</td><td>103.6 ± 29.3</td><td>1.06 × 1012</td></tr><tr><td>GRU (pskip = 0.70)</td><td>8.42</td><td>51.9 ± 15.4</td><td>7.95 × 1011</td></tr><tr><td>GRU (pskip = 0.90)</td><td>7.09</td><td>17.3 ± 6.3</td><td>2.65×1011</td></tr><tr><td>Skip GRU,λ= 0</td><td>8.94</td><td>159.9 ± 46.9</td><td>2.45×1012</td></tr><tr><td>Skip GRU,入 = 10-4</td><td>8.76</td><td>100.8 ± 28.1</td><td>1.54 × 1012</td></tr><tr><td>Skip GRU,λ = 10-3</td><td>8.68</td><td>54.2 ± 16.2</td><td>8.29×1011</td></tr><tr><td>Skip GRU,λ = 10-2</td><td>7.95</td><td>18.4 ± 5.1</td><td>2.82 × 1011</td></tr></table>
+
+Table 3: Mean Average Precision (mAP), used samples and average FLOPs per sequence at inference on the validation set of Charades. The number of state updates is displayed as $m e a n \pm s t d$ over all the videos in the validation set.
+
+# 5 CONCLUSION
+
+We presented Skip RNNs as an extension to existing recurrent architectures enabling them to skip state updates thereby reducing the number of sequential operations in the computation graph. Unlike other approaches, all parameters in Skip RNN are trained with backpropagation. Experiments conducted with LSTMs and GRUs showed that Skip RNNs can match or in some cases even outperform the baseline models while relaxing their computational requirements. Skip RNNs provide faster and more stable training for long sequences and complex models, owing to gradients being backpropagated through fewer time steps resulting in a simpler optimization task. Moreover, the introduced computational savings are better suited for modern hardware than those methods that reduce the amount of computation required at each time step (Koutnik et al., 2014; Neil et al., 2016; Chung et al., 2017).
+
+# ACKNOWLEDGMENTS
+
+This work was partially supported by the Spanish Ministry of Economy and Competitivity and the European Regional Development Fund (ERDF) under contracts TEC2016-75976-R and TIN2015- 65316-P, by the BSC-CNS Severo Ochoa program SEV-2015-0493, and grant 2014-SGR-1051 by the Catalan Government. V´ıctor Campos was supported by Obra Social “la Caixa” through La Caixa-Severo Ochoa International Doctoral Fellowship program. We would also like to thank the technical support team at the Barcelona Supercomputing Center.
+
+# REFERENCES
+
+Amjad Almahairi, Nicolas Ballas, Tim Cooijmans, Yin Zheng, Hugo Larochelle, and Aaron Courville. Dynamic capacity networks. In ICML, 2016.
+
+Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In ICML, 2016.
+
+Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. arXiv preprint arXiv:1412.7755, 2014.
+
+Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016.
+
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015.
+
+Yoshua Bengio. Deep learning of representations: Looking forward. In SLSP, 2013.
+
+Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 1994.
+
+Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.
+
+Subhabrata Bhattacharya, Felix X Yu, and Shih-Fu Chang. Minimally needed evidence for complex event recognition in unconstrained videos. In ICMR, 2014.
+
+James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural networks. In ICLR, 2017.
+
+Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In CVPR, 2017.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In EMNLP, 2014.
+
+Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
+
+Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. In ICLR, 2017.
+
+Tim Cooijmans, Nicolas Ballas, Cesar Laurent, C¸ a ´ glar G ˘ ulc¸ehre, and Aaron Courville. Recurrent ¨ batch normalization. In ICLR, 2017.
+
+Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016.
+
+Andrew Davis and Itamar Arel. Low-rank approximations for conditional feedforward computation in deep neural networks. arXiv preprint arXiv:1312.4461, 2013.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.
+
+Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In CVPR, 2015.
+
+Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In ICASSP, 2013.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
+
+Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In NIPS, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Geoffrey Hinton. Neural networks for machine learning. Coursera video lectures, 2012.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016.
+
+Yacine Jernite, Edouard Grave, Armand Joulin, and Tomas Mikolov. Variable computation in recurrent neural networks. In ICLR, 2017.
+
+Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jan Koutnik, Klaus Greff, Faustino Gomez, and Juergen Schmidhuber. A clockwork rnn. In ICML, 2014.
+
+David Krueger, Tegan Maharaj, Janos Kram ´ ar, Mohammad Pezeshki, Nicolas Ballas, Nan Rose-´ mary Ke, Anirudh Goyal, Yoshua Bengio, Hugo Larochelle, Aaron Courville, et al. Zoneout: Regularizing rnns by randomly preserving hidden activations. In ICLR, 2017.
+
+Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015a.
+
+Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015b.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998.
+
+Tao Lei and Yu Zhang. Training rnns as fast as cnns. arXiv preprint arXiv:1709.02755, 2017.
+
+Lanlan Liu and Jia Deng. Dynamic deep neural networks: Optimizing accuracy-efficiency trade-offs by selective execution. arXiv preprint arXiv:1701.00299, 2017.
+
+Shayne Longpre, Sabeek Pradhan, Caiming Xiong, and Richard Socher. A way out of the odyssey: Analyzing and combining recent insights for lstms. arXiv preprint arXiv:1611.05104, 2016.
+
+Andrew L Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In ACL, 2011.
+
+Mason McGill and Pietro Perona. Deciding how to decide: Dynamic routing in artificial neural networks. In ICML, 2017.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013.
+
+Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In NIPS, 2014.
+
+Daniel Neil, Michael Pfeiffer, and Shih-Chii Liu. Phased LSTM: accelerating recurrent network training for long or event-based sequences. In NIPS, 2016.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In ICML, 2013.
+
+Colin Raffel and Dieterich Lawson. Training a subsampling mechanism in expectation. In ICLR Workshop Track, 2017.
+
+Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. In ICLR, 2017.
+
+Evan Shelhamer, Kate Rakelly, Judy Hoffman, and Trevor Darrell. Clockwork convnets for video semantic segmentation. arXiv preprint arXiv:1608.03609, 2016.
+
+Gunnar Sigurdsson, Gul Varol, Xiaolong Wang, Ali Farhadi, Ivan Laptev, and Abhinav Gupta. Hol- ¨ lywood in homes: Crowdsourcing data collection for activity understanding. In ECCV, 2016a.
+
+Gunnar A Sigurdsson, Xinlei Chen, and Abhinav Gupta. Learning visual storylines with skipping recurrent neural networks. In ECCV, 2016b.
+
+Gunnar A Sigurdsson, Santosh Divvala, Ali Farhadi, and Abhinav Gupta. Asynchronous temporal fields for action recognition. arXiv preprint arXiv:1612.06371, 2016c.
+
+Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In NIPS, 2014.
+
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012.
+
+Yu-Chuan Su and Kristen Grauman. Leaving some stones unturned: dynamic feature prioritization for activity detection in streaming video. In ECCV, 2016.
+
+Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In ICCV, 2015.
+
+Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015.
+
+Serena Yeung, Olga Russakovsky, Greg Mori, and Li Fei-Fei. End-to-end learning of action detection from frame glimpses in videos. In CVPR, 2016.
+
+Adams Wei Yu, Hongrae Lee, and Quoc V Le. Learning to skim text. In ACL, 2017.
+
+Joe Yue-Hei $\mathrm { N g }$ , Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In CVPR, 2015.
+
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. In ICLR, 2015.
+
+Saizheng Zhang, Yuhuai Wu, Tong Che, Zhouhan Lin, Roland Memisevic, Ruslan R Salakhutdinov, and Yoshua Bengio. Architectural complexity measures of recurrent neural networks. In NIPS, 2016.
+
+# A ADDITIONAL EXPERIMENTS
+
+# A.1 FREQUENCY DISCRIMINATION TASK
+
+In this experiment, the network is trained to classify between sinusoids whose period is in range $T \sim \mathcal { U } \left( 5 , 6 \right)$ milliseconds and those whose period is in range $T \sim \{ ( 1 , 5 ) \cup ( 6 , 1 0 0 ) \}$ milliseconds (Neil et al., 2016). Every sine wave with period $T$ has a random phase shift drawn from $\mathcal { U } ( 0 , T )$ . At every time step, the input to the network is a single scalar representing the amplitude of the signal. Since sinusoid are continuous signals, this tasks allows to study whether Skip RNNs converge to the same solutions when their parameters are fixed but the sampling period is changed. We study two different sampling periods, $\mathrm { \tilde { \it T } _ { 3 } } = \mathrm { \{ 0 . 5 , 1 \} }$ milliseconds, for each set of hyperparameters.
+
+We train RNNs with 110 units each on input signals of 100 milliseconds. Batches are stratified, containing the same number of samples for each class, yielding a $50 \%$ chance accuracy. The last state of the RNN is fed into a 2-way classifier and trained with cross-entropy loss. We consider that a model is able to solve the task when it achieves an accuracy over $9 9 \%$ on a held-out set of examples.
+
+Table 4 summarizes results for this task. When no cost per sample is set $\lambda = 0$ ), the number of updates differ under different sampling conditions. We attribute this behavior to the potentially large number of local minima in the cost function, since there are numerous subsampling patterns for which the task can be successfully solved and we are not explicitly encouraging the network to converge to a particular solution. On the other hand, when $\lambda > 0$ Skip RNN models with the same cost per sample use roughly the same number of input samples even when the sampling frequency is doubled. This is a desirable property, since solutions are robust to oversampled input signals. Qualitative results can be found in Section B.2.
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Ts = 1ms (length 100)</td><td colspan="2">Ts = O.5ms (length 200)</td></tr><tr><td>Task solved</td><td>State updates</td><td>Task solved</td><td> State updates</td></tr><tr><td>LSTM</td><td>Yes</td><td>100.0 ± 0.00</td><td>Yes</td><td>200.0 ± 0.00</td></tr><tr><td>Skip LSTM, λ= 0</td><td>Yes</td><td>55.5 ± 16.9</td><td>Yes</td><td>147.9 ± 27.0</td></tr><tr><td>Skip LSTM,λ = 10-5</td><td>Yes</td><td>47.4 ± 14.1</td><td>Yes</td><td>50.7 ± 16.8</td></tr><tr><td>Skip LSTM,λ = 10-4</td><td>Yes</td><td>12.7 ± 0.5</td><td>Yes</td><td>19.9 ± 1.5</td></tr><tr><td>GRU</td><td>Yes</td><td>100.0 ± 0.00</td><td>Yes</td><td>200.0 ±0.00</td></tr><tr><td>Skip GRU, λ = 0</td><td>Yes</td><td>73.7 ± 17.9</td><td>Yes</td><td>167.0 ± 18.3</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>Yes</td><td>51.9 ± 10.2</td><td>Yes</td><td>54.2 ± 4.4</td></tr><tr><td>Skip GRU, λ= 10-4</td><td>Yes</td><td>23.5 ± 6.2</td><td>Yes</td><td>22.5 ± 2.1</td></tr></table>
+
+Table 4: Results for the frequency discrimination task, displayed as $m e a n \pm s t d$ over four different runs. The task is considered to be solved if the classification accuracy is over $9 9 \%$ . Models with the same cost per sample $( \lambda > 0$ ) converge to a similar number of used samples under different sampling conditions.
+
+# A.2 SENTIMENT ANALYSIS ON IMDB
+
+The IMDB dataset (Maas et al., 2011) contains 25,000 training and 25,000 testing movie reviews annotated into two classes, positive and negative sentiment, with an approximate average length of 240 words per review. We set aside $1 5 \%$ of training data for validation purposes. Words are embedded into 300-d vector representations before being fed to an RNN with 128 units. The embedding matrix is initialized using pre-trained word2vec5 embeddings (Mikolov et al., 2013) when available, or random vectors drawn from $\mathcal { U } ( - 0 . 2 5 , 0 . 2 5 )$ otherwise (Kim, 2014). Dropout with rate 0.2 is applied between the last RNN state and the classification layer in order to reduce overfitting. We evaluate the models on sequences of length 200 and 400 by cropping longer sequences and padding shorter ones (Yu et al., 2017).
+
+Results on the test are reported in Table 5. In a task where it is hard to predict which input tokens will be discriminative, the Skip RNN models are able to achieve similar accuracy rates to the baseline models while reducing the number of required updates. These results highlight the trade-off between accuracy and the available computational budget, since a larger cost per sample results in lower accuracies. However, allowing the network to select which samples to use instead of cropping sequences at a given length boosts performance, as observed for the Skip LSTM (length 400, $\lambda =$ $1 0 ^ { { \bar { - 4 } } { \bar { \cdot } } }$ ), which achieves a higher accuracy than the baseline LSTM (length 200) while seeing roughly the same number of words per review. A similar behavior can be seen for the Skip RNN models with $\lambda = 1 0 ^ { - 3 }$ , where allowing them to select words from longer reviews boosts classification accuracy while using a comparable number of tokens per sequence.
+
+In order to reduce overfitting of large models, Miyato et al. (2017) leverage additional unlabeled data through adversarial training and achieve a state of the art accuracy of 0.941 on IMDB. For an extended analysis on how different experimental setups affect the performance of RNNs on this task, we refer the reader to (Longpre et al., 2016).
+
+Table 5: Accuracy and used samples on the test set of IMDB for different sequence lengths. Results are displayed as $m e a n \pm s t d$ over four different runs.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Length 200</td><td colspan="2">Length 400</td></tr><tr><td>Accuracy</td><td>State updates</td><td>Accuracy</td><td> State updates</td></tr><tr><td>LSTM</td><td>0.843 ± 0.003</td><td>200.00±0.00</td><td>0.868 ± 0.004</td><td>400.00 ± 0.00</td></tr><tr><td>Skip LSTM,λ= 0</td><td>0.844 ± 0.004</td><td>196.75 ± 5.63</td><td>0.866 ± 0.004</td><td>369.70 ± 19.35</td></tr><tr><td>Skip LSTM, X= 10-5</td><td>0.846 ± 0.004</td><td>197.15 ± 3.16</td><td>0.865 ± 0.001</td><td>380.62 ± 18.20</td></tr><tr><td>Skip LSTM,λ= 10-4</td><td>0.837 ± 0.006</td><td>164.65 ± 8.67</td><td>0.862 ± 0.003</td><td>186.30 ± 25.72</td></tr><tr><td>Skip LSTM,λ= 10-3</td><td>0.811 ± 0.007</td><td>73.85 ± 1.90</td><td>0.836 ± 0.007</td><td>84.22 ± 1.98</td></tr><tr><td>GRU</td><td>0.845 ± 0.006</td><td>200.00 ±0.00</td><td>0.862 ± 0.003</td><td>400.00 ± 0.00</td></tr><tr><td>Skip GRU,λ = 0</td><td>0.848 ±0.002</td><td>200.00 ±0.00</td><td>0.866 ±0.002</td><td>399.02 ±1.69</td></tr><tr><td>Skip GRU, λ= 10-5</td><td>0.842 ± 0.005</td><td>199.25 ± 1.30</td><td>0.862 ±0.008</td><td>398.00 ±2.06</td></tr><tr><td>Skip GRU, 入= 10-4</td><td>0.834 ± 0.006</td><td>180.97 ± 8.90</td><td>0.853 ± 0.011</td><td>314.30 ± 2.82</td></tr><tr><td>Skip GRU,λ = 10-3</td><td>0.800 ±0.007</td><td>106.15 ± 37.92</td><td>0.814 ± 0.005</td><td>99.12 ± 2.69</td></tr></table>
+
+# A.3 ACTION CLASSIFICATION ON UCF-101
+
+UCF-101 (Soomro et al., 2012) is a dataset containing 13,320 trimmed videos belonging to 101 different action categories. We use 10 seconds of video sampled at 25 fps, cropping longer ones and padding shorter examples with empty frames. Activations in the Global Average Pooling layer from a ResNet-50 (He et al., 2016) CNN pretrained on the ImageNet dataset (Deng et al., 2009) are used as frame-level features, which are fed into two stacked RNN layers with 512 units each. The weights in the CNN are not tuned during training to reduce overfitting. The hidden state in the last RNN layer is used to compute the update probability for the Skip RNN models.
+
+We evaluate the different models on the first split of UCF-101 and report results in Table 6. Skip RNN models do not only improve the classification accuracy with respect to the baseline, but require very few updates to do so, possibly due to the low motion between consecutive frames resulting in frame-level features with high temporal redundancy (Shelhamer et al., 2016). Moreover, Figure 4 shows how models performing fewer updates converge faster thanks to the gradients being preserved during longer spans when training with backpropagation through time.
+
+Non recurrent architectures for video action recognition that have achieved high performance on UCF-101 comprise CNNs with spatiotemporal kernels (Tran et al., 2015) or two-stream CNNs (Simonyan & Zisserman, 2014). Carreira & Zisserman (2017) show the benefits of expanding 2D CNN filters into 3D and pretraining on larger datasets, obtaining an accuracy of 0.845 when using RGB data only and 0.934 when incorporating optical flow information.
+
+<table><tr><td>Model</td><td> Accuracy</td><td> State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>0.671</td><td>250.0</td><td>9.52 ×1011</td></tr><tr><td>Skip LSTM, λ = 0</td><td>0.749</td><td>138.9</td><td>5.29×1011</td></tr><tr><td>Skip LSTM,λ= 10-5</td><td>0.757</td><td>24.2</td><td>9.21 × 1010</td></tr><tr><td>Skip LSTM, λ= 10-4</td><td>0.790</td><td>7.6</td><td>2.89×1010</td></tr><tr><td>GRU</td><td>0.791</td><td>250.0</td><td>9.51 × 1011</td></tr><tr><td>Skip GRU,λ = 0</td><td>0.796</td><td>124.2</td><td>4.73 × 1011</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>0.792</td><td>29.7</td><td>1.13 × 1011</td></tr><tr><td>Skip GRU,λ = 10-4</td><td>0.793</td><td>23.7</td><td>9.02 ×1010</td></tr><tr><td>I3D (RGB) (Carreira &amp; Zisserman, 2017)</td><td>0.845</td><td>=</td><td></td></tr><tr><td>Two-stream I3D (Carreira &amp; Zisserman, 2017)</td><td>0.934</td><td>■</td><td></td></tr></table>
+
+Table 6: Accuracy, used samples and average FLOPs per sequence at inference on the validation set of UCF-101 (split 1).
+
+![](images/fceb38d809e5cfa29a3604ba1e90bcef2f072d685491e6e5555c418bf329335c.jpg)  
+Figure 4: Accuracy evolution during the first 300 training epochs on the validation set of UCF-101 (split 1). Skip LSTM models converge much faster than the baseline LSTM.
+
+# B QUALITATIVE RESULTS
+
+This appendix contains additional qualitative results for the Skip RNN models.
+
+# B.1 ADDING TASK
+
+![](images/d6521d4fbc04697107e8cda3c1975b53916e50b9a1428f04e8dd4778b6581024.jpg)  
+Figure 5: Sample usage examples for the Skip GRU with $\lambda = 1 0 ^ { - 5 }$ on the adding task. Red dots indicate used samples, whereas blue ones are skipped.
+
+![](images/c2799b3b795938bede8847ce47def1d327e5b232e367c05ec310b8af37e0c523.jpg)  
+Figure 6: Sample usage examples for the Skip LSTM with $\lambda = 1 0 ^ { - 4 }$ on the frequency discrimination task with $T _ { s } = 0 . 5 \mathrm { m s }$ . Red dots indicate used samples, whereas blue ones are skipped. The network learns that using the first samples is enough to classify the frequency of the sine waves, in contrast to a uniform downsampling that may result in aliasing.

parse/train/HkwVAXyCW/HkwVAXyCW_content_list.json

@@ -0,0 +1,1805 @@
+[
+    {
+        "type": "text",
+        "text": "SKIP RNN: LEARNING TO SKIP STATE UPDATES IN RECURRENT NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            789,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "V´ıctor Campos∗†, Brendan $\\mathbf { J o u } ^ { \\ddag }$ , Xavier Giro-i-Nieto ´ §, Jordi Torres†, Shih-Fu ChangΓ †Barcelona Supercomputing Center, ‡Google Inc, §Universitat Politecnica de Catalunya, \\` ΓColumbia University {victor.campos, jordi.torres}@bsc.es, bjou@google.com, xavier.giro@upc.edu, shih.fu.chang@columbia.edu ",
+        "bbox": [
+            186,
+            165,
+            784,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            186,
+            692,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            286,
+            544,
+            301
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent Neural Networks (RNNs) continue to show outstanding performance in sequence modeling tasks. However, training RNNs on long sequences often face challenges like slow inference, vanishing gradients and difficulty in capturing long term dependencies. In backpropagation through time settings, these issues are tightly coupled with the large, sequential computational graph resulting from unfolding the RNN in time. We introduce the Skip RNN model which extends existing RNN models by learning to skip state updates and shortens the effective size of the computational graph. This model can also be encouraged to perform fewer state updates through a budget constraint. We evaluate the proposed model on various tasks and show how it can reduce the number of required RNN updates while preserving, and sometimes even improving, the performance of the baseline RNN models. Source code is publicly available at https://imatge-upc. github.io/skiprnn-2017-telecombcn/. ",
+        "bbox": [
+            233,
+            315,
+            764,
+            497
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            336,
+            539
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recurrent Neural Networks (RNNs) have become the standard approach for practitioners when addressing machine learning tasks involving sequential data. Such success has been enabled by the appearance of larger datasets, more powerful computing resources and improved architectures and training algorithms. Gated units, such as the Long Short-Term Memory (Hochreiter & Schmidhuber, 1997) (LSTM) and the Gated Recurrent Unit (Cho et al., 2014) (GRU), were designed to deal with the vanishing gradients problem commonly found in RNNs (Bengio et al., 1994). These architectures have been popularized, in part, due to their impressive results on a variety of tasks in machine translation (Bahdanau et al., 2015), language modeling (Zaremba et al., 2015) and speech recognition (Graves et al., 2013). ",
+        "bbox": [
+            174,
+            554,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Some of the main challenges of RNNs are in their training and deployment when dealing with long sequences, due to their inherently sequential behaviour. These challenges include throughput degradation, slower convergence during training and memory leakage, even for gated architectures (Neil et al., 2016). Sequence shortening techniques, which can be seen as a sort of conditional computation (Bengio et al., 2013; Bengio, 2013; Davis & Arel, 2013) in time, can alleviate these issues. The most common approaches, such as cropping discrete signals or reducing the sampling rate in continuous signals, are based on heuristics and can be suboptimal. In contrast, we propose a model that is able to learn which samples (i.e., elements in the input sequence) need to be used in order to solve the target task. Consider a video understanding task as an example: scenes with large motion may benefit from high frame rates, whereas only a few frames are needed to capture the semantics of a mostly static scene. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of this work is a novel modification for existing RNN architectures that allows them to skip state updates, decreasing the number of sequential operations performed, without requiring any additional supervision signal. This model, called Skip RNN, adaptively determines whether the state needs to be updated or copied to the next time step. We show how the network can be encouraged to perform fewer state updates by adding a penalization term during training, allowing us to train models under different computation budgets. The proposed modification can generally be integrated with any RNN and we show, in this paper, implementations with well-known RNNs, namely LSTM and GRU. The resulting models show promising results on a series of sequence modeling tasks. In particular, we evaluate the proposed Skip RNN architecture on six sequence learning problems: an adding task, sine wave frequency discrimination, digit classification, sentiment analysis in movie reviews, action classification in video, and temporal action localization in video1. ",
+        "bbox": [
+            174,
+            845,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            224,
+            341,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Conditional computation has been shown to gradually increase model capacity without proportional increases in computational cost by exploiting certain computation paths for each input (Bengio et al., 2013; Liu & Deng, 2017; Almahairi et al., 2016; McGill & Perona, 2017; Shazeer et al., 2017). This idea has been extended in the temporal domain, such as in learning how many times an input needs to be ”pondered” before moving to the next one (Graves, 2016) or designing RNN architectures whose number of layers depend on the input data (Chung et al., 2017). Other works have addressed time-dependent computation in RNNs by updating only a fraction of the hidden states based on the current hidden state and input (Jernite et al., 2017), or following periodic patterns (Koutnik et al., 2014; Neil et al., 2016). However, due to the inherently sequential nature of RNNs and the parallel computation capabilities of modern hardware, reducing the size of the matrices involved in the computations performed at each time step generally has not accelerated inference as dramatically as hoped. The proposed Skip RNN model can be seen as form of conditional computation in time, where the computation associated to the RNN updates may or may not be executed at every time step. This idea is related to the UPDATE and COPY operations in hierarchical multiscale RNNs (Chung et al., 2017), but applied to the whole stack of RNN layers at the same time. This difference is key to allowing our approach to skip input samples, effectively reducing sequential computation and shielding the hidden state over longer time lags. Learning whether to update or copy the hidden state through time steps can be seen as a learnable Zoneout mask (Krueger et al., 2017) which is shared between all the units in the hidden state. Similarly, it can be interpreted as an input-dependent recurrent version of stochastic depth (Huang et al., 2016). ",
+        "bbox": [
+            173,
+            257,
+            825,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Selecting parts of the input signal is similar in spirit to the hard attention mechanisms that have been applied to image regions (Mnih et al., 2014), where only some patches of the input image are attended in order to generate captions (Xu et al., 2015) or detect objects (Ba et al., 2014). Our model can be understood as generating a hard temporal attention mask on-the-fly given previously seen samples, deciding which time steps should be attended and operating on a subset of input samples. Subsampling input sequences has been explored for visual storylines generation (Sigurdsson et al., 2016b), although jointly optimizing the RNN weights and the subsampling mechanism is often computationally infeasible and they use an Expectation-Maximization algorithm instead. Similar research has been conducted for video analysis tasks, discovering minimally needed evidence for event recognition (Bhattacharya et al., 2014) and training agents that decide which frames need to be observed in order to localize actions in time (Yeung et al., 2016; Su & Grauman, 2016). Motivated by the advantages of training recurrent models on shorter subsequences, efforts have been conducted on learning differentiable subsampling mechanisms (Raffel & Lawson, 2017), although the computational complexity of the proposed method precludes its application to long input sequences. In contrast, our proposed method can be trained with backpropagation and does not degrade the complexity of the baseline RNNs. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Accelerating inference in RNNs is difficult due to their inherently sequential nature, leading to the design of Quasi-Recurrent Neural Networks (Bradbury et al., 2017) and Simple Recurrent Units (Lei & Zhang, 2017), which relax the temporal dependency between consecutive steps. With the goal of speeding up RNN inference, LSTM-Jump (Yu et al., 2017) augments an LSTM cell with a classification layer that will decide how many steps to jump between RNN updates. Despite its promising results on text tasks, the model needs to be trained with REINFORCE (Williams, 1992), which requires defining a reasonable reward signal. Determining these rewards are non-trivial and may not necessarily generalize across tasks. Moreover, the number of tokens read between jumps, the maximum jump distance and the number of jumps allowed all need to be chosen in advance. These hyperparameters define a reduced set of subsequences that the model can sample, instead of allowing the network to learn any arbitrary sampling scheme. Unlike LSTM-Jump, our proposed approach is differentiable, thus not requiring any modifications to the loss function and simplifying the optimization process, and is not limited to a predefined set of sample selection patterns. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL DESCRIPTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            193,
+            390,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An RNN takes an input sequence $\\mathbf { x } = ( x _ { 1 } , \\dots , x _ { T } )$ and generates a state sequence $\\mathbf { s } = ( s _ { 1 } , \\dots , s _ { T } )$ by iteratively applying a parametric state transition model $S$ from $t = 1$ to $T$ : ",
+        "bbox": [
+            173,
+            223,
+            823,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0affabea2497928af8e5edb44c935066b789f07a345e961fda212d76532941b8.jpg",
+        "text": "$$\ns _ { t } = S ( s _ { t - 1 } , x _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            442,
+            271,
+            555,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We augment the network with a binary state update gate, $u _ { t } \\in \\{ 0 , 1 \\}$ , selecting whether the state of the RNN will be updated $\\mathit { u } _ { t } = 1$ ) or copied from the previous time step ${ { u } _ { t } } = 0$ ). At every time step $t$ , the probability $\\tilde { u } _ { t + 1 } \\in [ 0 , 1 ]$ of performing a state update at $t + 1$ is emitted. The resulting architecture is depicted in Figure 1 and can be characterized as follows: ",
+        "bbox": [
+            174,
+            295,
+            823,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b1921d539e3de313a42b8e6f1f7ef09839a8c5efb2f1340ab008566bb4c8ca2.jpg",
+        "text": "$$\n\\begin{array} { r l } & { u _ { t } = f _ { b i n a r i z e } ( \\tilde { u } _ { t } ) } \\\\ & { s _ { t } = u _ { t } \\cdot S ( s _ { t - 1 } , x _ { t } ) + ( 1 - u _ { t } ) \\cdot s _ { t - 1 } } \\\\ & { \\Delta \\tilde { u } _ { t } = \\sigma ( W _ { p } s _ { t } + b _ { p } ) } \\\\ & { \\tilde { u } _ { t + 1 } = u _ { t } \\cdot \\Delta \\tilde { u } _ { t } + ( 1 - u _ { t } ) \\cdot ( \\tilde { u } _ { t } + \\operatorname* { m i n } ( \\Delta \\tilde { u } _ { t } , 1 - \\tilde { u } _ { t } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            372,
+            681,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { p }$ is a weights vector, $b _ { p }$ is a scalar bias, $\\sigma$ is the sigmoid function and $f _ { b i n a r i z e } : [ 0 , 1 ] $ $\\{ 0 , 1 \\}$ binarizes the input value. Should the network be composed of several layers, some columns of $W _ { p }$ can be fixed to 0 so that $\\Delta \\tilde { u } _ { t }$ depends only on the states of a subset of layers (see Section 4.3 for an example with two layers). We implement $f _ { b i n a r i z e }$ as a deterministic step function $u _ { t } =$ round $( \\tilde { u } _ { t } )$ , although a stochastic sampling from a Bernoulli distribution $u _ { t } \\sim$ Bernoulli $( \\tilde { u } _ { t } )$ would be possible as well. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The model formulation encodes the observation that the likelihood of requesting a new input to update the state increases with the number of consecutively skipped samples. Whenever a state update is omitted, the pre-activation of the state update gate for the following time step, $\\tilde { u } _ { t + 1 }$ , is incremented by $\\Delta \\tilde { u } _ { t }$ . On the other hand, if a state update is performed, the accumulated value is flushed and $\\tilde { u } _ { t + 1 } = \\Delta \\tilde { u } _ { t }$ . ",
+        "bbox": [
+            174,
+            541,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The number of skipped time steps can be computed ahead of time. For the particular formulation used in this work, where $f _ { b i n a r i z e }$ is implemented by means of a rounding function, the number of skipped samples after performing a state update at time step $t$ is given by: ",
+        "bbox": [
+            174,
+            619,
+            825,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2f250225df61fb023cb2dfead9c3e7d3c9964e72426f0ce955d482f091d9f9c3.jpg",
+        "text": "$$\nN _ { s k i p } ( t ) = \\operatorname* { m i n } \\{ n : n \\cdot \\Delta \\tilde { u } _ { t } \\geq 0 . 5 \\} - 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            662,
+            633,
+            679
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $n \\in \\mathbb { Z } ^ { + }$ . This enables more efficient implementations where no computation at all is performed whenever $u _ { t } = 0$ . These computational savings are possible because $\\Delta \\hat { \\boldsymbol u } _ { t } = \\sigma ( W _ { p } \\boldsymbol s _ { t } + \\boldsymbol b _ { p } ) =$ $\\sigma ( W _ { p } s _ { t - 1 } + b _ { p } ) = \\Delta \\tilde { u } _ { t - 1 }$ when $u _ { t } = 0$ and there is no need to evaluate it again, as depicted in Figure 1d. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are several advantages in reducing the number of RNN updates. From the computational standpoint, fewer updates translates into fewer required sequential operations to process an input signal, leading to faster inference and reduced energy consumption. Unlike some other models that aim to reduce the average number of operations per step (Neil et al., 2016; Jernite et al., 2017), ours enables skipping steps completely. Replacing RNN updates with copy operations increases the memory of the network and its ability to model long term dependencies even for gated units, since the exponential memory decay observed in LSTM and GRU (Neil et al., 2016) is alleviated. During training, gradients are propagated through fewer updating time steps, providing faster convergence in some tasks involving long sequences. Moreover, the proposed model is orthogonal to recent advances in RNNs and could be used in conjunction with such techniques, e.g. normalization (Cooijmans et al., 2017; Ba et al., 2016), regularization (Zaremba et al., 2015; Krueger et al., 2017), variable computation (Jernite et al., 2017; Neil et al., 2016) or even external memory (Graves et al., 2014; Weston et al., 2014). ",
+        "bbox": [
+            173,
+            742,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c8bbb74368a7356747a0b01aa4070e7d27939c71f05129ebbb30ef959258167.jpg",
+        "image_caption": [
+            "Figure 1: Model architecture of the proposed Skip RNN. (a) Complete Skip RNN architecture, where the computation graph at time step $t$ is conditioned on $u _ { t }$ . $\\mathbf { ( b ) }$ Architecture when the state is updated, i.e. $u _ { t } = 1$ . (c) Architecture when the update step is skipped and the previous state is copied, i.e. $u _ { t } = 0$ . (d) In practice, redundant computation is avoided by propagating $\\Delta \\tilde { u } _ { t }$ between time steps when $u _ { t } = 0$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            103,
+            802,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 ERROR GRADIENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            349,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The whole model is differentiable except for $f _ { b i n a r i z e }$ , which outputs binary values. A common method for optimizing functions involving discrete variables is REINFORCE (Williams, 1992), although several estimators have been proposed for the particular case of neurons with binary outputs (Bengio et al., 2013). We select the straight-through estimator (Hinton, 2012; Bengio et al., 2013), which consists of approximating the step function by the identity when computing gradients during the backward pass: ",
+        "bbox": [
+            173,
+            587,
+            825,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93da5bd347b2f42e0e09cc6128b185468bac0cd85ac0bd23d9896063f31fb0ab.jpg",
+        "text": "$$\n\\frac { \\partial f _ { b i n a r i z e } \\left( x \\right) } { \\partial x } = 1\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            688,
+            563,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This yields a biased estimator that has proven more efficient than other unbiased but high-variance estimators such as REINFORCE (Bengio et al., 2013) and has been successfully applied in different works (Courbariaux et al., 2016; Chung et al., 2017). By using the straight-through estimator as the backward pass for $f _ { b i n a r i z e }$ , all the model parameters can be trained to minimize the target loss function with standard backpropagation and without defining any additional supervision or reward signal. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 LIMITING COMPUTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            387,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Skip RNN is able to learn when to update or copy the state without explicit information about which samples are useful to solve the task at hand. However, a different operating point on the trade-off between performance and number of processed samples may be required depending on the application, e.g. one may be willing to sacrifice a few accuracy points in order to run faster on machines with a low computational power, or to reduce energy impact on portable devices. The proposed model can be encouraged to perform fewer state updates through additional loss terms, a common practice in neural networks with dynamically allocated computation (Liu & Deng, 2017; McGill & Perona, 2017; Graves, 2016; Jernite et al., 2017). In particular, we consider a cost per sample condition ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da0c2732b4183743a430c139613b3e21dec3313d9cf22b519be21bfb3ad27b4d.jpg",
+        "text": "$$\nL _ { b u d g e t } = \\lambda \\cdot \\sum _ { t = 1 } ^ { T } u _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            180,
+            570,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $L _ { b u d g e t }$ is the cost associated to a single sequence, $\\lambda$ is the cost per sample and $T$ is the sequence length. This formulation bears a similarity to weight decay regularization, where the network is encouraged to slowly converge toward a solution where the norm of the weights is small. Similarly, in this case the network is encouraged to converge toward a solution where fewer state updates are required. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although the above budget formulation is extensively studied in our experiments, other budget loss terms can be used depending on the application. For instance, a specific number of samples may be encouraged by applying a $L _ { 1 }$ or $L _ { 2 }$ loss between the target value and the number of updates per sequence, $et { } { ' } \\sum _ { t = 1 } ^ { T } u _ { t }$ . ",
+        "bbox": [
+            174,
+            314,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            326,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the following section, we investigate the advantages of adding this state skipping to two common RNN architectures, LSTM and GRU, for a variety of tasks. In addition to the evaluation metric for each task, we report the number of RNN state updates (i.e., the number of elements in the input sequence used by the model) and the number of floating point operations (FLOPs) as measures of the computational load for each model. Since skipping an RNN update results in ignoring its corresponding input, we will refer to the number of updates and the number of used samples (i.e. elements in a sequence) interchangeably. With the goal of studying the effect of skipping state updates on the learning capability of the networks, we also introduce a baseline which skips a state update with probability $p _ { s k i p }$ . We tune the skipping probability to obtain models that perform a similar number of state updates to the Skip RNN models. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training is performed with Adam (Kingma & Ba, 2014), learning rate of $1 0 ^ { - 4 }$ , $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } =$ 0.999 and $\\epsilon = 1 0 ^ { - 8 }$ on batches of 256. Gradient clipping (Pascanu et al., 2013) with a threshold of 1 is applied to all trainable variables. Bias $b _ { p }$ in Equation 4 is initialized to 1, so that all samples are used at the beginning of training2. The initial hidden state $s _ { 0 }$ is learned during training, whereas $\\tilde { u } _ { 0 }$ is set to a constant value of 1 in order to force the first update at $t = 1$ . ",
+        "bbox": [
+            174,
+            577,
+            825,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Experiments are implemented with TensorFlow3 and run on a single NVIDIA K80 GPU. ",
+        "bbox": [
+            173,
+            654,
+            754,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 ADDING TASK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            315,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We revisit one of the original LSTM tasks (Hochreiter & Schmidhuber, 1997), where the network is given a sequence of (value, marker) tuples. The desired output is the addition of only two values that are marked with a 1, whereas those marked with a 0 need to be ignored. We follow the experimental setup in Neil et al. (2016), where the first marker is randomly placed among the first $10 \\%$ of samples (drawn with uniform probability) and the second one is placed among the last half of samples (drawn with uniform probability). This marker distribution yields sequences where at least $40 \\%$ of the samples are distractors and provide no useful information at all. However, it is worth noting that in this task the risk of missing a marker is very large as compared to the benefits of working on shorter subsequences. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc966563b7ba636410edee02c3a5f6c2b22ddfb940dd3b3f091255a08efc33b7.jpg",
+        "table_caption": [
+            "Table 1: Results for the adding task, displayed as $m e a n \\pm s t d$ over four different runs. The task is considered to be solved if the MSE is at least two orders of magnitude below the variance of the output distribution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Task solved</td><td> State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>Yes</td><td>100.0%± 0.0%</td><td>2.46 ×106</td></tr><tr><td>LSTM (pskip = 0.2)</td><td>No</td><td>80.0%±0.1%</td><td>1.97 × 106</td></tr><tr><td>LSTM (Pskip = 0.5)</td><td>No</td><td>50.1%± 0.1%</td><td>1.23 × 106</td></tr><tr><td>Skip LSTM, λ= 0</td><td>Yes</td><td>81.1% ± 3.6%</td><td>2.00 ×106</td></tr><tr><td>Skip LSTM,λ= 10-5</td><td>Yes</td><td>53.9%± 2.1%</td><td>1.33 × 106</td></tr><tr><td>GRU</td><td>Yes</td><td>100.0% ± 0.0%</td><td>1.85 × 106</td></tr><tr><td>GRU (pskip = 0.02)</td><td>No</td><td>98.0%±0.0%</td><td>1.81 × 106</td></tr><tr><td>GRU (pskip = 0.5)</td><td>No</td><td>49.9%± 0.6%</td><td>9.25×105</td></tr><tr><td>Skip GRU, λ = 0</td><td>Yes</td><td>97.9%± 3.2%</td><td>1.81 × 106</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>Yes</td><td>50.7%± 2.6%</td><td>9.40 × 105</td></tr></table>",
+        "bbox": [
+            230,
+            99,
+            767,
+            281
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train RNN models with 110 units each on sequences of length 50, where the values are uniformly drawn from $\\mathcal { U } ( - 0 . 5 , 0 . 5 )$ . The final RNN state is fed to a fully connected layer that regresses the scalar output. The model is trained to minimize the Mean Squared Error (MSE) between the output and the ground truth. We consider that a model is able to solve the task when its MSE on a held-out set of examples is at least two orders of magnitude below the variance of the output distribution. This criterion is a stricter version of the one followed by Hochreiter & Schmidhuber (1997). ",
+        "bbox": [
+            174,
+            372,
+            825,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "While all models learn to solve the task, results in Table 1 show that Skip RNN models are able to do so with roughly half of the updates of their corresponding counterparts. We observed that the models using fewer updates never miss any marker, since the penalization in terms of MSE would be very large (see Section B.1 for examples). This is confirmed by the poor performance of the baselines that randomly skip state updates, which are not able to solve the tasks even when the skipping probability is low. Skip RNN models learn to skip most of the samples in the $40 \\%$ of the sequence where there are no markers. Moreover, most updates are skipped once the second marker is found, since all the relevant information in the sequence has already been seen. This last pattern provides evidence that the proposed models effectively learn whether to update or copy the hidden state based on the input sequence, as opposed to learning biases in the dataset only. As a downside, Skip RNN models show some difficulties skipping a large number of updates at once, probably due to the cumulative nature of $\\tilde { u } _ { t }$ . ",
+        "bbox": [
+            174,
+            463,
+            825,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 MNIST CLASSIFICATION FROM A SEQUENCE OF PIXELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            606,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The MNIST handwritten digits classification benchmark (LeCun et al., 1998) is traditionally addressed with Convolutional Neural Networks (CNNs) that efficiently exploit spatial dependencies through weight sharing. By flattening the $2 8 \\times 2 8$ images into 784-d vectors, however, it can be reformulated as a challenging task for RNNs where long term dependencies need to be leveraged (Le et al., 2015b). We follow the standard data split and set aside 5,000 training samples for validation purposes. After processing all pixels with an RNN with 110 units, the last hidden state is fed into a linear classifier predicting the digit class. All models are trained for 600 epochs to minimize cross-entropy loss. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 summarizes classification results on the test set after 600 epochs of training. Skip RNNs are not only able to solve the task using fewer updates than their counterparts, but also show a lower variation among runs and train faster (see Figure 2). We hypothesize that skipping updates make the Skip RNNs work on shorter subsequences, simplifying the optimization process and allowing the networks to capture long term dependencies more easily. A similar behavior was observed for Phased LSTM, where increasing the sparsity of cell updates accelerates training for very long sequences (Neil et al., 2016). However, the drop in performance observed in the models where the state updates are skipped randomly suggests that learning which samples to use is a key component in the performance of Skip RNN. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e280beeafec35da01bc1e8013282419a60547ec4e0ce52718223718bd7119a15.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Accuracy</td><td>State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>0.910 ± 0.045</td><td>784.00 ± 0.00</td><td>3.83×107</td></tr><tr><td>LSTM (pskip = 0.5)</td><td>0.893 ± 0.003</td><td>392.03 ± 0.05</td><td>1.91 × 107</td></tr><tr><td>Skip LSTM,X= 10-4</td><td>0.973 ± 0.002</td><td>379.38 ± 33.09</td><td>1.86 ×107</td></tr><tr><td>GRU</td><td>0.968 ± 0.013</td><td>784.00 ±0.00</td><td>2.87×107</td></tr><tr><td>GRU (p skip = 0.5)</td><td>0.912 ±0.004</td><td>391.86 ± 0.14</td><td>1.44 × 107</td></tr><tr><td>Skip GRU,X=10-4</td><td>0.976 ± 0.003</td><td>392.62 ± 26.48</td><td>1.44 × 107</td></tr><tr><td>TANH-RNN (Le et al., 2015a)</td><td>0.350</td><td>784.00</td><td></td></tr><tr><td>iRNN (Le et al., 2015a)</td><td>0.970</td><td>784.00</td><td></td></tr><tr><td>uRNN (Arjovsky et al., 2016)</td><td>0.951</td><td>784.00</td><td></td></tr><tr><td>sTANH-RNN (Zhang et al., 2016)</td><td>0.981</td><td>784.00</td><td></td></tr><tr><td>LSTM (Cooijmans et al., 2017)</td><td>0.989</td><td>784.00</td><td></td></tr><tr><td>BN-LSTM (Cooijmans et al., 2017)</td><td>0.990</td><td>784.00</td><td></td></tr></table>",
+        "bbox": [
+            183,
+            101,
+            813,
+            313
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Accuracy, used samples and average FLOPs per sequence at inference on the test set of MNIST after 600 epochs of training. Results are displayed as $m e a n \\pm s t d$ over four different runs. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9fba09fd879c43112caf70dc4538bb8c8e2159ecfd6ea365bece1928549acb1b.jpg",
+        "image_caption": [
+            "Figure 2: Accuracy evolution during training on the validation set of MNIST. The Skip GRU exhibits lower variance and faster convergence than the baseline GRU. A similar behavior is observed for LSTM and Skip LSTM, but omitted for clarity. Shading shows maximum and minimum over 4 runs, while dark lines indicate the mean. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            381,
+            815,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The performance of RNN models on this task can be boosted through techniques like recurrent batch normalization (Cooijmans et al., 2017) or recurrent skip coefficients (Zhang et al., 2016). Cooijmans et al. (2017) show how an LSTM with specific weight initialization schemes for improved gradient flow (Le et al., 2015a; Arjovsky et al., 2016) can reach accuracy rates of up to $0 . 9 \\hat { 8 } 9 \\%$ . Note that these techniques are orthogonal to skipping state updates and Skip RNN models could benefit from them as well. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            742
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sequences of pixels can be reshaped back into 2D images, allowing to visualize the samples used by the RNNs as a sort of hard visual attention model ( $\\mathrm { { X u } }$ et al., 2015). Examples such as the ones depicted in Figure 3 show how the model learns to skip pixels that are not discriminative, such as the padding regions in the top and bottom of images. Similarly to the qualitative results for the adding task (Section 4.1), attended samples vary depending on the particular input being given to the network. ",
+        "bbox": [
+            173,
+            751,
+            825,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 TEMPORAL ACTION LOCALIZATION ON CHARADES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            562,
+            868
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One popular approach to video analysis tasks today is to extract frame-level features with a CNN and modeling temporal dynamics with an RNN (Donahue et al., 2015; Yue-Hei $\\mathrm { N g }$ et al., 2015). Videos are commonly recorded at high sampling rates, generating long sequences with strong temporal redundancies that are challenging for RNNs. Moreover, processing frames with a CNN is computationally expensive and may become prohibitive for high frame rates. These issues have been alleviated in previous works by using short clips (Donahue et al., 2015) or by downsampling the original data in order to cover long temporal spans without increasing the sequence length excessively (Yue-Hei $\\mathrm { N g }$ et al., 2015). Instead of addressing the long sequence problem at the input data level, we let the network learn which frames need to be used. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f56669854424b159f8ca406c1931ba5f8c9bcb930aef3dbceb93dd4832102ab.jpg",
+        "image_caption": [
+            "Figure 3: Sample usage examples for the Skip LSTM with $\\lambda = 1 0 ^ { - 4 }$ on the test set of MNIST. Red pixels are used, whereas blue ones are skipped. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            104,
+            816,
+            208
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            306,
+            825,
+            390
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Charades (Sigurdsson et al., 2016a) is a dataset containing 9,848 videos annotated for 157 action classes in a per-frame fashion. Frames are encoded using $f c 7$ features from the RGB stream of a Two-Stream CNN provided by the organizers of the challenge4, extracted at 6 fps. The encoded frames are fed into two stacked RNN layers with 256 units each and the hidden state in the last RNN layer is used to compute the update probability for the Skip RNN models. Since each frame may be annotated with zero or more classes, the networks are trained to minimize element-wise binary cross-entropy at every time step. Unlike the previous sequence tagging tasks, this setup allows us to evaluate the performance of Skip RNN on a task where the output is a sequence as well. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            510
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation is performed following the setup by Sigurdsson et al. (2016c), but evaluating on 100 equally spaced frames instead of 25, and results are reported in Table 3. It is surprising that the GRU baselines that randomly skip state updates perform on par with their Skip GRU counterparts for low skipping probabilities. We hypothesize several reasons for this behavior, which was not observed in previous experiments: (1) there is a supervision signal at every time step and the inputs and (2) outputs are strongly correlated in consecutive frames. On the other hand, Skip RNN models clearly outperform the random methods when fewer updates are allowed. Note that this setup is far more challenging because of the longer time spans between updates, so properly distributing the state updates along the sequence is key to the performance of the models. Interestingly, Skip RNN models learn which frames need to be attended from RGB data and without having access to explicit motion information. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Skip GRU tends to perform fewer state updates than Skip LSTM when the cost per sample is low or none. This behavior is the opposite of the one observed in the adding task (Section 4.1), which may be related to the observation that determining the best performing gated unit depends on the task at hand Chung et al. (2014). Indeed, GRU models consistently outperform LSTM ones on this task. This mismatch in the number of used samples is not observed for large values of $\\lambda$ , as both Skip LSTM and Skip GRU converge to a comparable number of used samples. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A previous work reports better action localization performance by integrating RGB and optical flow information as an input to an LSTM, reaching $9 . { \\bar { 6 } } 0 \\%$ mAP (Sigurdsson et al., 2016c). This boost in performance comes at the cost of roughly doubling the number of FLOPs and memory footprint of the CNN encoder, plus requiring the extraction of flow information during a preprocessing step. Interestingly, our model learns which frames need to be attended from RGB data and without having access to explicit motion information. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/df6d5ec0a4a977be191d759f0d82ec0214a431bcaa31d9b2ebadbbd1cdcd1bd9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>mAP(%)</td><td>State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>8.40</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>LSTM (pskip = 0.75)</td><td>8.11</td><td>43.3 ± 13.2</td><td>6.63 × 1011</td></tr><tr><td>LSTM (pskip = 0.90)</td><td>7.21</td><td>17.2 ± 6.1</td><td>2.65×1011</td></tr><tr><td>Skip LSTM,λ= 0</td><td>8.32</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>Skip LSTM,λ= 10-4</td><td>8.61</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>Skip LSTM,λ= 10-3</td><td>8.32</td><td>41.9 ± 11.3</td><td>6.41 × 1011</td></tr><tr><td>Skip LSTM,X = 10-2</td><td>7.86</td><td>17.4 ± 4.4</td><td>2.66 × 1011</td></tr><tr><td>GRU</td><td>8.70</td><td>172.9 ± 47.4</td><td>2.65×1012</td></tr><tr><td>GRU (pskip = 0.10)</td><td>8.94</td><td>155.6 ± 42.9</td><td>2.39 ×1012</td></tr><tr><td>GRU (pskip = 0.40)</td><td>8.81</td><td>103.6 ± 29.3</td><td>1.06 × 1012</td></tr><tr><td>GRU (pskip = 0.70)</td><td>8.42</td><td>51.9 ± 15.4</td><td>7.95 × 1011</td></tr><tr><td>GRU (pskip = 0.90)</td><td>7.09</td><td>17.3 ± 6.3</td><td>2.65×1011</td></tr><tr><td>Skip GRU,λ= 0</td><td>8.94</td><td>159.9 ± 46.9</td><td>2.45×1012</td></tr><tr><td>Skip GRU,入 = 10-4</td><td>8.76</td><td>100.8 ± 28.1</td><td>1.54 × 1012</td></tr><tr><td>Skip GRU,λ = 10-3</td><td>8.68</td><td>54.2 ± 16.2</td><td>8.29×1011</td></tr><tr><td>Skip GRU,λ = 10-2</td><td>7.95</td><td>18.4 ± 5.1</td><td>2.82 × 1011</td></tr></table>",
+        "bbox": [
+            241,
+            101,
+            754,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Mean Average Precision (mAP), used samples and average FLOPs per sequence at inference on the validation set of Charades. The number of state updates is displayed as $m e a n \\pm s t d$ over all the videos in the validation set. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            426
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            449,
+            318,
+            465
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We presented Skip RNNs as an extension to existing recurrent architectures enabling them to skip state updates thereby reducing the number of sequential operations in the computation graph. Unlike other approaches, all parameters in Skip RNN are trained with backpropagation. Experiments conducted with LSTMs and GRUs showed that Skip RNNs can match or in some cases even outperform the baseline models while relaxing their computational requirements. Skip RNNs provide faster and more stable training for long sequences and complex models, owing to gradients being backpropagated through fewer time steps resulting in a simpler optimization task. Moreover, the introduced computational savings are better suited for modern hardware than those methods that reduce the amount of computation required at each time step (Koutnik et al., 2014; Neil et al., 2016; Chung et al., 2017). ",
+        "bbox": [
+            174,
+            481,
+            825,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            326,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This work was partially supported by the Spanish Ministry of Economy and Competitivity and the European Regional Development Fund (ERDF) under contracts TEC2016-75976-R and TIN2015- 65316-P, by the BSC-CNS Severo Ochoa program SEV-2015-0493, and grant 2014-SGR-1051 by the Catalan Government. V´ıctor Campos was supported by Obra Social “la Caixa” through La Caixa-Severo Ochoa International Doctoral Fellowship program. We would also like to thank the technical support team at the Barcelona Supercomputing Center. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            763,
+            285,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amjad Almahairi, Nicolas Ballas, Tim Cooijmans, Yin Zheng, Hugo Larochelle, and Aaron Courville. Dynamic capacity networks. In ICML, 2016. ",
+        "bbox": [
+            174,
+            786,
+            823,
+            814
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In ICML, 2016. ",
+        "bbox": [
+            173,
+            821,
+            823,
+            851
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. arXiv preprint arXiv:1412.7755, 2014. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450, 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Deep learning of representations: Looking forward. In SLSP, 2013. ",
+        "bbox": [
+            174,
+            140,
+            727,
+            157
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 1994. ",
+        "bbox": [
+            174,
+            165,
+            821,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Nicholas Leonard, and Aaron Courville. Estimating or propagating gradients ´ through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Subhabrata Bhattacharya, Felix X Yu, and Shih-Fu Chang. Minimally needed evidence for complex event recognition in unconstrained videos. In ICMR, 2014. ",
+        "bbox": [
+            173,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural networks. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            277,
+            823,
+            308
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In CVPR, 2017. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. In EMNLP, 2014. ",
+        "bbox": [
+            176,
+            353,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014. ",
+        "bbox": [
+            171,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical multiscale recurrent neural networks. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Cooijmans, Nicolas Ballas, Cesar Laurent, C¸ a ´ glar G ˘ ulc¸ehre, and Aaron Courville. Recurrent ¨ batch normalization. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthieu Courbariaux, Itay Hubara, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks: Training deep neural networks with weights and activations constrained $\\mathrm { t o } + 1$ or-1. arXiv preprint arXiv:1602.02830, 2016. ",
+        "bbox": [
+            174,
+            517,
+            823,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Davis and Itamar Arel. Low-rank approximations for conditional feedforward computation in deep neural networks. arXiv preprint arXiv:1312.4461, 2013. ",
+        "bbox": [
+            173,
+            569,
+            823,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009. ",
+        "bbox": [
+            173,
+            606,
+            820,
+            636
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            645,
+            821,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Adaptive computation time for recurrent neural networks. arXiv preprint arXiv:1603.08983, 2016. ",
+        "bbox": [
+            173,
+            695,
+            823,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In ICASSP, 2013. ",
+        "bbox": [
+            171,
+            733,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014. ",
+        "bbox": [
+            173,
+            771,
+            825,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edward Grefenstette, Karl Moritz Hermann, Mustafa Suleyman, and Phil Blunsom. Learning to transduce with unbounded memory. In NIPS, 2015. ",
+        "bbox": [
+            171,
+            809,
+            823,
+            839
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            847,
+            823,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton. Neural networks for machine learning. Coursera video lectures, 2012. ",
+        "bbox": [
+            171,
+            885,
+            753,
+            901
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 1997. ",
+        "bbox": [
+            173,
+            909,
+            803,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yacine Jernite, Edouard Grave, Armand Joulin, and Tomas Mikolov. Variable computation in recurrent neural networks. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim. Convolutional neural networks for sentence classification. In EMNLP, 2014. ",
+        "bbox": [
+            174,
+            178,
+            753,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            202,
+            823,
+            231
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jan Koutnik, Klaus Greff, Faustino Gomez, and Juergen Schmidhuber. A clockwork rnn. In ICML, 2014. ",
+        "bbox": [
+            169,
+            239,
+            825,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Krueger, Tegan Maharaj, Janos Kram ´ ar, Mohammad Pezeshki, Nicolas Ballas, Nan Rose-´ mary Ke, Anirudh Goyal, Yoshua Bengio, Hugo Larochelle, Aaron Courville, et al. Zoneout: Regularizing rnns by randomly preserving hidden activations. In ICLR, 2017. ",
+        "bbox": [
+            176,
+            277,
+            821,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015a. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            359
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Quoc V Le, Navdeep Jaitly, and Geoffrey E Hinton. A simple way to initialize recurrent networks of rectified linear units. arXiv preprint arXiv:1504.00941, 2015b. ",
+        "bbox": [
+            174,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            174,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tao Lei and Yu Zhang. Training rnns as fast as cnns. arXiv preprint arXiv:1709.02755, 2017. ",
+        "bbox": [
+            176,
+            443,
+            789,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lanlan Liu and Jia Deng. Dynamic deep neural networks: Optimizing accuracy-efficiency trade-offs by selective execution. arXiv preprint arXiv:1701.00299, 2017. ",
+        "bbox": [
+            173,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shayne Longpre, Sabeek Pradhan, Caiming Xiong, and Richard Socher. A way out of the odyssey: Analyzing and combining recent insights for lstms. arXiv preprint arXiv:1611.05104, 2016. ",
+        "bbox": [
+            173,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew L Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In ACL, 2011. ",
+        "bbox": [
+            171,
+            541,
+            823,
+            570
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mason McGill and Pietro Perona. Deciding how to decide: Dynamic routing in artificial neural networks. In ICML, 2017. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In NIPS, 2013. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Andrew M Dai, and Ian Goodfellow. Adversarial training methods for semisupervised text classification. In ICLR, 2017. ",
+        "bbox": [
+            171,
+            655,
+            823,
+            684
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In NIPS, 2014. ",
+        "bbox": [
+            173,
+            693,
+            823,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Neil, Michael Pfeiffer, and Shih-Chii Liu. Phased LSTM: accelerating recurrent network training for long or event-based sequences. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In ICML, 2013. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            797
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel and Dieterich Lawson. Training a subsampling mechanism in expectation. In ICLR Workshop Track, 2017. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Evan Shelhamer, Kate Rakelly, Judy Hoffman, and Trevor Darrell. Clockwork convnets for video semantic segmentation. arXiv preprint arXiv:1608.03609, 2016. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gunnar Sigurdsson, Gul Varol, Xiaolong Wang, Ali Farhadi, Ivan Laptev, and Abhinav Gupta. Hol- ¨ lywood in homes: Crowdsourcing data collection for activity understanding. In ECCV, 2016a. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gunnar A Sigurdsson, Xinlei Chen, and Abhinav Gupta. Learning visual storylines with skipping recurrent neural networks. In ECCV, 2016b. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gunnar A Sigurdsson, Santosh Divvala, Ali Farhadi, and Abhinav Gupta. Asynchronous temporal fields for action recognition. arXiv preprint arXiv:1612.06371, 2016c. ",
+        "bbox": [
+            171,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In NIPS, 2014. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012. ",
+        "bbox": [
+            173,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu-Chuan Su and Kristen Grauman. Leaving some stones unturned: dynamic feature prioritization for activity detection in streaming video. In ECCV, 2016. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            321
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In ICCV, 2015. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            358
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Sumit Chopra, and Antoine Bordes. Memory networks. arXiv preprint arXiv:1410.3916, 2014. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 1992. ",
+        "bbox": [
+            169,
+            405,
+            825,
+            434
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In ICML, 2015. ",
+        "bbox": [
+            176,
+            443,
+            823,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Serena Yeung, Olga Russakovsky, Greg Mori, and Li Fei-Fei. End-to-end learning of action detection from frame glimpses in videos. In CVPR, 2016. ",
+        "bbox": [
+            173,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, Hongrae Lee, and Quoc V Le. Learning to skim text. In ACL, 2017. ",
+        "bbox": [
+            173,
+            532,
+            728,
+            547
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joe Yue-Hei $\\mathrm { N g }$ , Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In CVPR, 2015. ",
+        "bbox": [
+            176,
+            556,
+            821,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization. In ICLR, 2015. ",
+        "bbox": [
+            174,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Saizheng Zhang, Yuhuai Wu, Tong Che, Zhouhan Lin, Roland Memisevic, Ruslan R Salakhutdinov, and Yoshua Bengio. Architectural complexity measures of recurrent neural networks. In NIPS, 2016. ",
+        "bbox": [
+            173,
+            645,
+            826,
+            689
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            444,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 FREQUENCY DISCRIMINATION TASK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            472,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, the network is trained to classify between sinusoids whose period is in range $T \\sim \\mathcal { U } \\left( 5 , 6 \\right)$ milliseconds and those whose period is in range $T \\sim \\{ ( 1 , 5 ) \\cup ( 6 , 1 0 0 ) \\}$ milliseconds (Neil et al., 2016). Every sine wave with period $T$ has a random phase shift drawn from $\\mathcal { U } ( 0 , T )$ . At every time step, the input to the network is a single scalar representing the amplitude of the signal. Since sinusoid are continuous signals, this tasks allows to study whether Skip RNNs converge to the same solutions when their parameters are fixed but the sampling period is changed. We study two different sampling periods, $\\mathrm { \\tilde { \\it T } _ { 3 } } = \\mathrm { \\{ 0 . 5 , 1 \\} }$ milliseconds, for each set of hyperparameters. ",
+        "bbox": [
+            173,
+            159,
+            825,
+            257
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We train RNNs with 110 units each on input signals of 100 milliseconds. Batches are stratified, containing the same number of samples for each class, yielding a $50 \\%$ chance accuracy. The last state of the RNN is fed into a 2-way classifier and trained with cross-entropy loss. We consider that a model is able to solve the task when it achieves an accuracy over $9 9 \\%$ on a held-out set of examples. ",
+        "bbox": [
+            174,
+            263,
+            825,
+            319
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 4 summarizes results for this task. When no cost per sample is set $\\lambda = 0$ ), the number of updates differ under different sampling conditions. We attribute this behavior to the potentially large number of local minima in the cost function, since there are numerous subsampling patterns for which the task can be successfully solved and we are not explicitly encouraging the network to converge to a particular solution. On the other hand, when $\\lambda > 0$ Skip RNN models with the same cost per sample use roughly the same number of input samples even when the sampling frequency is doubled. This is a desirable property, since solutions are robust to oversampled input signals. Qualitative results can be found in Section B.2. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            438
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/f5cab9c00573377a556b05c10186d1c7706d8d122337beaf71329e563a79f097.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Ts = 1ms (length 100)</td><td colspan=\"2\">Ts = O.5ms (length 200)</td></tr><tr><td>Task solved</td><td>State updates</td><td>Task solved</td><td> State updates</td></tr><tr><td>LSTM</td><td>Yes</td><td>100.0 ± 0.00</td><td>Yes</td><td>200.0 ± 0.00</td></tr><tr><td>Skip LSTM, λ= 0</td><td>Yes</td><td>55.5 ± 16.9</td><td>Yes</td><td>147.9 ± 27.0</td></tr><tr><td>Skip LSTM,λ = 10-5</td><td>Yes</td><td>47.4 ± 14.1</td><td>Yes</td><td>50.7 ± 16.8</td></tr><tr><td>Skip LSTM,λ = 10-4</td><td>Yes</td><td>12.7 ± 0.5</td><td>Yes</td><td>19.9 ± 1.5</td></tr><tr><td>GRU</td><td>Yes</td><td>100.0 ± 0.00</td><td>Yes</td><td>200.0 ±0.00</td></tr><tr><td>Skip GRU, λ = 0</td><td>Yes</td><td>73.7 ± 17.9</td><td>Yes</td><td>167.0 ± 18.3</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>Yes</td><td>51.9 ± 10.2</td><td>Yes</td><td>54.2 ± 4.4</td></tr><tr><td>Skip GRU, λ= 10-4</td><td>Yes</td><td>23.5 ± 6.2</td><td>Yes</td><td>22.5 ± 2.1</td></tr></table>",
+        "bbox": [
+            197,
+            448,
+            800,
+            617
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Results for the frequency discrimination task, displayed as $m e a n \\pm s t d$ over four different runs. The task is considered to be solved if the classification accuracy is over $9 9 \\%$ . Models with the same cost per sample $( \\lambda > 0$ ) converge to a similar number of used samples under different sampling conditions. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 SENTIMENT ANALYSIS ON IMDB ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            714,
+            449,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The IMDB dataset (Maas et al., 2011) contains 25,000 training and 25,000 testing movie reviews annotated into two classes, positive and negative sentiment, with an approximate average length of 240 words per review. We set aside $1 5 \\%$ of training data for validation purposes. Words are embedded into 300-d vector representations before being fed to an RNN with 128 units. The embedding matrix is initialized using pre-trained word2vec5 embeddings (Mikolov et al., 2013) when available, or random vectors drawn from $\\mathcal { U } ( - 0 . 2 5 , 0 . 2 5 )$ otherwise (Kim, 2014). Dropout with rate 0.2 is applied between the last RNN state and the classification layer in order to reduce overfitting. We evaluate the models on sequences of length 200 and 400 by cropping longer sequences and padding shorter ones (Yu et al., 2017). ",
+        "bbox": [
+            173,
+            739,
+            825,
+            866
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Results on the test are reported in Table 5. In a task where it is hard to predict which input tokens will be discriminative, the Skip RNN models are able to achieve similar accuracy rates to the baseline models while reducing the number of required updates. These results highlight the trade-off between accuracy and the available computational budget, since a larger cost per sample results in lower accuracies. However, allowing the network to select which samples to use instead of cropping sequences at a given length boosts performance, as observed for the Skip LSTM (length 400, $\\lambda =$ $1 0 ^ { { \\bar { - 4 } } { \\bar { \\cdot } } }$ ), which achieves a higher accuracy than the baseline LSTM (length 200) while seeing roughly the same number of words per review. A similar behavior can be seen for the Skip RNN models with $\\lambda = 1 0 ^ { - 3 }$ , where allowing them to select words from longer reviews boosts classification accuracy while using a comparable number of tokens per sequence. ",
+        "bbox": [
+            174,
+            872,
+            825,
+            901
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In order to reduce overfitting of large models, Miyato et al. (2017) leverage additional unlabeled data through adversarial training and achieve a state of the art accuracy of 0.941 on IMDB. For an extended analysis on how different experimental setups affect the performance of RNNs on this task, we refer the reader to (Longpre et al., 2016). ",
+        "bbox": [
+            174,
+            222,
+            825,
+            279
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/691f67d1b20de1009e06bc4fa98c0537607da92221481bff0b493838ce18b00b.jpg",
+        "table_caption": [
+            "Table 5: Accuracy and used samples on the test set of IMDB for different sequence lengths. Results are displayed as $m e a n \\pm s t d$ over four different runs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">Length 200</td><td colspan=\"2\">Length 400</td></tr><tr><td>Accuracy</td><td>State updates</td><td>Accuracy</td><td> State updates</td></tr><tr><td>LSTM</td><td>0.843 ± 0.003</td><td>200.00±0.00</td><td>0.868 ± 0.004</td><td>400.00 ± 0.00</td></tr><tr><td>Skip LSTM,λ= 0</td><td>0.844 ± 0.004</td><td>196.75 ± 5.63</td><td>0.866 ± 0.004</td><td>369.70 ± 19.35</td></tr><tr><td>Skip LSTM, X= 10-5</td><td>0.846 ± 0.004</td><td>197.15 ± 3.16</td><td>0.865 ± 0.001</td><td>380.62 ± 18.20</td></tr><tr><td>Skip LSTM,λ= 10-4</td><td>0.837 ± 0.006</td><td>164.65 ± 8.67</td><td>0.862 ± 0.003</td><td>186.30 ± 25.72</td></tr><tr><td>Skip LSTM,λ= 10-3</td><td>0.811 ± 0.007</td><td>73.85 ± 1.90</td><td>0.836 ± 0.007</td><td>84.22 ± 1.98</td></tr><tr><td>GRU</td><td>0.845 ± 0.006</td><td>200.00 ±0.00</td><td>0.862 ± 0.003</td><td>400.00 ± 0.00</td></tr><tr><td>Skip GRU,λ = 0</td><td>0.848 ±0.002</td><td>200.00 ±0.00</td><td>0.866 ±0.002</td><td>399.02 ±1.69</td></tr><tr><td>Skip GRU, λ= 10-5</td><td>0.842 ± 0.005</td><td>199.25 ± 1.30</td><td>0.862 ±0.008</td><td>398.00 ±2.06</td></tr><tr><td>Skip GRU, 入= 10-4</td><td>0.834 ± 0.006</td><td>180.97 ± 8.90</td><td>0.853 ± 0.011</td><td>314.30 ± 2.82</td></tr><tr><td>Skip GRU,λ = 10-3</td><td>0.800 ±0.007</td><td>106.15 ± 37.92</td><td>0.814 ± 0.005</td><td>99.12 ± 2.69</td></tr></table>",
+        "bbox": [
+            176,
+            323,
+            823,
+            520
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 ACTION CLASSIFICATION ON UCF-101 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            486,
+            633
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "UCF-101 (Soomro et al., 2012) is a dataset containing 13,320 trimmed videos belonging to 101 different action categories. We use 10 seconds of video sampled at 25 fps, cropping longer ones and padding shorter examples with empty frames. Activations in the Global Average Pooling layer from a ResNet-50 (He et al., 2016) CNN pretrained on the ImageNet dataset (Deng et al., 2009) are used as frame-level features, which are fed into two stacked RNN layers with 512 units each. The weights in the CNN are not tuned during training to reduce overfitting. The hidden state in the last RNN layer is used to compute the update probability for the Skip RNN models. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the different models on the first split of UCF-101 and report results in Table 6. Skip RNN models do not only improve the classification accuracy with respect to the baseline, but require very few updates to do so, possibly due to the low motion between consecutive frames resulting in frame-level features with high temporal redundancy (Shelhamer et al., 2016). Moreover, Figure 4 shows how models performing fewer updates converge faster thanks to the gradients being preserved during longer spans when training with backpropagation through time. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            847
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Non recurrent architectures for video action recognition that have achieved high performance on UCF-101 comprise CNNs with spatiotemporal kernels (Tran et al., 2015) or two-stream CNNs (Simonyan & Zisserman, 2014). Carreira & Zisserman (2017) show the benefits of expanding 2D CNN filters into 3D and pretraining on larger datasets, obtaining an accuracy of 0.845 when using RGB data only and 0.934 when incorporating optical flow information. ",
+        "bbox": [
+            176,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/3cf06b77992f9be46d4dd1db57120153dd437bc952458c542826f8aa1e81c555.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td> Accuracy</td><td> State updates</td><td>Inference FLOPs</td></tr><tr><td>LSTM</td><td>0.671</td><td>250.0</td><td>9.52 ×1011</td></tr><tr><td>Skip LSTM, λ = 0</td><td>0.749</td><td>138.9</td><td>5.29×1011</td></tr><tr><td>Skip LSTM,λ= 10-5</td><td>0.757</td><td>24.2</td><td>9.21 × 1010</td></tr><tr><td>Skip LSTM, λ= 10-4</td><td>0.790</td><td>7.6</td><td>2.89×1010</td></tr><tr><td>GRU</td><td>0.791</td><td>250.0</td><td>9.51 × 1011</td></tr><tr><td>Skip GRU,λ = 0</td><td>0.796</td><td>124.2</td><td>4.73 × 1011</td></tr><tr><td>Skip GRU,λ = 10-5</td><td>0.792</td><td>29.7</td><td>1.13 × 1011</td></tr><tr><td>Skip GRU,λ = 10-4</td><td>0.793</td><td>23.7</td><td>9.02 ×1010</td></tr><tr><td>I3D (RGB) (Carreira &amp; Zisserman, 2017)</td><td>0.845</td><td>=</td><td></td></tr><tr><td>Two-stream I3D (Carreira &amp; Zisserman, 2017)</td><td>0.934</td><td>■</td><td></td></tr></table>",
+        "bbox": [
+            176,
+            102,
+            821,
+            281
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Accuracy, used samples and average FLOPs per sequence at inference on the validation set of UCF-101 (split 1). ",
+        "bbox": [
+            174,
+            297,
+            823,
+            327
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fceb38d809e5cfa29a3604ba1e90bcef2f072d685491e6e5555c418bf329335c.jpg",
+        "image_caption": [
+            "Figure 4: Accuracy evolution during the first 300 training epochs on the validation set of UCF-101 (split 1). Skip LSTM models converge much faster than the baseline LSTM. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            361,
+            818,
+            542
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            401,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "This appendix contains additional qualitative results for the Skip RNN models. ",
+        "bbox": [
+            173,
+            166,
+            691,
+            183
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.1 ADDING TASK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            316,
+            270
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6521d4fbc04697107e8cda3c1975b53916e50b9a1428f04e8dd4778b6581024.jpg",
+        "image_caption": [
+            "Figure 5: Sample usage examples for the Skip GRU with $\\lambda = 1 0 ^ { - 5 }$ on the adding task. Red dots indicate used samples, whereas blue ones are skipped. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            359,
+            821,
+            882
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2799b3b795938bede8847ce47def1d327e5b232e367c05ec310b8af37e0c523.jpg",
+        "image_caption": [
+            "Figure 6: Sample usage examples for the Skip LSTM with $\\lambda = 1 0 ^ { - 4 }$ on the frequency discrimination task with $T _ { s } = 0 . 5 \\mathrm { m s }$ . Red dots indicate used samples, whereas blue ones are skipped. The network learns that using the first samples is enough to classify the frequency of the sine waves, in contrast to a uniform downsampling that may result in aliasing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            135,
+            821,
+            651
+        ],
+        "page_idx": 16
+    }
+]

parse/train/HygsfnR9Ym/HygsfnR9Ym.md

@@ -0,0 +1,451 @@
+# RECALL TRACES: BACKTRACKING MODELS FOR EFFICIENT REINFORCEMENT LEARNING
+
+Anirudh Goyal1, Philemon Brakel2, William Fedus1, Soumye Singhal1,4, Timothy Lillicrap2, Sergey Levine5, Hugo Larochelle3, Yoshua Bengio1
+
+# ABSTRACT
+
+In many environments only a tiny subset of all states yield high reward. In these cases, few of the interactions with the environment provide a relevant learning signal. Hence, we may want to preferentially train on those high-reward states and the probable trajectories leading to them. To this end, we advocate for the use of a backtracking model that predicts the preceding states that terminate at a given high-reward state. We can train a model which, starting from a high value state (or one that is estimated to have high value), predicts and samples which (state, action)-tuples may have led to that high value state. These traces of (state, action) pairs, which we refer to as Recall Traces, sampled from this backtracking model starting from a high value state, are informative as they terminate in good states, and hence we can use these traces to improve a policy. We provide a variational interpretation for this idea and a practical algorithm in which the backtracking model samples from an approximate posterior distribution over trajectories which lead to large rewards. Our method improves the sample efficiency of both on- and off-policy RL algorithms across several environments and tasks.
+
+# 1 INTRODUCTION
+
+Training control algorithms efficiently from interactions with the environment is a central issue in reinforcement learning (RL). Model-free RL methods, combined with deep neural networks, have achieved impressive results across a wide range of domains (Lillicrap et al., 2015; Mnih et al., 2016; Silver et al., 2016). However, existing model-free solutions lack sample efficiency, meaning that they require extensive interaction with the environment to achieve these levels of performance.
+
+Model-based methods in RL can mitigate this issue. These approaches learn an unsupervised model of the underlying dynamics of the environment, which does not necessarily require rewards, as the model observes and predicts state-to-state transitions. With a well-trained model, the algorithm can then simulate the environment and look ahead to future events to establish better value estimates, without requiring expensive interactions with the environment. Model-based methods can thus be more sample efficient than their model-free counterparts, but often do not achieve the same asymptotic performance (Deisenroth & Rasmussen, 2011a; Nagabandi et al., 2017).
+
+In this work, we propose a method that takes advantage of unsupervised observations of state-to-state transitions for increasing the sample efficiency of current model-free RL algorithms, as measured by the number of interactions with the environment required to learn a successful policy. Our idea stems from a simple observation: given a world model, finding a path between a starting state and a goal state can be done either forward from the start or backward from the goal. Here, we explore an idea for leveraging the latter approach and combining it with model-free algorithms. This idea is particularly useful when rewards are sparse. High-value states are rare and trajectories leading to them are particularly useful for a learner.
+
+The availability of an exact backward dynamics model of the environment is a strong and often unrealistic requirement for most domains. Therefore, we propose learning a backward dynamics model, which we refer to as a backtracking model, from the experiences performed by the agent. This backtracking model $p ( s _ { t } , a _ { t } | s _ { t + 1 } )$ , is trained to predict, given a state $s _ { t + 1 }$ , which state $s _ { t }$ the agent visited before $s _ { t + 1 }$ and what action $a _ { t } \sim \pi$ was performed in $s _ { t }$ to reach $s _ { t + 1 }$ . Specifically, this is a model which, starting from a future high-value state, can be used to recall traces that have ended at this high value state, that is sequences of (state, action)-tuples. This allows the agent to simulate and be exposed to alternative possible paths to reach a high value state. A final state may be a previously experienced high-value state or a goal state may be explicitly given, or even produced by the agent using a generative model of high-value states (Held et al., 2017).
+
+Our hypothesis is that using a backtracking model in this way should benefit learning, especially in the context of weak or sparse rewards. Indeed, in environments or tasks where the agent receives rewards infrequently, it must leverage this information effectively and efficiently. Exploration methods have been employed successfully (Bellemare et al., 2016; Held et al., 2017; Ostrovski et al., 2017) to increase the frequency at which novel states are discovered. Our proposal can be viewed as a special kind of simulated exploration proceeding backward from presumed high-value states, in order to discover trajectories that may lead to high rewards. A backtracking model aims to augment the experience of the trajectory $\tau$ leading to a high-value state by generating other
+
+![](images/290cd08fc780f2c7ceeb861c49733079b2326965b620a12e4d0da4afced490e3.jpg)  
+Figure 1: The policy explores the state space $s$ from an initial state. Discovered high value states are then passed to the backtracking model (dashed-lines) to generate new traces that may have led to this high value state.
+
+possible traces $\tilde { \tau }$ that could have also caused it. To summarize: the main contribution of this paper is an RL method based on the use of a backtracking model, which can easily be integrated with existing on- and off-policy techniques for reducing sample complexity. Empirically, we show with experiments on eight RL environments that the proposed approach is more sample efficient.
+
+# 2 PRELIMINARIES
+
+We consider a Markov decision process (MDP) defined by the tuple $( S , { \mathcal { A } } , P , r , \gamma )$ , where the state space $s$ and the action space $\mathcal { A }$ may be discrete or continuous. The learner is not explicitly given the environment transition probability $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ for going from $s _ { t } \in S$ to $s _ { t + 1 } \in S$ given $a _ { t } \in { \mathcal { A } }$ , but samples from this distribution are observed. The environment emits a bounded reward $r : S \times$ $\mathcal { A }  [ r _ { m i n } , r _ { m a x } ]$ on each transition and $\gamma \in ( 0 , 1 )$ is the discount factor. Let $\pi$ denote a stochastic policy over actions given states, and let $R ( \pi ) ~ = ~ \mathbb { E } _ { \pi } \left[ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } ) \right]$ denote the expected total return when policy $\pi$ is followed.The standard objective in reinforcement learning is to maximize the discounted total return $R ( \pi )$ . Throughout the text we will refer to experienced trajectories as $\tau = ( s _ { 1 } , a _ { 1 } , \cdot \cdot \cdot , s _ { T } , a _ { T } )$ and we will refer to simulated experiences as traces $\tilde { \tau }$ .
+
+# 2.1 BACKTRACKING MODEL
+
+We introduce the backtracking model $B _ { \phi } = q _ { \phi } ( s _ { t } , a _ { t } | s _ { t + 1 } )$ , which is a density estimator of the joint probability distribution over the previous $\left( { { s _ { t } } , { a _ { t } } } \right)$ -tuple parameterized by $\phi$ . This distribution is produced by both a learned backward policy $\pi _ { b } = q ( a _ { t } | s _ { t + 1 } )$ and a state generator $q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ . The backward policy predicts the previous action $a _ { t }$ given the resulting state $s _ { t + 1 }$ . The state generator estimates the probability of a previous state $s _ { t }$ given the tuple $\left( a _ { t } , s _ { t + 1 } \right)$ . With these models, we may decompose $q _ { \phi } { \left( s _ { t } , a _ { t } \vert s _ { t + 1 } \right) }$ as $q ( s _ { t } | a _ { t } , s _ { t + 1 } ) q ( a _ { t } | s _ { t + 1 } )$ .
+
+However, for training stability with continuous-valued states, we model the density of state variation $\Delta s _ { t } = s _ { t } - s _ { t + 1 }$ rather than the raw $s _ { t }$ . Therefore, our density models are given by
+
+$$
+q _ { \phi } ( \Delta _ { t } , a _ { t } | s _ { t + 1 } ) = q ( \Delta s _ { t } | a _ { t } , s _ { t + 1 } ) q ( a _ { t } | s _ { t + 1 } ) .
+$$
+
+Note that for readability, we will drop the $\phi$ -subscript unless it is necessary for clarity.
+
+Generating Recall Traces. Analogous to the use of forward models in (Oh et al., 2015; Chiappa et al., 2017; Weber et al., 2017), we may generate a recall trace auto-regressively. To do so, we begin with a state $s _ { t + 1 }$ and sample $a _ { t } \sim q ( a _ { t } | s _ { t + 1 } )$ . The state generator can then be sampled to produce the change in state $\Delta s _ { t } \sim q ( \Delta s _ { t } | a _ { t } , s _ { t + 1 } )$ . We can continue to unroll this process, repeating with state $s _ { t } = \Delta s _ { t } + s _ { t + 1 }$ for a desired number of steps. These generated transitions are then stored as a potential trace $\tilde { \tau }$ which terminates at some final state. The backtracking model $B _ { \phi }$ is learned by maximum likelihood, using the policy’s trajectories as observations, as described in Section 3.1.
+
+Producing Intended High Value States. Before recursively sampling from the backtracking model, we need to obtain presumed high-value states. Generally, such states will not be known in advance. However, as the agent learns, it will visit states $s _ { t }$ with increasingly high value $\begin{array} { r } { V ^ { \pi } ( s _ { t } = s ) = E _ { \pi } \left[ \sum _ { t } \gamma ^ { t } r ( s _ { t } ) | \bar { s _ { t } } = s \right] . } \end{array}$ The agent’s full experience is maintained in a replay buffer $\boldsymbol { B }$ , in the form of tuples of $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ . Filtering of trajectories based on the returns is done, so that only top $k _ { t r a j }$ are added to the buffer. In this work, we will investigate our approach with two methods for generating the initial high-value states.
+
+The first method relies on picking the most valuable states stored in the replay buffer $\boldsymbol { B }$ . As before, a valuable state may be defined by its estimated expected return $V ^ { \pi } ( s )$ as computed by a critic (our off-policy method) or state that received a high reward (our on-policy method).
+
+The second method is based on Goal GAN, recently introduced by (Held et al., 2017) where goal states $g$ are produced via a Generative Adversarial Network (Goodfellow et al., 2014). In our variant, we map the goal state $g$ to a valid point in state space $s$ using a ’decoder’ $D$ . For the point-mass, the goal and state are identical; for Ant, we use a valid random joint-angle configuration at that goal position. The backtracking model is then used to find plausible trajectories that terminate at that state. For both methods, as the learner improves, one would expect that on average, higher value states are used to seed the recall traces.
+
+# 3 IMPROVING POLICIES WITH BACKTRACKING MODEL
+
+In this section, we describe how to train the backtracking model and how it can be used to improve the efficiency of the agent’s policy and aid with exploration.
+
+# 3.1 TRAINING THE BACKTRACKING MODEL
+
+We use a maximum likelihood training loss for training of the backtracking model $B _ { \phi }$ on the top $k \%$ of the agent’s trajectories stored in the state buffer $\boldsymbol { B }$ . At each iteration, we perform stochastic gradient updates based on agent trajectories $\tau$ , with respect to the following objective:
+
+$$
+\begin{array} { r l } { \mathcal { L } _ { \boldsymbol { B } } = \log q _ { \phi } ( \tau ) = \log \displaystyle \prod _ { t = 0 } ^ { T } q ( \Delta s _ { t } , a _ { t } | s _ { t + 1 } ) } & { { } = \displaystyle \sum _ { t = 0 } ^ { T } \log q ( a _ { t } | s _ { t + 1 } ) + \log q ( \Delta s _ { t } | a _ { t } , s _ { t + 1 } ) , } \end{array}
+$$
+
+where $s _ { t } = \Delta s _ { t } + s _ { t + 1 }$ and $T$ is the episode length. For our chosen backtracking model, this implies a mean-squared error loss (i.e. corresponding to a conditional Gaussian for $\Delta s _ { t }$ ) for continuous action tasks and a cross-entropy loss (i.e. corresponding to a conditional Multinoulli for $s _ { t }$ given $a _ { t }$ and $s _ { t + 1 }$ ) for discrete action tasks. The buffer is constantly updated with recent experiences and the backtracking model is trained online in order to encourage generalization as the distribution of trajectories in the buffer evolves.
+
+# 3.2 IMPROVING THE POLICY FROM THE RECALL TRACES
+
+We now describe how we use the recall traces $\tilde { \tau }$ to improve the agent’s policy $\pi _ { \theta }$ . In brief, the traces $\tilde { \tau }$ generated by the backtracking model are used as observations for imitation learning (Pomerleau, 1989; ros, 2011; Bojarski et al., 2016) by the agent. The backtracking model will be continuously updated as new actual experiences are generated, as described in Section 3.1. Imitation learning of the policy is performed simply by maximizing the log-probability of the agent’s action $a _ { t }$ given $s _ { t }$ given by
+
+$$
+\mathcal { L } _ { \mathcal { T } } = \sum _ { t = 0 } ^ { T } \log p ( a _ { t } | s _ { t } ) = \sum _ { t = 0 } ^ { T } \log \pi _ { \theta } ( a _ { t } | s _ { t } ) ,
+$$
+
+where $\left( { { s _ { t } } , { a _ { t } } } \right)$ -tuples come from a generated trace $\tilde { \tau }$ .
+
+Our motivation for having the agent imitate trajectories from the backtracking model is two-fold:
+
+# Algorithm 1 Improve Policy via Recall Traces and Backtracking Model
+
+Require: RL algorithm with parameterized policy (i.e. TRPO, Actor-Critic)   
+Require: Agent policy $\pi _ { \boldsymbol { \theta } } ( a | \boldsymbol { s } )$   
+Require: Backtracking model $B _ { \phi } = q _ { \phi } ( \Delta s _ { t } , a _ { t } | s _ { t + 1 } )$   
+Require: Critic $V ( s )$
+
+Require: $k$ quantile of best state values used to train backtracking model, $k _ { t r a j }$ number of trajectories filtered by returns.
+
+Require: $N$ ; number of backward trajectories per target state
+
+Require: $\alpha , \beta$ ; forward, backward learning rates   
+1: Randomly initialize agent policy parameters $\theta$   
+2: Randomly initialize backtracking model parameters $\phi$   
+3: for $t = 1$ to $K$ do   
+4: Execute policy to produce trajectory $\tau$   
+5: Add trajectory $\tau = ( s _ { 1 } , a _ { 1 } , r _ { 1 } , \cdot \cdot \cdot , s _ { T } , a _ { T } , r _ { T } )$ in $\boldsymbol { B }$   
+6: Estimate $\nabla _ { \boldsymbol { \theta } } R ( \pi _ { \boldsymbol { \theta } } )$ from RL algorithm   
+7: $\theta  \theta + \alpha \nabla _ { \theta } \dot { R } ( \dot { \pi } _ { \theta } )$   
+8: Compute $\mathcal { L } _ { B }$ via Equation 2, using top $k \%$ valuable states from top $k _ { t r a j }$ trajectories in $\boldsymbol { B }$   
+9: $\phi  \phi + \beta \nabla _ { \phi } \mathcal { L } _ { B }$   
+10: Obtain target high value state $s$ (see Algorithm 2 for details)   
+11: Generate $N$ recall traces $\tilde { \tau }$ for $s$ using $B _ { \phi } ( s )$   
+12: Compute imitation loss $\mathcal { L } _ { \mathcal { I } }$ via Equation 3   
+13: $\theta  \theta + \alpha \nabla _ { \theta } \mathcal { L } _ { \mathcal { Z } }$   
+14: end for
+
+Dealing with sparse rewards States with significant return are emphasized by the backtracking model, since the traces it generates are initialized at high value states. We expect this behaviour to help in the context of sparse or weak rewards.
+
+Aiding in exploration The backtracking model can also generate new ways to reach high-value states. So even if it cannot directly discover new high-value states, it can at least point to new ways to reach known high value states, thus aiding with exploration.
+
+# 4 VARIATIONAL INTERPRETATION
+
+Thus far, we have motivated the use of a backtracking model intuitively. In this section, we provide a motivation relying on a variational perspective of RL and ideas from the wake-sleep algorithm Hinton et al. (1995).
+
+Let $R$ be the return of a policy trajectory $\tau$ , i.e. the sum of discounted rewards under this trajectory. Consider the event of the return $R$ being larger than some threshold $L$ . The probability of that event under the agent’s policy is $\begin{array} { r } { p ( R > \bar { L } ) \stackrel { - } { = } \sum _ { \tau } p ( R > L | \tau ) p ( \tau ) } \end{array}$ , where $p ( \tau )$ is distribution of trajectories under policy $\pi$ , $p ( R > L | \tau ) = 1 _ { R > L }$ and $1 _ { A }$ is the indicator function that is equal to 1 if $A$ is true and is otherwise 0.
+
+Let $q ( \tau )$ be any other distribution over trajectories, then we have the following classic relationship between the marginal log-probability of an observation $( R > L$ ) and the KL-divergence between $q$ and the posterior over a latent variable $( \tau )$ :
+
+$$
+\log p ( R > L ) = \mathcal { L } + \mathrm { K L } ( q ( \tau ) | | p ( \tau | R > L ) ) \geq \mathcal { L }
+$$
+
+where
+
+$$
+\mathcal { L } = \sum _ { \tau } q ( \tau ) \log \left( p ( R > L | \tau ) p ( \tau ) / q ( \tau ) \right) .
+$$
+
+This suggests an EM-style training procedure, that alternates between training the variational distribution $q ( \tau )$ towards the posterior $p ( \tau | R > L )$ and training the policy to maximize $\mathcal { L }$ . In this context, we view the backtracking model and the high-value states sampler as providing $q ( \tau )$ implicitly. Specifically, we assume that $q$ factorizes temporally as in Equation 2 with the backtracking model providing $q ( a _ { t } | s _ { t + 1 } )$ and $q ( \Delta s _ { t } | a _ { t } , s _ { s + 1 } )$ . We parameterize the approximate posterior in this way so that we can take advantage of a model of the backwards transitions to conveniently sample from $q$ starting from a high-value final state $s _ { T }$ . This makes sense in the context of sparse rewards, where few states have significant reward. If we have a way to identify these high-reward states, then it is much easier to obtain these posterior trajectories by starting from them.
+
+Training $q ( \tau )$ by minimizing the $\mathrm { K L } ( q ( \tau ) | | p ( \tau | R > L ) )$ term is hard due to the direction of the KL-divergence. Taking inspiration from the wake-sleep algorithm (Hinton et al., 1995), we instead minimize the KL in the opposite direction, $\mathrm { K L } ( p ( \tau | R > L ) | | q ( \tau ) )$ . This can be done by sampling trajectories from $p ( \tau | R > \overline { { L } } )$ (e.g. by rejection sampling, keeping only the forward-generated trajectories which lead to $R > L$ ) and maximizing their log-probability under $q ( \tau )$ . This recovers our algorithm, which trains the backtracking model on high-return trajectories generated by the agent.
+
+So far we have assumed a known threshold $L$ . However, in practice the choice of $L$ is important. While ultimately we would want $L$ to be close to the highest possible return, at the early stages of training it cannot be, as trajectories from the agent are unlikely to reach that threshold. A better strategy is to gradually increase $L$ . One natural way of doing this is to use the top few percentile trajectories sampled by the agent for training $q ( \tau )$ , instead of explicitly setting $L$ . This approach can be thought of as providing a curriculum for training the agent that is adapted to its performance. This is also related to evolutionary methods (Hansen, 2016; Baluja, 1994), which keep the “fittest” samples from a population in order to re-estimate a model, from which new samples are generated.
+
+This variational point of view also tells us how the prior over the last state should be constructed. The ideal prior $q ( s _ { T } )$ is simply a generative model of the final states leading to $R > L$ . Both methods proposed to estimate $q ( s _ { T } )$ with this purpose, either non-parametrically (with the forward samples for which $R > L$ ) or parametrically (with generative model trained from those samples). Also, if goal states are known ahead of time, then we can set $L$ as the reward of those states (minus a small quantity) and we can seed the backwards trajectories from these goal states. In that case the variational objective used to train the policy is a proxy for log-likelihood of reaching a goal state.
+
+# 5 RELATED WORK
+
+Control as inference The idea of treating control problems as inference has been around for many years (Stengel, 1986; Kappen et al., 2012; Todorov, 2007; Toussaint, 2009; Rawlik et al., 2012). A good example of this idea is to use Expectation Maximization (EM) for RL (Dayan & Hinton, 1997), of which the PoWER algorithm (Kober et al., 2013) is one well-known practical implementation. In EM algorithms for RL, learning is divided between the estimation of the expectation over the trajectories conditioned on the reward observations and estimation of a new policy based on these expectation estimates. While we don’t explicitly try to estimate these expectations, one could argue that the samples from the backtracking model serve a similar purpose. Variational inference has also been proposed for policy search (Neumann et al., 2011; Levine & Koltun, 2013). Probabilistic views of the RL problem have also been used to construct maximum entropy methods for both regular and inverse RL (Haarnoja et al., 2017; Ziebart et al., 2008).
+
+Using off-policy trajectories By incorporating the trajectories of a separate backtracking model, our method is similar in spirit to approaches which combine on-policy learning algorithms with off-policy samples. Recent examples of this, like the interpolated policy gradient (Gu et al., 2017), PGQ (O’Donoghue et al., 2016) and ACER (Wang et al., 2016), combine policy gradient learning with ideas for off-policy learning and methodology inspired by Q-learning. Our method differs by using the backtracking model to obtain off-policy trajectories and is, as an idea, independent of the specific model-free RL method it is combined with. Our work to effectively propagate value updates backwards is also related to the seminal work of prioritized sweeping (Moore & Atkeson, 1993).
+
+Model-based methods A wide range of model-based RL and control methods have been proposed in the literature (Deisenroth et al., 2013). PILCO (Deisenroth & Rasmussen, 2011b), is a model-based policy search method to learn a probabilistic model of dynamics and incorporate model uncertainty into long-term planning. The classic Dyna (Sutton) algorithm was proposed to take advantage of a model to generate simulated experiences, which could be included in the training data for a modelfree algorithm. This method was extended to work with deep neural network policies, but performed best with models that were not neural networks (Gu et al., 2016b). Other extensions to Dyna have also been proposed (Silver et al., 2008; Kalweit & Boedecker; Heess et al., 2015).
+
+Other approaches have also been proposed to combine advantages of both value and policy-based approaches (Nachum et al., 2017; Sukhbaatar et al., 2017). Finally, (Edwards et al., 2018) is concurrent work to this and also proposes training on imagined reversal steps from known goal states. (Goyal et al., 2017) proposed to use similar learning rule in the context of generative models to modify the parameters of transition operator to make the reverse of this heated trajectory more likely under a reverse cooling process.
+
+![](images/eefea3db8f94db0088a9a43f7a5a807952871a1389f3002804e8641052c90207.jpg)  
+Figure 2: Training curves from the Four Room Environment for the Actor-Critic baseline (blue) and the backtracking model augmented Actor-Critic (orange). For the size-19 environment, several of the Actor-Critic baselines failed to converge, whereas the augmented recall trace model always succeeded in the number of training steps considered. For additional results see Figure 9 in Appendix.
+
+# 6 EXPERIMENTAL RESULTS
+
+Our experimental evaluation aims to understand whether our method can improve the sample complexity of off-policy as well as on-policy RL algorithms. Practically, we must choose the length of generated backward traces. Longer traces become increasingly likely to deviate significantly from the traces that the agent can generate from its initial state. Therefore, in our experiments, we sample fairly short traces $\tilde { \tau }$ from the backtracking model, where the length is adjusted manually based on the time-scale of each task.
+
+# We empirically show the following results across different experimental settings:
+
+• Samples from the true backtracking model can be used to improve sample efficiency. • Using a learned backtracking model starting from high value states accelerates learning for off-policy as well as on-policy experiments. • Modeling parametrically and generating high value states (using GoalGAN) also helps.
+
+# 6.1 ACCESS TO TRUE BACKTRACKING MODEL
+
+Here, we aim to check if in the ideal case when the true backtracking model is known, the proposed approach works. To investigate this, we use the four-room environment from Schaul et al. (2015) of various dimensions. The 4-room grid world is a simple environment where the agent must navigate to a goal position to receive a positive reward through bottleneck states (doorways). We compare the proposed method to the scenario where the policy is trained through the actor-critic method Konda (2002) with generalized advantage estimation (GAE) Schulman et al. (2015b)
+
+Finding the goal state becomes more challenging as the dimension increases due to sparsity of rewards. Therefore, we expect that the backtracking model would be a more effective tool in larger environments. Confirming this hypothesis, we see in Figure 2 that, as we increase the dimensionality of the maze, sample efficiency increases thanks to recall traces, compared to our baseline.
+
+# 6.2 COMPARISON WITH PRIORITIZED EXPERIENCE REPLAY
+
+Here we aim to compare the performance of recall traces with Prioritized Experience Replay (PER). PER stores the past experiences in a buffer and then selectively trains on high value experiences. We again use the Four-room Environment. PER gives an optimistic bias to the critic, and while it allows the reinforcement of sparse rewards, it also converges too quickly to an exploitation mode, which can be difficult to get out of. In order to show this, we plot the state visitation counts of a policies trained with PER and recall traces and see that the latter visit more states.
+
+![](images/16904e4d69cdc495b305097ef7fc9f8953482a4c5bf15fda554ad0ab1918f903.jpg)  
+Figure 3: Visitation count visualization of trained policies for PER (left) and Recall Traces (right) for two 4-room grid sizes.
+
+![](images/cfbc408eb978e61773fbef4dc973e3dfbdf4be94733efa8523371b9c37ed7847.jpg)  
+Figure 4: Plots for reward vs. time steps, comparing the performance of recall traces (labeled BacktrackingModel), PER and baseline Actor Critic (AC).
+
+We show in Figure 4 that while PER is competitive in the smaller 11x11 environment, recall traces outperform it in the larger 15x15 environment. Figure 3 also shows how the use of a backtracking model and recall traces pushes the policy to visit a wider variety of grid positions than PER.
+
+# 6.3 LEARNED BACKTRACKING MODEL FROM GENERATED STATES
+
+One situation in which states to start the backtracking model at are naturally available, is when the method is combined with an algorithm for sub-goal selection. We chose to investigate how well the backtracking model can be used in conjunction with the automatic goal generation algorithm from Held et al. (2017), Goal GAN. It uses a Generative Adversarial Network to produce sub-goals at the appropriate level of difficulty for the agent to reach. As the agent learns, new sub-goals of increasing difficulty are generated. This way, the agent is pressured to explore and learn to be able to reach any location in the state space. We hypothesize that the backtracking model should help the agent to reach the sub-goals faster and explore more efficiently.
+
+Hence, in this learning scenario, what changes is that high value states are now generated by Goal GAN instead of being selected by a critic from a replay buffer.
+
+We performed experiments on the U-Maze Ant task described in Held et al. (2017). It is a challenging robotic locomotion task where a quadruped robot has to navigate its center of mass within some particular distance of a target goal. The objective is to cover as much of the space of the U-shaped maze as possible. We find that using the backtracking model improves data efficiency, by reaching a coverage of more than $63 \%$ in 155 steps, instead of 275 steps without it (Fig 5). More visualizations and learning curves for U-Maze Ant task as well as the N-Dimensional Point Mass task can be found in Appendix (Figs. 11, 12 and 13).
+
+# 6.4 LEARNED BACKTRACKING MODEL - ON-POLICY CASE
+
+We conducted robotic locomotion experiments using the MuJoCo simulator (Todorov et al., 2012). We use the same setup as (Nagabandi et al., 2017). We compare our approach with a pure model-free method on standard benchmark locomotion tasks, to learn the fastest forward-moving gait possible. The model-free approach we consider is the rllab implementation of trust region policy optimization (TRPO) Schulman et al. (2015a). For the TRPO baseline we use the same setup as Nagabandi et al. (2017). See the appendix for the model implementation details.
+
+![](images/5b169c2be83e36aa4be472bee8085e14f1730dca1ed186e974ea6708c8bd23b6.jpg)  
+Figure 5: Visualization of GoalGAN baseline (b) vs backtracking model (c) policy performance for different parts of the state space for Ant Maze task. Red indicates complete success; blue indicates failure. Backtracking model achieves equal coverage rates in fewer steps of training.
+
+Performance across tasks: The results in Figure 6 show that our method consistently outperforms TRPO on all of the benchmark tasks in terms of final performance, and learns substantially faster.
+
+![](images/875638c64e7dda53f3ad3a9db7338b2219a3121cda68c8d620aecd1412d1f5b5.jpg)  
+Figure 6: Our model as compared to TRPO. For TRPO baselines, except walker, we ran with 5 different random seeds. For our model, we ran with 5 different random seeds.
+
+# 6.5 LEARNED BACKTRACKING MODEL - OFF POLICY CASE
+
+Here, we evaluate on the same range of challenging continuous control tasks from the OpenAI gym benchmark suite. We compare to Soft Actor Critic (SAC) (Haarnoja et al., 2018), shown to be more sample efficient compared to other off-policy algorithms such as DDPG (Lillicrap et al., 2015) and which consistently outperforms DDPG. Part of the reason for choosing SAC instead of DDPG was that the latter is also known to be more sensitive to hyper-parameter settings, limiting its effectiveness on complex tasks Henderson et al. (2017). For SAC, we use the same hyper-parameters reported in Haarnoja et al. (2018). Implementation details for our model are listed in the Appendix.
+
+Performance across tasks - The results in Figure 7 show that our method consistently improves the performance of SAC on all of the benchmark tasks, leading to faster learning. In fact, the largest improvement is observed on the hardest task, Ant.
+
+![](images/fa977aca2b3a0e6eedfa7c38633d2d6447fb877a9108781a0e86ef394a9801f8.jpg)  
+Figure 7: Our model as compared to SAC. We ran SAC baselines with 2 different random seeds. For our model, we ran with 5 different random seeds.
+
+# 7 DISCUSSION
+
+We advocate for the use of a backtracking model for improving sample efficiency and exploration in RL. The method can easily be combined with popular RL algorithms like TRPO and soft actorcritic. Our results indicate that the recall traces generated by such models are able to accelerate learning on a variety of tasks. We also show that the method can be combined with automatic goal generation. The Appendix provides more analysis on the sensitivity of our method to various factors and ablations. We show that a random model is outperformed by a trained backtracking model, confirming its usefulness and present plots showing the effect of varying the length of recall traces.
+
+For future work, while we observed empirically that the method has practical value and could relate its workings from a variational perspective, but more could be done to improve our theoretical understanding of its convergence behavior and what kind of assumptions need to hold about the environment. It would also be interesting to investigate how the backtracking model can be combined with forward models from a more conventional model-based system.
+
+# 8 ACKNOWLEDGEMENTS
+
+The authors acknowledge the important role played by their colleagues at Mila throughout the duration of this work. The authors would like to thank Alessandro Sordoni for being involved in the earlier phase of the project, and for the Four Room Code. AG would like to thank Doina Precup, Matthew Botvinick, Konrad Kording for useful discussions. William Fedus would like to thank Evan Racah and Valentin Thomas for useful discussions and edits. The authors would also like to thank Nicolas Le Roux, Rahul Sukthankar, Gatan Marceau Caron, Maxime Chevalier-Boisvert, Justin Fu, Nasim Rahaman for the feedback on the draft. The authors would also like to thank NSERC, CIFAR, Google Research, Samsung, Nuance, IBM and Canada Research Chairs, Nvidia for funding, and Compute Canada for computing resources.
+
+# REFERENCES
+
+A reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, 2011.
+
+Shumeet Baluja. Population-based incremental learning: A method for integrating genetic search based function optimization and competitive learning. Technical report, 1994.
+
+Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, 2016.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+Silvia Chiappa, Sebastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment ´ simulators. arXiv preprint arXiv:1704.02254, 2017.
+
+Peter Dayan and Geoffrey E Hinton. Using expectation-maximization for reinforcement learning. Neural Computation, 9(2):271–278, 1997.
+
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011a.
+
+Marc Peter Deisenroth and Carl Edward Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, pp. 465–472, USA, 2011b. Omnipress. ISBN 978- 1-4503-0619-5. URL http://dl.acm.org/citation.cfm?id $=$ 3104482.3104541.
+
+Marc Peter Deisenroth, Gerhard Neumann, and Jan Peters. A survey on policy search for robotics. Foundations and Trends in Robotics, 2(12):1–142, 2013. ISSN 1935-8253. doi: 10.1561/2300000021. URL http://dx.doi.org/10.1561/2300000021.
+
+Ashley D Edwards, Laura Downs, and James C Davidson. Forward-backward reinforcement learning. arXiv preprint arXiv:1803.10227, 2018.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Anirudh Goyal Alias Parth Goyal, Nan Rosemary Ke, Surya Ganguli, and Yoshua Bengio. Variational walkback: Learning a transition operator as a stochastic recurrent net. In Advances in Neural Information Processing Systems, pp. 4392–4402, 2017.
+
+Shixiang Gu, Timothy Lillicrap, Zoubin Ghahramani, Richard E Turner, and Sergey Levine. Qprop: Sample-efficient policy gradient with an off-policy critic. arXiv preprint arXiv:1611.02247, 2016a.
+
+Shixiang Gu, Timothy P. Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. CoRR, abs/1603.00748, 2016b.
+
+Shixiang Gu, Tim Lillicrap, Richard E Turner, Zoubin Ghahramani, Bernhard Scholkopf, and Sergey ¨ Levine. Interpolated policy gradient: Merging on-policy and off-policy gradient estimation for deep reinforcement learning. In NIPS, 2017.
+
+Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. arXiv preprint arXiv:1702.08165, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. CoRR, abs/1801.01290, 2018.
+
+Nikolaus Hansen. The CMA evolution strategy: A tutorial. CoRR, abs/1604.00772, 2016. URL http://arxiv.org/abs/1604.00772.
+
+Nicolas Heess, Greg Wayne, David Silver, Timothy P. Lillicrap, Yuval Tassa, and Tom Erez. Learning continuous control policies by stochastic value gradients. abs/1510.09142, 2015.
+
+David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for reinforcement learning agents. arXiv preprint arXiv:1705.06366, 2017.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. abs/1709.06560, 2017.
+
+Geoffrey E Hinton, Peter Dayan, Brendan J Frey, and Radford M Neal. The” wake-sleep” algorithm for unsupervised neural networks. Science, 268(5214):1158–1161, 1995.
+
+Gabriel Kalweit and Joschka Boedecker. Uncertainty-driven imagination for continuous deep reinforcement learning. In Proceedings of the 1st Annual Conference on Robot Learning, volume 78 of Proceedings of Machine Learning Research.
+
+Hilbert J Kappen, Vicenc¸ Gomez, and Manfred Opper. Optimal control as a graphical model infer- ´ ence problem. Machine learning, 87(2):159–182, 2012.
+
+Jens Kober, J Andrew Bagnell, and Jan Peters. Reinforcement learning in robotics: A survey. The International Journal of Robotics Research, 32(11):1238–1274, 2013.
+
+Vijaymohan Konda. Actor-critic Algorithms. PhD thesis, Cambridge, MA, USA, 2002. AAI0804543.
+
+Sergey Levine and Vladlen Koltun. Variational policy search via trajectory optimization. In NIPS, 2013.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016.
+
+Andrew W Moore and Christopher G Atkeson. Prioritized sweeping: Reinforcement learning with less data and less time. Machine learning, 13(1):103–130, 1993.
+
+Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the gap between value and policy based reinforcement learning. In NIPS, 2017.
+
+Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. arXiv preprint arXiv:1708.02596, 2017.
+
+Gerhard Neumann et al. Variational inference for policy search in changing situations. In ICML 2011, 2011.
+
+Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Pgq: Combining policy gradient and q-learning. arXiv preprint arXiv:1611.01626, 2016.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS, 2015.
+
+Georg Ostrovski, Marc G Bellemare, Aaron van den Oord, and Remi Munos. Count-based explo- ´ ration with neural density models. arXiv preprint arXiv:1703.01310, 2017.
+
+Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information processing systems, pp. 305–313, 1989.
+
+Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Robotics: science and systems, volume 13, pp. 3052–3056, 2012.
+
+Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, 2015.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. CoRR, abs/1502.05477, 2015a.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael I. Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. CoRR, abs/1506.02438, 2015b.
+
+David Silver, Richard S. Sutton, and Martin Muller. Sample-based learning and search with perma- ¨ nent and transient memories. In Proceedings of the 25th International Conference on Machine Learning, ICML ’08, 2008.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016.
+
+Robert F Stengel. Optimal control and estimation. Courier Corporation, 1986.
+
+Sainbayar Sukhbaatar, Ilya Kostrikov, Arthur Szlam, and Rob Fergus. Intrinsic motivation and automatic curricula via asymmetric self-play. arXiv preprint arXiv:1703.05407, 2017.
+
+Richard S. Sutton. Dyna, an integrated architecture for learning, planning, and reacting. SIGART Bull.
+
+E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In IROS, 2012.
+
+Emanuel Todorov. Linearly-solvable markov decision problems. In NIPS, 2007.
+
+Marc Toussaint. Robot trajectory optimization using approximate inference. In Proceedings of the 26th annual international conference on machine learning, 2009.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016.
+
+Theophane Weber, Sebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \` Danilo Jimenez Rezende, Adria Puigdom \` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \` Razvan Pascanu, Peter Battaglia, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017.
+
+Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, 2008.
+
+A PSEUDO CODE FOR GAN BASED MODEL
+
+# Algorithm 2 Produce High Value States
+
+Require: Critic $V ( s )$   
+Require: $D$ ; transformation ’decoder’ from $g$ to $s$   
+Require: Experience buffer $\boldsymbol { B }$ with tuples $\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \right)$   
+Require: gen state; boolean whether to generate states   
+Require: $G A N$ , some generative model trained to model high-value goal states   
+1: if gen state then   
+2: $g \sim G A N$   
+3: $D : g \mapsto s$   
+4: Return $s$   
+5: else   
+6: Return argmax ${ \mathrm { : } } ( V ( s ) ) \ \forall s \in B$   
+7: end if
+
+# B PERFORMANCE BY VARYING LENGTH
+
+In Figure 8 we show the performance in learning efficiency when the length of the backward traces is varied.
+
+![](images/4cbdae02d8b7c74ee8f08da2d651f18271753ec52476874e17bfea3939e7074e.jpg)  
+Figure 8: Performance of our model (with TRPO) by varying the length of traces from backtracking model. All the time-steps are in thousands i.e $( \mathbf { x } 1 0 0 0 )$
+
+# C ARCHITECTURE AND IMPLEMENTATION DETAILS
+
+The backtracking model we used for all the experiments consisted of two multi-layer perceptrons: one for the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ and one for the backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ . Both MLPs had two hidden layers of 128 units. The action predictor used hyperbolic tangent units while the inverse state predictor used ReLU units. Each network produced as output the mean and variance parameters of a Gaussian distribution. For the action predictor the output variance was fixed to 1. For the state predictor this value was learned for each dimension.
+
+We do about a hundred training-steps of the backtracking model for every 5 training-steps of the RL algorithm. For training the backtracking model we maintain a buffer which stores states (state, action, nextstate, reward) yielding high rewards. We sample a batch from the buffer and then normalize the states, actions before training the backtracking model on them.
+
+During the sampling phase we feed in the normalized nextstate in the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ to get normalized action. Then we input this normalized action in the backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ to get normalized previous state. We then un-normalize the obtained previous states and action using the corresponding mean and variance to compute the Imitation loss. This is required for stability during sampling.
+
+# D ADDITIONAL RESULTS
+
+# FOUR ROOM ENVIRONMENT
+
+![](images/09743a08e364150927a6aa7be84b01ba8cc7daec12d4f13ba72a09f8e14aa2dd.jpg)  
+Figure 9: Training curves from the Four Room Environment for the Actor-Critic baseline (blue) and the backtracking model augmented Actor-Critic (orange). As the size of the environment increases, the benefit of the backtracking model increases for the policy. For the size-19 environment, several of the Actor-Critic baselines failed to converge, whereas the augmented recall trace model always succeeded in the number of training steps considered.
+
+# COMPARISON WITH PER
+
+We show additional results for 13 Dimensional Environment.
+
+![](images/5f20b21a9b4e2692d1f0c9882b70552984a8b86f870ff82ca03354e587f06ef0.jpg)  
+Figure 10: Plot(a) for Reward(y) vs Timesteps $\mathbf { \tau } ( \mathbf { x } )$ comparing the performance of backtracking model, PER and baseline Actor Critic. We can see that backtracking model consistently beats PER and the gap increases for increasing dimension. Heatmaps(b,c) indicating the visitation count on various positions of the grid on trained policies for the 13-Dimensional environment. We can see that the Backtracking visits a lot more states that PER does.
+
+# U-MAZE NAVIGATION
+
+An agent has to navigate within $\epsilon -$ distance of the goal position at the end of a U-shaped maze.
+
+For the Point Mass U-Maze navigation, we use high return trajectories for training the parameters of backtracking model (i.e those trajectories which reach sub-goals defined by Goal GAN). We sample a trajectory of length 20 from our backtracking model and the recall traces are used to improve the policy via imitation learning.
+
+For the Ant U-Maze navigation, we train identically, only with length-50 traces.
+
+![](images/b78722a6896dfa20ea01b2ca545cbafb94a59d0b9bc9dc0414d25015b12e58cb.jpg)  
+Figure 11: Visualization of Goal GAN baseline (top row) versus backtracking model (bottom row) for different parts of the state space for the N-Dimensional Point Mass task. Red indicates complete success; blue indicates failure. Using the backtracking model achieves greater coverage rates for the same or fewer steps of training.
+
+![](images/dec55ba58a5188d0926ed0268a0b778e4ed85cceb16cd4298443cfa9b51674e8.jpg)  
+Figure 12: Visualization of Goal GAN baseline (top row) versus backtracking model (bottom row) policy performance for different parts of the state space for Ant Maze task. Red indicates complete success; blue indicates failure. Using the backtracking model achieves equal coverage rates in fewer steps of training.
+
+![](images/db42253b4d38cc46437d958badf97da719ba6533e8fc315ec625bf1c70cf500f.jpg)  
+Figure 13: Learning curves comparing the training efficiency of our method and the baseline for both the point mass as well as ant maze task. The y-axis indicates the average return over all goal positions in the maze, and the $\mathbf { X }$ -axis corresponds to the number of iterations which are used for sampling goals.
+
+# E HYPERPARAMETERS
+
+# E.1 ON-POLICY. TRPO
+
+For training the backtracking model, we used an explicit buffer to store states(state, action, nextstate, reward) which yields high rewards. Since, we don’t have an explicit value function, we use high reward states as a proxy for high value states. We tried training the backtracking model directly from the trajectories, but it was unstable, due to changing distributions of trajectories.
+
+Table 1: On-Policy TRPO Hyper-params:- Length of the trajectory sampled from our backtracking model   
+
+<table><tr><td>Agent</td><td>Length of trajectory Sampled from Backtracking model</td></tr><tr><td>Half-Cheetah</td><td>20</td></tr><tr><td>Walker</td><td>20</td></tr><tr><td>Hopper</td><td>10</td></tr><tr><td>Ant</td><td>50</td></tr></table>
+
+# E.2 OFF-POLICY. SAC
+
+For training the backtracking model, we used the high value states (under the current value function) from the buffer $\boldsymbol { B }$ . We sample a batch of 20K high value tuples from the experience replay buffer. The length of trajectory sampled from backtracking model for each agent is shown in Table 1.
+
+The rest of the model hyperparameters are identical to those used in Soft Actor Critic Held et al. (2017).   
+Table 2: Off Policy SAC Hyperparams:- Length of the trajectory sampled from our backtracking model   
+
+<table><tr><td>Agent</td><td>Length of trajectory Sampled from Backtracking model</td></tr><tr><td>Half-Cheetah</td><td>20</td></tr><tr><td>Walker</td><td>20</td></tr><tr><td>Hopper</td><td>20</td></tr><tr><td>Ant</td><td>50</td></tr><tr><td>Humanoid</td><td>50</td></tr></table>
+
+# E.3 PRIORITIZED EXPERIENCE REPLAY
+
+The Experience Replay Buffer capacity was fixed at $1 0 0 \mathrm { k }$ . No entropy regularization was used.
+
+Table 3: Hyperparameters for the PER Implementation.   
+
+<table><tr><td>Environment Size</td><td>Batch-size</td><td>Num. of Actor Critic steps per PER step</td><td>PER-α</td><td>PER β</td></tr><tr><td>11x11</td><td>200</td><td>3</td><td>0.8</td><td>0.1</td></tr><tr><td>13x13</td><td>2000</td><td>3</td><td>0.8</td><td>0.1</td></tr><tr><td>15x15</td><td>1000</td><td>3</td><td>0.95</td><td>0.1</td></tr></table>
+
+# F RANDOM SEARCH WITH BACKWARD MODEL
+
+We test the performance of backtracking model when it is not learned i.e the backtracking model is a random model, in the Four Room Environment. In this experiment, we compare the scenario when the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ is learned and when it is random. Since in the Four Room Environment, we have access to the true backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ we use that for this experiment. The comparison is shown in the figure 14. It is clear from the figure that it is helpful to learn the backward action predictor $Q \big ( a _ { t } | s _ { t + 1 } \big )$ .
+
+![](images/ea74d0cb96855ca9c9b6544c67337796f29b048aa68dd758dab9878dbe77ce83.jpg)  
+Figure 14: Training curves from the Four Room Environment for the Actor-Critic baseline (blue), the backtracking model augmented Actor-Critic (red), and the random search (blue).
+
+Figure 15 shows the same comparison for Ant-v1, and Walker2d-v1 where the baseline is Soft Actor Critic (SAC). For our baseline i.e the scenario when backtracking model is not learned, we experimented with all the lengths 1,2,3,4,5, 10 and we choose the best one as our baseline. As you can see in the Figure 15, backtracking model performs best as compared to SAC baseline as well as to the scenario when backtracking model is not trained. Hence proving that backtracking model is not just doing random search.
+
+![](images/b42b9d4ddaf88f8a8435604795ff5967eabae29950911b090243a97fe8efd84b.jpg)  
+Figure 15: Training curves for the Walker2d and Ant agent. Comparing when the backtracking model is learned v/s when it’s not learned.
+
+# G COMPARISON TO MODEL BASED RL
+
+Dyna algorithm uses a forward model to generate simulated experience that could be included in a model-free algorithm. This method can be used to work with deep neural network policies, but performed best with models which are not neural networks (Gu et al., 2016a). Our intuition says that it might be better to generate simulated experience from backtracking model (starting from a high value state) as compared to forward model, just because we know that traces from backtracking model are good, as they lead to high value state, which is not really the case for the simulated experience from a forward model. In Fig 16, we evaluate the Forward model with On-Policy TRPO on Ant and Humanoid Mujoco tasks. We were not able to get any better results on with forward model as compared to the Baseline TRPO, which is consistent with the findings from (Gu et al., 2016a).
+
+![](images/057d6cc25fd96ff975e278b44720002a6806ad6662bb9a5cf89bbf2e64ee1e12.jpg)  
+Figure 16: Forward Model compared with Baseline TRPO. We can clearly see that on Ant and Humanoid Mujoco tasks using a forward Model-based approach doesn’t help.
+
+Building the backward model is necessarily neither harder nor easier. Realistically, building any kind of model and having it be accurate for more than, say, 10 time steps is pretty hard. But if we only have 10 time steps of accurate transitions, it is probably better to take them backward model from different states as compared to from forward model from the same initial state. (as corroborated by our experiments).
+
+Something which remains as a part of future investigation is to train the forward model and backtracking model jointly. As backtracking model is tied to high value state, the forward model could extract the goal value from the high value state. When trained jointly, this should help the forward model learn some reduced representation of the state that is necessary to evaluate the reward. Ultimately, when planning, we want the model to predict the goal accurately, which helps to optimize for this ”goal-oriented” behaviour directly. This also avoids the need to model irrelevant aspects of the environment.
+
+# H LEARNING THE TRUE ENVIRONMENT VS LEARNING FROM RECALL TRACES
+
+Here, we show the results of various ablations in the four-room environment which highlight the effect various hyperparameters have on performance.
+
+In Fig 17 we train on the recall traces after a fixed number of iterations of learning in the true environment. For all of the environments, as we increase the ratio of updates in the true environment to updates using recall traces from backward model, the performance decreases significantly. This again highlights the advantages of learning from recall traces.
+
+In Fig. 18, we see the effects of training from the recall traces multiple times for every iteration of training in the true environment. We can see that as we increase the number of iteration of learning from recall traces, we correspondingly need to choose smaller trace length. For each update in the real environment, making more number of updates helps if the trace length is smaller, and if the trace length is larger, it has a detrimental effect on the learning process as is seen in 18. Also as observed in the cases of $1 2 \mathrm { x } 1 2$ and 14x14 environment, it may happen that for an increased ratio of learning from recall traces and high trace length, the model achieves the maximum reward initially but after sometime the average reward plummets.
+
+![](images/1516aac4eb9b061f278485bc1bafd0f9a7a37c4fda916c3b354950ec349bfe32.jpg)  
+Figure 17: Legend indicates the ratio of updates in the true environment to updates using recall traces. Here we learn more in the true environment than using traces. We can see that not learning regularly from recall traces gives decreased performance.
+
+![](images/a49e244caa64990da77e888e6cd6b2fc5f5e7dcfe914b3c148d3fe9c74da71ba.jpg)  
+Figure 18: Legend indicates the ratio of updates in the true environment to updates using recall traces with the trajectory length of traces in parenthesis. Here we learn more using recall traces than actual environment. This tells that more updates using recall traces helps if we have a correspondingly lower trajectory length
+
+# OFF POLICY CASE FOR MUJOCO
+
+We investigate the effect of doing more updates from the generated recall traces on some Mujoco tasks using Off-Policy SAC. As can be seen from 19, we find that using more traces helps and that for an increased number of updates we need to correspondingly shorten the trajectory length of the sampled traces.
+
+![](images/11a11f30b732120634bc0a832b845bd06da09fd7d44a5b1864ad8e5bb983ee0d.jpg)  
+Figure 19: Legend indicates the number of updates from recall traces(per 5 updates of SAC) with the trajectory length in parentheses. In both the environments doing 10 or 20 updates is better than 5 updates. Also for 20 updates we need to choose a smaller trajectory of length 10 as compared to length 20 for 10(and 5) updates.
+
+These experiments show that there is a balance between how much we should train in the actual environment and how much we should learn from the traces generated from the backward model. In the smaller four room-environment, 1:1 balance performed the best. In Mujoco tasks and larger four room environments, doing more updates from the backward model helps, but in the smaller four room maze, doing more updates is detrimental. So depending upon the complexity of the task, we need to decide this ratio.

parse/train/KmykpuSrjcq/KmykpuSrjcq.md

@@ -0,0 +1,390 @@
+# PROTOTYPICAL CONTRASTIVE LEARNING OF UNSUPERVISED REPRESENTATIONS
+
+Junnan Li, Pan Zhou, Caiming Xiong, Steven C.H. Hoi
+
+Salesforce Research {junnan.li,pzhou,cxiong,shoi}@salesforce.com
+
+# ABSTRACT
+
+This paper presents Prototypical Contrastive Learning (PCL), an unsupervised representation learning method that bridges contrastive learning with clustering. PCL not only learns low-level features for the task of instance discrimination, but more importantly, it encodes semantic structures discovered by clustering into the learned embedding space. Specifically, we introduce prototypes as latent variables to help find the maximum-likelihood estimation of the network parameters in an Expectation-Maximization framework. We iteratively perform E-step as finding the distribution of prototypes via clustering and M-step as optimizing the network via contrastive learning. We propose ProtoNCE loss, a generalized version of the InfoNCE loss for contrastive learning, which encourages representations to be closer to their assigned prototypes. PCL outperforms state-of-the-art instance-wise contrastive learning methods on multiple benchmarks with substantial improvement in low-resource transfer learning. Code and pretrained models are available at https://github.com/salesforce/PCL.
+
+# 1 INTRODUCTION
+
+Unsupervised visual representation learning aims to learn image representations from pixels themselves without relying on semantic annotations, and recent advances are largely driven by instance discrimination tasks (Wu et al., 2018; Ye et al., 2019; He et al., 2020; Misra & van der Maaten, 2020; Hjelm et al., 2019; Oord et al., 2018; Tian et al., 2019). These methods usually consist of two key components: image transformation and contrastive loss. Image transformation aims to generate multiple embeddings that represent the same image, by data augmentation (Ye et al., 2019; Bachman et al., 2019; Chen et al., 2020a), patch perturbation (Misra & van der Maaten, 2020), or using momentum features (He et al., 2020). The contrastive loss, in the form of a noise contrastive estimator (Gutmann & Hyvärinen, 2010), aims to bring closer samples from the same instance and separate samples from different instances. Essentially, instance-wise contrastive learning leads to an embedding space where all instances are well-separated, and each instance is locally smooth (i.e. input with perturbations have similar representations).
+
+Despite their improved performance, instance discrimination methods share a common weakness: the representation is not encouraged to encode the semantic structure of data. This problem arises because instance-wise contrastive learning treats two samples as a negative pair as long as they are from different instances, regardless of their semantic similarity. This is magnified by the fact that thousands of negative samples are generated to form the contrastive loss, leading to many negative pairs that share similar semantics but are undesirably pushed apart in the embedding space.
+
+In this paper, we propose prototypical contrastive learning (PCL), a new framework for unsupervised representation learning that implicitly encodes the semantic structure of data into the embedding space. Figure 1 shows an illustration of PCL. A prototype is defined as “a representative embedding for a group of semantically similar instances”. We assign several prototypes of different granularity to each instance, and construct a contrastive loss which enforces the embedding of a sample to be more similar to its corresponding prototypes compared to other prototypes. In practice, we can find prototypes by performing clustering on the embeddings.
+
+We formulate prototypical contrastive learning as an Expectation-Maximization (EM) algorithm, where the goal is to find the parameters of a Deep Neural Network (DNN) that best describes the data distribution, by iteratively approximating and maximizing the log-likelihood function. Specifically, we introduce prototypes as additional latent variables, and estimate their probability in the E-step by performing $k$ -means clustering. In the M-step, we update the network parameters by minimizing our proposed contrastive loss, namely ProtoNCE. We show that minimizing ProtoNCE is equivalent to maximizing the estimated log-likelihood, under the assumption that the data distribution around each prototype is isotropic Gaussian. Under the EM framework, the widely used instance discrimination task can be explained as a special case of prototypical contrastive learning, where the prototype for each instance is its augmented feature, and the Gaussian distribution around each prototype has the same fixed variance. The contributions of this paper can be summarized as follows:
+
+![](images/0612404d791db647e84c0565fc5fc55d0773e5012448b77f5e6b956269c5d548.jpg)  
+Figure 1: Illustration of Prototypical Contrastive Learning. Each instance is assigned to multiple prototypes with different granularity. PCL learns an embedding space which encodes the semantic structure of data.
+
+• We propose prototypical contrastive learning, a novel framework for unsupervised representation learning that bridges contrastive learning and clustering. The learned representation is encouraged to capture the hierarchical semantic structure of the dataset. • We give a theoretical framework that formulates PCL as an Expectation-Maximization (EM) based algorithm. The iterative steps of clustering and representation learning can be interpreted as approximating and maximizing the log-likelihood function. The previous methods based on instance discrimination form a special case in the proposed EM framework. • We propose ProtoNCE, a new contrastive loss which improves the widely used InfoNCE by dynamically estimating the concentration for the feature distribution around each prototype. ProtoNCE also includes an InfoNCE term in which the instance embeddings can be interpreted as instancebased prototypes. We provide explanations for PCL from an information theory perspective, by showing that the learned prototypes contain more information about the image classes. PCL outperforms instance-wise contrastive learning on multiple benchmarks with substantial improvements in low-resource transfer learning. PCL also leads to better clustering results.
+
+# 2 RELATED WORK
+
+Our work is closely related to two main branches of studies in unsupervised/self-supervised learning: instance-wise contrastive learning and deep unsupervised clustering.
+
+Instance-wise contrastive learning (Wu et al., 2018; Ye et al., 2019; He et al., 2020; Misra & van der Maaten, 2020; Zhuang et al., 2019; Hjelm et al., 2019; Oord et al., 2018; Tian et al., 2019; Chen et al., 2020a) aims to learn an embedding space where samples (e.g. crops) from the same instance (e.g. an image) are pulled closer and samples from different instances are pushed apart. To construct the contrastive loss, positive instance features and negative instance features are generated for each sample. Different contrastive learning methods vary in their strategy to generate instance features. The memory bank approach (Wu et al., 2018) stores the features of all samples calculated in the previous step. The end-to-end approach (Ye et al., 2019; Tian et al., 2019; Chen et al., 2020a) generates instance features using all samples within the current mini-batch. The momentum encoder approach (He et al., 2020) encodes samples on-the-fly by a momentum-updated encoder, and maintains a queue of instance features.
+
+Despite their improved performance, the existing methods based on instance-wise contrastive learning have the following two major limitations, which can be addressed by the proposed PCL framework.
+
+• The task of instance discrimination could be solved by exploiting low-level image differences, thus the learned embeddings do not necessarily capture high-level semantics. This is supported by the fact that the accuracy of instance classification often rapidly rises to a high level $( > 9 0 \%$ within 10 epochs) and further training gives limited informative signals. A recent study also shows that better performance of instance discrimination could worsen the performance on downstream tasks (Tschannen et al., 2020).
+
+• A sufficiently large number of negative instances need to be sampled, which inevitably yields negative pairs that share similar semantic meaning and should be closer in the embedding space. However, they are undesirably pushed apart by the contrastive loss. Such problem is defined as class collision in (Saunshi et al., 2019) and is shown to hurt representation learning. Essentially, instance discrimination learns an embedding space that only preserves the local smoothness around each instance but largely ignores the global semantic structure of the dataset.
+
+Deep unsupervised clustering. Clustering based methods have been proposed for deep unsupervised learning. Xie et al. (2016); Yang et al. (2016); Liao et al. (2016); Yang et al. (2017); Chang et al. (2017); Ji et al. (2019); Gansbeke et al. (2020) jointly learn image embeddings and cluster assignments, but they have not shown the ability to learn transferable representations from a large scale of images. Closer to our work, DeepCluster (Caron et al., 2018) performs iterative clustering and unsupervised representation learning, which is further improved by Zhan et al. (2020) with online clustering. However, our method is conceptually different from DeepCluster. In DeepCluster, the cluster assignments are considered as pseudo-labels and a classification objective is optimized, which results in two weaknesses: (1) the high-dimensional features from the penultimate layer of a ConvNet are not optimal for clustering and need to be PCA-reduced; (2) an additional linear classification layer is frequently re-initialized which interferes with representation learning. In our method, representation learning happens directly in a low-dimensional embedding space, by optimizing a contrastive loss on the prototypes (cluster centroids). Concurrent to our work, SwAV (Caron et al., 2020) also brings together a clustering objective with contrastive learning.
+
+Self-supervised pretext tasks. Another line of self-supervised learning methods focus on training DNNs to solve pretext tasks, which usually involve hiding certain information about the input and training the network to recover those missing information. Examples include image inpainting (Pathak et al., 2016), colorization (Zhang et al., 2016; 2017), prediction of patch orderings (Doersch et al., 2015; Noroozi & Favaro, 2016) and image transformations (Dosovitskiy et al., 2014; Gidaris et al., 2018; Caron et al., 2019; Zhang et al., 2019). Compared to heuristic pretext task designs, the proposed PCL is a more general learning framework with better theoretical justification.
+
+# 3 PROTOTYPICAL CONTRASTIVE LEARNING
+
+# 3.1 PRELIMINARIES
+
+Given a training set $X = \{ x _ { 1 } , x _ { 2 } , . . . , x _ { n } \}$ of $n$ images, unsupervised visual representation learning aims to learn an embedding function $f _ { \theta }$ (realized via a DNN) that maps $X$ to $V = \{ v _ { 1 } , v _ { 2 } , . . . , v _ { n } \}$ with $v _ { i } = f _ { \theta } ( x _ { i } )$ , such that $v _ { i }$ best describes $x _ { i }$ . Instance-wise contrastive learning achieves this objective by optimizing a contrastive loss function, such as InfoNCE (Oord et al., 2018; He et al., 2020), defined as:
+
+$$
+\mathcal { L } _ { \mathrm { I n f o N C E } } = \sum _ { i = 1 } ^ { n } - \log \frac { \exp ( v _ { i } \cdot v _ { i } ^ { \prime } / \tau ) } { \sum _ { j = 0 } ^ { r } \exp ( v _ { i } \cdot v _ { j } ^ { \prime } / \tau ) } ,
+$$
+
+where $v _ { i }$ and $\boldsymbol { v } _ { i } ^ { \prime }$ are positive embeddings for instance $i$ , and $\boldsymbol { v } _ { j } ^ { \prime }$ includes one positive embedding and $r$ negative embeddings for other instances, and $\tau$ is a temperature hyper-parameter. In MoCo (He et al., 2020), these embeddings are obtained by feeding $x _ { i }$ to a momentum encoder parametrized by $\theta ^ { \prime }$ , $, v _ { i } ^ { \prime } = f _ { \theta ^ { \prime } } ( x _ { i } )$ , where $\theta ^ { \prime }$ is a moving average of $\theta$ .
+
+In prototypical contrastive learning, we use prototypes $c$ instead of $v ^ { \prime }$ , and replace the fixed temperature $\tau$ with a per-prototype concentration estimation $\phi$ . An overview of our training framework is shown in Figure 2, where clustering and representation learning are performed iteratively at each epoch. Next, we will delineate the theoretical framework of PCL based on EM. A pseudo-code of our algorithm is given in appendix B.
+
+![](images/4f1ab2fc7ccccdda98417ee196e1fadceac522f5ec844708adc2491697a3ab43.jpg)  
+Figure 2: Training framework of Prototypical Contrastive Learning.
+
+# 3.2 PCL AS EXPECTATION-MAXIMIZATION
+
+Our objective is to find the network parameters $\theta$ that maximizes the log-likelihood function of the observed $n$ samples:
+
+$$
+\theta ^ { * } = \arg \operatorname* { m a x } _ { \theta } \sum _ { i = 1 } ^ { n } \log p ( x _ { i } ; \theta )
+$$
+
+We assume that the observed data $\{ x _ { i } \} _ { i = 1 } ^ { n }$ are related to latent variable $C = \{ c _ { i } \} _ { i = 1 } ^ { k }$ which denotes the prototypes of the data. In this way, we can re-write the log-likelihood function as:
+
+$$
+\theta ^ { * } = \arg \operatorname* { m a x } _ { \theta } \sum _ { i = 1 } ^ { n } \log p ( x _ { i } ; \theta ) = \arg \operatorname* { m a x } _ { \theta } \sum _ { i = 1 } ^ { n } \log \sum _ { c _ { i } \in C } p ( x _ { i } , c _ { i } ; \theta )
+$$
+
+It is hard to optimize this function directly, so we use a surrogate function to lower-bound it:
+
+$$
+\sum _ { i = 1 } ^ { n } \log \sum _ { { c _ { i } } \in C } p ( x _ { i } , c _ { i } ; \theta ) = \sum _ { i = 1 } ^ { n } \log \sum _ { { c _ { i } } \in C } Q ( c _ { i } ) \frac { p ( x _ { i } , c _ { i } ; \theta ) } { Q ( c _ { i } ) } \geq \sum _ { i = 1 } ^ { n } \sum _ { { c _ { i } } \in C } Q ( c _ { i } ) \log \frac { p ( x _ { i } , c _ { i } ; \theta ) } { Q ( c _ { i } ) } ,
+$$
+
+where $Q ( c _ { i } )$ denotes some distribution over $c$ ’s $\begin{array} { r } { ( \sum _ { c _ { i } \in C } Q ( c _ { i } ) = 1 ) } \end{array}$ , and the last step of derivation uses Jensen’s inequality. To make the inequality hold with equality, we require $\frac { p ( x _ { i } , c _ { i } ; \theta ) } { Q ( c _ { i } ) }$ to be a constant. Therefore, we have:
+
+$$
+Q ( c _ { i } ) = \frac { p ( x _ { i } , c _ { i } ; \theta ) } { \sum _ { c _ { i } \in C } p ( x _ { i } , c _ { i } ; \theta ) } = \frac { p ( x _ { i } , c _ { i } ; \theta ) } { p ( x _ { i } ; \theta ) } = p ( c _ { i } ; x _ { i } , \theta )
+$$
+
+By ignoring the constant $- \textstyle \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ( c _ { i } ) \log Q ( c _ { i } )$ in eqn.(4), we should maximize:
+
+$$
+\sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ( c _ { i } ) \log p ( x _ { i } , c _ { i } ; \theta )
+$$
+
+$\mathbf { E }$ -step. In this step, we aim to estimate $p ( c _ { i } ; x _ { i } , \theta )$ . To this end, we perform $k$ -means on the features $v _ { i } ^ { \prime } = \bar { f } _ { \theta ^ { \prime } } ( x _ { i } )$ given by the momentum encoder to obtain $k$ clusters. We define prototype $c _ { i }$ as the centroid for the $i$ -th cluster. Then, we compute $p ( c _ { i } ; x _ { i } , \theta ) = \mathbb { 1 } ( x _ { i } \in c _ { i } )$ , where $\mathbb { 1 } ( x _ { i } \in c _ { i } ) = 1$ if $x _ { i }$ belongs to the cluster represented by $c _ { i }$ ; otherwise $\mathbb { 1 } ( x _ { i } \in c _ { i } ) = 0$ . Similar to MoCo, we found features from the momentum encoder yield more consistent clusters.
+
+M-step. Based on the E-step, we are ready to maximize the lower-bound in eqn.(6).
+
+$$
+\begin{array} { r } { \displaystyle \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ( c _ { i } ) \log p ( x _ { i } , c _ { i } ; \theta ) = \displaystyle \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } p ( c _ { i } ; x _ { i } , \theta ) \log p ( x _ { i } , c _ { i } ; \theta ) } \\ { = \displaystyle \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } \mathbb { 1 } ( x _ { i } \in c _ { i } ) \log p ( x _ { i } , c _ { i } ; \theta ) } \end{array}
+$$
+
+Under the assumption of a uniform prior over cluster centroids, we have:
+
+$$
+p ( x _ { i } , c _ { i } ; \theta ) = p ( x _ { i } ; c _ { i } , \theta ) p ( c _ { i } ; \theta ) = \frac { 1 } { k } \cdot p ( x _ { i } ; c _ { i } , \theta ) ,
+$$
+
+where we set the prior probability $p ( c _ { i } ; \theta )$ for each $c _ { i }$ as $1 / k$ since we are not provided any samples. We assume that the distribution around each prototype is an isotropic Gaussian, which leads to:
+
+$$
+p ( x _ { i } ; c _ { i } , \theta ) = \exp { \left( \frac { - ( v _ { i } - c _ { s } ) ^ { 2 } } { 2 \sigma _ { s } ^ { 2 } } \right) } \bigg / \sum _ { j = 1 } ^ { k } \exp { \left( \frac { - ( v _ { i } - c _ { j } ) ^ { 2 } } { 2 \sigma _ { j } ^ { 2 } } \right) } ,
+$$
+
+where $v _ { i } = f _ { \theta } ( x _ { i } )$ and $x _ { i } \in c _ { s }$ . If we apply $\ell _ { 2 }$ -normalization to both $v$ and $c$ , then $( v - c ) ^ { 2 } = 2 - 2 v \cdot c .$ . Combining this with eqn.(3, 4, 6, 7, 8, 9), we can write maximum log-likelihood estimation as
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \sum _ { i = 1 } ^ { n } - \log \frac { \exp ( v _ { i } \cdot c _ { s } / \phi _ { s } ) } { \sum _ { j = 1 } ^ { k } \exp ( v _ { i } \cdot c _ { j } / \phi _ { j } ) } ,
+$$
+
+where $\phi \propto \sigma ^ { 2 }$ denotes the concentration level of the feature distribution around a prototype and will be introduced later. Note that eqn.(10) has a similar form as the InfoNCE loss in eqn.(1). Therefore, InfoNCE can be interpreted as a special case of the maximum log-likelihood estimation, where the prototype for a feature $v _ { i }$ is the augmented feature $\boldsymbol { v } _ { i } ^ { \prime }$ from the same instance (i.e. $c = v ^ { \prime }$ ), and the concentration of the feature distribution around each instance is fixed (i.e. $\phi = \tau$ ).
+
+In practice, we take the same approach as NCE and sample $r$ negative prototypes to calculate the normalization term. We also cluster the samples $M$ times with different number of clusters $K = \{ k _ { m } \} _ { m = 1 } ^ { M }$ , which enjoys a more robust probability estimation of prototypes that encodestructure. Furthermore, we add the InfoNCE loss to retain the property of local smoothness and help bootstrap clustering. Our overall objective, namely ProtoNCE, is defined as
+
+$$
+\mathcal { L } _ { \mathrm { P r o t o N C E } } = \sum _ { i = 1 } ^ { n } - \left( \log \frac { \exp ( v _ { i } \cdot v _ { i } ^ { \prime } / \tau ) } { \sum _ { j = 0 } ^ { r } \exp ( v _ { i } \cdot v _ { j } ^ { \prime } / \tau ) } + \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \log \frac { \exp ( v _ { i } \cdot c _ { s } ^ { m } / \phi _ { s } ^ { m } ) } { \sum _ { j = 0 } ^ { r } \exp ( v _ { i } \cdot c _ { j } ^ { m } / \phi _ { j } ^ { m } ) } \right) .
+$$
+
+# 3.3 CONCENTRATION ESTIMATION
+
+The distribution of embeddings around each prototype has different level of concentration. We use $\phi$ to denote the concentration estimation, where a smaller $\phi$ indicates larger concentration. Here we calculate $\phi$ using the momentum features $\{ v _ { z } ^ { \prime } \} _ { z = 1 } ^ { Z }$ that are within the same cluster as a prototype $c$ The desired $\phi$ should be small (high concentration) if (1) the average distance between $v _ { z } ^ { \prime }$ and $c$ is small, and (2) the cluster contains more feature points (i.e. $Z$ is large). Therefore, we define $\phi$ as:
+
+$$
+\phi = \frac { \sum _ { z = 1 } ^ { Z } \| v _ { z } ^ { \prime } - c \| _ { 2 } } { Z \log ( Z + \alpha ) } ,
+$$
+
+where $\alpha$ is a smooth parameter to ensure that small clusters do not have an overly-large $\phi$ . We normalize $\phi$ for each set of prototypes $C ^ { m }$ such that they have a mean of $\tau$ .
+
+In the ProtoNCE loss (eqn.(11)), $\phi _ { s } ^ { m }$ acts as a scaling factor on the similarity between an embedding $v _ { i }$ and its prototype $c _ { s } ^ { m }$ . With the proposed $\phi$ , the similarity in a loose cluster (larger $\phi$ ) are down-scaled, pulling embeddings closer to the prototype. On the contrary, embeddings in a tight cluster (smaller $\phi$ ) have an up-scaled similarity, thus less encouraged to approach the prototype. Therefore, learning with ProtoNCE yields more balanced clusters with similar concentration, as shown in Figure 3(a). It prevents a trivial solution where most embeddings collapse to a single cluster, a problem that could only be heuristically addressed by data-resampling in DeepCluster (Caron et al., 2018).
+
+# 3.4 MUTUAL INFORMATION ANALYSIS
+
+It has been shown that minimizing InfoNCE is maximizing a lower bound on the mutual information (MI) between representations $V$ and $V ^ { \prime }$ (Oord et al., 2018). Similarly, minimizing the proposed ProtoNCE can be considered as simultaneously maximizing the mutual information between $V$ and all the prototypes $\{ V ^ { \prime } , C ^ { 1 } , . . . , C ^ { M } \}$ . This leads to better representation learning, for two reasons.
+
+First, the encoder would learn the shared information among prototypes, and ignore the individual noise that exists in each prototype. The shared information is more likely to capture higher-level semantic knowledge. Second, we show that compared to instance features, prototypes have a larger mutual information with the class labels. We estimate the mutual information between the instance features (or their assigned prototypes) and the ground-truth class labels for all images in ImageNet (Deng et al., 2009) training set, following the method in (Ross, 2014). We compare the obtained MI of our method (ProtoNCE) and that of MoCo (InfoNCE). As shown in Figure 3(b), compared to instance features, the prototypes have a larger MI with the class labels due to the effect of clustering. Furthermore, compared to InfoNCE, training on ProtoNCE can increase the MI of prototypes as training proceeds, indicating that better representations are learned to form more semantically-meaningful clusters.
+
+![](images/e44aaf5d7dd1acb2ac523a000209506c1f567d1121bdcb1883a0700f0057f543.jpg)  
+Figure 3: (a) Histogram of cluster size for PCL ( $\#$ clusters $k { = } 5 0 0 0 0 )$ ) with fixed or estimated concentration. Using a different $\phi$ for each prototype yields more balanced clusters with similar sizes, which leads to better representation learning. (b) Mutual info between instance features (or their assigned prototypes) and class labels of all images in ImageNet. Compared to InfoNCE, our ProtoNCE learns better prototypes with more semantics.
+
+# 3.5 PROTOTYPES AS LINEAR CLASSIFIER
+
+Another interpretation of PCL can provide more insights into the nature of the learned prototypes. The optimization in eqn.(10) is similar to optimizing the cluster-assignment probability $p ( s ; x _ { i } , \theta )$ using the cross-entropy loss, where the prototypes $c$ represent weights for a linear classifier. With $k$ -means clustering, the linear classifier has a fixed set of weights as the mean vectors for the representations in each cluster, $\begin{array} { r } { c = { \frac { 1 } { Z } } \sum _ { z = 1 } ^ { Z } v _ { z } ^ { \prime } } \end{array}$ . A similar idea has been used for few-shot learning (Snell et al., 2017), where a non-parametric prototypical classifier performs better than a parametric linear classifier.
+
+# 4 EXPERIMENTS
+
+We evaluate PCL on transfer learning tasks, based on the principle that good representations should transfer with limited supervision and fine-tuning. We follow the settings in MoCo, therefore direct comparisons with MoCo could demonstrate the improvement from the prototypical contrastive loss.
+
+# 4.1 IMPLEMENTATION DETAILS
+
+To enable a fair comparison, we follow the same setting as MoCo. We perform training on the ImageNet-1M dataset. A ResNet-50 (He et al., 2016) is adopted as the encoder, whose last fullyconnected layer outputs a 128-D and L2-normalized feature. We follow previous works (He et al., 2020; Wu et al., 2018) and perform data augmentation with random crop, random color jittering, random horizontal flip, and random grayscale conversion. We use SGD as our optimizer, with a weight decay of 0.0001, a momentum of 0.9, and a batch size of 256. We train for 200 epochs, where we warm-up the network in the first 20 epochs by only using the InfoNCE loss. The initial learning rate is 0.03, and is multiplied by 0.1 at 120 and 160 epochs. In terms of the hyper-parameters, we set $\tau = 0 . 1$ , $\alpha = 1 0$ , $r = 1 6 0 0 0$ , and number of clusters $K = \{ 2 5 0 0 0 , 5 0 0 0 { \bar { 0 } } , 1 0 { \bar { 0 } } 0 0 0 \}$ . We also experiment with PCL v2 using improvements introduced by Chen et al. (2020a;b), which includes a MLP projection layer, stronger data augmentation with additional Gaussian blur, and temperature $\tau = 0 . 2$ . We adopt faiss (Johnson et al., 2017) for efficient $k$ -means clustering. The clustering is performed per-epoch on center-cropped images. We find over-clustering to be beneficial. Recent advances in self-supervised learning have been propelled by huge compute which is inaccessible to many researchers. We instead target a more commonly accessible training resource for PCL with 4 NVIDIA-V100 GPUs and approximately 5 days of training.
+
+Table 1: Low-shot image classification on both VOC07 and Places205 datasets using linear SVMs trained on fixed representations. All methods were pretrained on ImageNet-1M dataset for 200 epochs (except for Jigsaw trained on ImageNet-14M). We vary the number of labeled examples $k$ and report the mAP (for VOC) and accuracy (for Places) across 5 runs. We use the released pretrained model for MoCo, and re-implement SimCLR.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">architecture</td><td colspan="5">vOC07</td><td colspan="5">Places205</td></tr><tr><td>k=1</td><td>k=2</td><td>k=4</td><td>k=8</td><td>k=16</td><td>k=1</td><td>k=2</td><td>k=4</td><td>k=8</td><td>k=16</td></tr><tr><td>Random Supervised</td><td>ResNet-50</td><td>8.0 54.3</td><td>8.2 67.8</td><td>8.2 73.9</td><td>8.2 79.6</td><td>8.5 82.3</td><td>0.7 14.9</td><td>0.7 21.0</td><td>0.7 26.9</td><td>0.7 32.1</td><td>0.7 36.0</td></tr><tr><td>Jigsaw MoCo PCL (ours)</td><td>ResNet-50</td><td>26.5 31.4 46.9</td><td>31.1 42.0 56.4</td><td>40.0 49.5 62.8</td><td>46.7 60.0 70.2</td><td>51.8 65.9 74.3</td><td>4.6 8.8 11.3</td><td>6.4 13.2 15.7</td><td>9.4 18.2 19.5</td><td>12.9 23.2 24.1</td><td>17.4 28.0 28.4</td></tr><tr><td>SimCLR MoCo v2 PCL v2 (ours)</td><td>ResNet-50-MLP</td><td>32.7 46.3 47.9 59.6</td><td>43.1 58.3</td><td>52.5 64.9</td><td>61.0 72.5</td><td>67.1 76.1</td><td>9.4 10.9</td><td>14.2 16.3</td><td>19.3 20.8</td><td>23.7 26.0</td><td>28.3 30.1 32.3</td></tr></table>
+
+# 4.2 IMAGE CLASSIFICATION WITH LIMITED TRAINING DATA
+
+Low-shot classification. We evaluate the learned representation on image classification tasks with few training samples per-category. We follow the setup in Goyal et al. (2019) and train linear SVMs using fixed representations on two datasets: Places205 (Zhou et al., 2014) for scene recognition and PASCAL VOC2007 (Everingham et al., 2010) for object classification. We vary the number $k$ of samples per-class and report the average result across 5 independent runs (standard deviation is reported in appendix C). Table 1 shows the results, in which our method substantially outperforms both MoCo and SimCLR.
+
+Semi-supervised image classification. We perform semi-supervised learning experiments to evaluate whether the learned representation can provide a good basis for fine-tuning. Following the setup from Wu et al. (2018); Misra & van der Maaten (2020), we randomly select a subset $1 \%$ or $10 \%$ ) of ImageNet training data (with labels), and fine-tune the self-supervised trained model on these subsets. Table 2 reports the top-5 accuracy on ImageNet validation set. Our method sets a new state-of-the-art under 200 training epochs, outperforming both self-supervised learning methods and semi-supervised learning methods. The standard deviation across 5 runs is low $< 0 . 6$ for $1 \%$ labels).
+
+Table 2: Semi-supervised learning on ImageNet. We report top-5 accuracy on the ImageNet validation set of self-supervised models that are finetuned on $1 \%$ or $10 \%$ of labeled data. ‡: SimCLR, BYOL, and SwAV use a large batch size of 4096. ‡: SwAV uses multi-crop augmentation.   
+
+<table><tr><td>Method</td><td>architecture</td><td>#pretrain epochs</td><td>Top-5 Accuracy 1%</td><td>10%</td></tr><tr><td>Random (Wu et al., 2018)</td><td>ResNet-50</td><td></td><td>22.0</td><td>59.0</td></tr><tr><td>Supervised baseline (Zhai et al., 2019)</td><td>ResNet-50</td><td></td><td>48.4</td><td>80.4</td></tr><tr><td>Semi-supervised learningmethods:</td><td></td><td></td><td></td><td></td></tr><tr><td>Pseudolabels (Zhai etal.,2019)</td><td>ResNet-50v2</td><td></td><td>51.6</td><td>82.4</td></tr><tr><td>VAT + Entropy Min. (Miyato et al., 2019)</td><td>ResNet-50v2</td><td></td><td>47.0</td><td>83.4</td></tr><tr><td>S4L Rotation (Zhai et al.,2019)</td><td>ResNet-50v2</td><td></td><td>53.4</td><td>83.8</td></tr><tr><td>Self-supervised learningmethods:</td><td></td><td></td><td></td><td></td></tr><tr><td>Instance Discrimination (Wu et al.,2018)</td><td>ResNet-50</td><td>200</td><td>39.2</td><td>77.4</td></tr><tr><td>Jigsaw (Noroozi &amp; Favaro,2016)</td><td>ResNet-50</td><td>90</td><td>45.3</td><td>79.3</td></tr><tr><td>SimCLR (Chen et al.,2020a)</td><td>ResNet-50-MLP</td><td>200</td><td>56.5</td><td>82.7</td></tr><tr><td>MoCo (He et al.,2020)</td><td>ResNet-50</td><td>200</td><td>56.9</td><td>83.0</td></tr><tr><td>MoCo v2 (Chen et al., 2020b)</td><td>ResNet-50-MLP</td><td>200</td><td>66.3</td><td>84.4</td></tr><tr><td>PCL v2 (ours)</td><td>ResNet-50-MLP</td><td>200</td><td>73.9</td><td>85.0</td></tr><tr><td>PCL (ours)</td><td>ResNet-50</td><td>200</td><td>75.3</td><td>85.6</td></tr><tr><td>PIRL (Misra &amp; van der Maaten, 2020)</td><td>ResNet-50</td><td>800</td><td>57.2</td><td>83.8</td></tr><tr><td>SimCLR Chen et al. (2020a)</td><td>ResNet-50-MLP</td><td>1000</td><td>75.5†</td><td>87.8†</td></tr><tr><td>BYOL (Grill et al., 2020)</td><td>ResNet-50-MLPbig</td><td>1000</td><td>78.4t</td><td>89.0†</td></tr><tr><td>SwAV (Caron et al., 2020)</td><td>ResNet-50-MLP</td><td>800</td><td>78.5</td><td>89.9t</td></tr></table>
+
+# 4.3 IMAGE CLASSIFICATION BENCHMARKS
+
+Linear classifiers. Next, we train linear classifiers on fixed image representations using the entire labeled training data. We evaluate the performance of such linear classifiers on three datasets: ImageNet, VOC07, and Places205. Table 3 reports the results. PCL outperforms MoCo under direct comparison, which demonstrate the advantage of the proposed prototypical contrastive loss.
+
+Table 3: Image classification with linear models. We report top-1 accuracy. Numbers with ∗ are from released pretrained model; all other numbers are adopted from corresponding papers. †: LocalAgg uses 10-crop evaluation. ADMIM uses FastAutoAugment (Lim et al., 2019) that is supervised by ImageNet labels. SwAV uses multi-crop augmentation. SimCLR, BYOL, and SwAV use a large batch size of 4096.   
+
+<table><tr><td>Method</td><td>architecture (#params)</td><td>#pretrain epochs</td><td>ImageNet</td><td>Dataset VOC07</td><td>Places205</td></tr><tr><td>Jigsaw (Noroozi &amp; Favaro,2016) Rotation (Gidaris et al.,2018) DeepCluster (Caron et al., 2018) BigBiGAN (Donahue &amp; Simonyan, 2019) InstDisc (Wu et al., 2018) MoCo (He et al., 2020)</td><td>R50 (24M) R50 (24M) VGG(15M) R50 (24M) R50 (24M) R50 (24M)</td><td>90 1 100 200</td><td>45.7 48.9 48.4 56.6 54.0</td><td>64.5 63.9 71.9 1 一</td><td>41.2 41.4 37.9 1 45.5</td></tr><tr><td>SimCLR(Chen et al.,2020a) MoCo v2(Chen et al.,2020b) PCL v2 (ours)</td><td>R50 (24M) R50-MLP (28M) R50-MLP (28M) R50-MLP (28M)</td><td>200 200 200 200</td><td>61.5 61.9 67.5 67.6</td><td>82.3 一 84.0* 85.4</td><td>49.2 50.1* 50.3</td></tr><tr><td>SelfLabel (Asano et al.,2020) CPC (Oord et al., 2018)</td><td>R50 (24M) R50 (24M)</td><td>200 400</td><td>60.2† 61.5</td><td>1 1</td><td>50.1†</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>R50 (24M)</td><td>800</td><td></td><td></td><td>49.8</td></tr><tr><td></td><td></td><td>280</td><td>64.0</td><td></td><td></td></tr><tr><td></td><td>R101 (28M)</td><td></td><td>48.7</td><td>1</td><td>1</td></tr><tr><td>CMC (Tian et al.,2019)</td><td>R50L+ab (47M)</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>1</td><td>一</td></tr><tr><td>PIRL (Misra &amp; van der Maaten,2020)</td><td></td><td></td><td>63.6</td><td>81.1</td><td></td></tr><tr><td>AMDIM (Bachman et al.,2019)</td><td>Custom (626M)</td><td>150</td><td>68.1†</td><td>一</td><td>55.0+</td></tr><tr><td>SimCLR (Chen et al.,2020a)</td><td>R50-MLP (28M)</td><td>1000</td><td>69.3†</td><td>80.5†</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1</td></tr><tr><td>BYOL (Grill et al., 2020)</td><td>R50-MLPbig(35M)</td><td>1000</td><td>74.3†</td><td>-</td><td></td></tr><tr><td>SwAV (Caron et al.,2020)</td><td>R50-MLP (28M)</td><td>800</td><td>75.3t</td><td>88.9t</td><td>56.7+</td></tr></table>
+
+KNN classifiers. We perform $\mathbf { k }$ -nearest neighbor (kNN) classification on ImageNet. For a query image with feature $v$ , we take its top $k$ nearest neighbors from the momentum features, and perform weighted-combination of their labels where the weights are calculated by $\exp ( v \cdot v _ { i } ^ { \prime } / \tau )$ . Table 4 reports the accuracy. Our method substantially outperforms previous methods.
+
+Table 4: Image classification with kNN classifiers using ResNet-50 features on ImageNet.   
+
+<table><tr><td>Method</td><td>Inst.Disc.(Wu et al.,2018)|MoCo (He et al.,2020)|LA (Zhuang et al.,2019)|PCL (ours)</td><td></td><td></td><td></td></tr><tr><td>Accuracy</td><td>46.5</td><td>47.1</td><td>49.4</td><td>54.5</td></tr></table>
+
+# 4.4 CLUSTERING EVALUATION
+
+In Table 5, we evaluate the $k$ -means clustering performance on ImageNet using representations learned by different methods. PCL leads to substantially higher adjusted mutual information (AMI) score. Details are given in appendix F.
+
+<table><tr><td></td><td>Method|DeepCluster (Caron et al., 2018)|MoCo (He et al.,2020)|PCL (ours)</td><td></td><td></td></tr><tr><td>AMI</td><td>0.281</td><td>0.285</td><td>0.410</td></tr></table>
+
+Table 5: AMI score for $\mathbf { k }$ -means clustering $k = 2 5 0 0 0 )$ on ImageNet representation.
+
+# 4.5 OBJECT DETECTION
+
+We assess the representation on object detection. Following Goyal et al. (2019), we train a Faster R-CNN (Ren et al., 2015) on VOC07 or $\mathrm { v o c } 0 7 { + } 1 2$ , and evaluate on the test set of VOC07. We keep the pretrained backbone frozen to better evaluate the learned representation, and use the same schedule for all methods. Table 6 reports the average mAP across three runs. Our method substantially closes the gap between self-supervised methods and supervised training. In appendix D, we show the results for fine-tuning the pretrained model for object detection and instance segmentation on COCO (Lin et al., 2014), where PCL outperforms both MoCo and supervised training.
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Pretrain Dataset|Architecture</td><td rowspan=1 colspan=1>Pretrain Dataset|Architecture</td><td rowspan=1 colspan=2>Training dataVOC07 VOC07+12</td></tr><tr><td rowspan=1 colspan=1>Supervised</td><td rowspan=1 colspan=1>ImageNet-1M</td><td rowspan=1 colspan=1>Resnet-50-FPN</td><td rowspan=1 colspan=1>72.8</td><td rowspan=1 colspan=1>79.3</td></tr><tr><td rowspan=1 colspan=1>MoCo (He et al.,2020)PCL (ours)</td><td rowspan=1 colspan=1>ImageNet-1MImageNet-1M</td><td rowspan=1 colspan=1>Resnet-50-FPNResnet-50-FPN</td><td rowspan=1 colspan=1>66.471.7</td><td rowspan=1 colspan=1>73.578.5</td></tr></table>
+
+Table 6: Object detection for frozen conv body on VOC using Faster R-CNN.
+
+# 5 VISUALIZATION OF LEARNED REPRESENTATION
+
+In Figure 4, we visualize the unsupervised learned representation of ImageNet training images using t-SNE (Maaten & Hinton, 2008). Compared to the representation learned by MoCo, the representation learned by the proposed PCL forms more separated clusters, which also suggests representation of lower entropy.
+
+![](images/79db6061c20db4241e80f5466ea60ca4ddbd74e67a6138faa58313f4f6748406.jpg)  
+Figure 4: T-SNE visualization of the unsupervised learned representation for ImageNet training images from the first 40 classes. Left: MoCo; Right: PCL (ours). Colors represent classes.
+
+# 6 CONCLUSION
+
+This paper proposes Prototypical Contrastive Learning, a generic unsupervised representation learning framework that finds network parameters to maximize the log-likelihood of the observed data. We introduce prototypes as latent variables, and perform iterative clustering and representation learning in an EM-based framework. PCL learns an embedding space which encodes the semantic structure of data, by training on the proposed ProtoNCE loss. Our extensive experiments on multiple benchmarks demonstrate the advantage of PCL for unsupervised representation learning.
+
+# REFERENCES
+
+Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. In ICLR, 2020.
+
+Philip Bachman, R. Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019.
+
+Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In ECCV, pp. 139–156, 2018.
+
+Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Unsupervised pre-training of image features on non-curated data. In ICCV, pp. 2959–2968, 2019.
+
+Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. In NeurIPS, 2020.
+
+Jianlong Chang, Lingfeng Wang, Gaofeng Meng, Shiming Xiang, and Chunhong Pan. Deep adaptive image clustering. In ICCV, pp. 5880–5888, 2017.
+
+Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, Zheng Zhang, Dazhi Cheng, Chenchen Zhu, Tianheng Cheng, Qijie Zhao, Buyu Li, Xin Lu, Rui Zhu, Yue Wu, Jifeng Dai, Jingdong Wang, Jianping Shi, Wanli Ouyang, Chen Change Loy, and Dahua Lin. MMDetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020a.
+
+Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020b.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Fei-Fei Li. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255, 2009.
+
+Carl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In ICCV, pp. 1422–1430, 2015.
+
+Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In NeurIPS, pp. 10541–10551, 2019.
+
+Alexey Dosovitskiy, Jost Tobias Springenberg, Martin A. Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In NIPS, pp. 766–774, 2014.
+
+Mark Everingham, Luc Van Gool, Christopher K. I. Williams, John M. Winn, and Andrew Zisserman. The pascal visual object classes (VOC) challenge. International Journal of Computer Vision, 88 (2):303–338, 2010.
+
+Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: A library for large linear classification. JMLR, 9:1871–1874, 2008.
+
+Wouter Van Gansbeke, Simon Vandenhende, Stamatios Georgoulis, Marc Proesmans, and Luc Van Gool. SCAN: learning to classify images without labels. In ECCV, pp. 268–285, 2020.
+
+Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. In ICLR, 2018.
+
+Ross Girshick, Ilija Radosavovic, Georgia Gkioxari, Piotr Dollár, and Kaiming He. Detectron. https://github.com/facebookresearch/detectron, 2018.
+
+Priya Goyal, Dhruv Mahajan, Abhinav Gupta, and Ishan Misra. Scaling and benchmarking selfsupervised visual representation learning. In ICCV, pp. 6391–6400, 2019.
+
+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, Bilal Piot, Koray Kavukcuoglu, Rémi Munos, and Michal Valko. Bootstrap your own latent: A new approach to self-supervised learning. In NeurIPS, 2020.
+
+Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In AISTATS, pp. 297–304, 2010.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. In ICCV, pp. 2980–2988, 2017.
+
+Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, 2020.
+
+R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.
+
+Xu Ji, João F Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised image classification and segmentation. In ICCV, pp. 9865–9874, 2019.
+
+Jeff Johnson, Matthijs Douze, and Hervé Jégou. Billion-scale similarity search with gpus. arXiv preprint arXiv:1702.08734, 2017.
+
+Renjie Liao, Alexander G. Schwing, Richard S. Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In NIPS, pp. 5076–5084, 2016.
+
+Sungbin Lim, Ildoo Kim, Taesup Kim, Chiheon Kim, and Sungwoong Kim. Fast autoaugment. In NeurIPS, pp. 6662–6672, 2019.
+
+Tsung-Yi Lin, Michael Maire, Serge J. Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft COCO: common objects in context. In ECCV, pp. 740–755, 2014.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9:2579–2605, 2008.
+
+Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning. IEEE Trans. Pattern Anal. Mach. Intell., 41(8):1979–1993, 2019.
+
+Xuan Vinh Nguyen, Julien Epps, and James Bailey. Information theoretic measures for clusterings comparison: Variants, properties, normalization and correction for chance. J. Mach. Learn. Res., 11:2837–2854, 2010.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, pp. 69–84, 2016.
+
+Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
+
+Deepak Pathak, Philipp Krähenbühl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context encoders: Feature learning by inpainting. In CVPR, pp. 2536–2544, 2016.
+
+Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards real-time object detection with region proposal networks. In NIPS, pp. 91–99, 2015.
+
+Brian C Ross. Mutual information between discrete and continuous data sets. PloS one, 9(2), 2014.
+
+Nikunj Saunshi, Orestis Plevrakis, Sanjeev Arora, Mikhail Khodak, and Hrishikesh Khandeparkar. A theoretical analysis of contrastive unsupervised representation learning. In ICML, pp. 5628–5637, 2019.   
+Jake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. In NIPS, pp. 4077–4087, 2017.   
+Yonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   
+Michael Tschannen, Josip Djolonga, Paul K. Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. In ICLR, 2020.   
+Zhirong Wu, Yuanjun Xiong, Stella X. Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In CVPR, pp. 3733–3742, 2018.   
+Junyuan Xie, Ross B. Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In ICML, pp. 478–487, 2016.   
+Bo Yang, Xiao Fu, Nicholas D. Sidiropoulos, and Mingyi Hong. Towards k-means-friendly spaces: Simultaneous deep learning and clustering. In ICML, pp. 3861–3870, 2017.   
+Jianwei Yang, Devi Parikh, and Dhruv Batra. Joint unsupervised learning of deep representations and image clusters. In CVPR, pp. 5147–5156, 2016.   
+Mang Ye, Xu Zhang, Pong C. Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In CVPR, pp. 6210–6219, 2019.   
+Xiaohua Zhai, Avital Oliver, Alexander Kolesnikov, and Lucas Beyer. S4l: Self-supervised semisupervised learning. In ICCV, pp. 1476–1485, 2019.   
+Xiaohang Zhan, Jiahao Xie, Ziwei Liu, Yew-Soon Ong, and Chen Change Loy. Online deep clustering for unsupervised representation learning. In CVPR, pp. 6687–6696, 2020.   
+Liheng Zhang, Guo-Jun Qi, Liqiang Wang, and Jiebo Luo. AET vs. AED: unsupervised representation learning by auto-encoding transformations rather than data. In CVPR, 2019.   
+Richard Zhang, Phillip Isola, and Alexei A. Efros. Colorful image colorization. In ECCV, pp. 649–666, 2016.   
+Richard Zhang, Phillip Isola, and Alexei Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In CVPR, pp. 1058–1067, 2017.   
+Bolei Zhou, Àgata Lapedriza, Jianxiong Xiao, Antonio Torralba, and Aude Oliva. Learning deep features for scene recognition using places database. In NIPS, pp. 487–495, 2014.   
+Chengxu Zhuang, Alex Lin Zhai, and Daniel Yamins. Local aggregation for unsupervised learning of visual embeddings. In ICCV, pp. 6002–6012, 2019.
+
+# APPENDIX A ABLATION ON PROTONCE
+
+The proposed loss in eqn.(11) contains two terms: the instance-wise contrastive loss and the proposed prototypical contrastive loss. Here we study the effect of each term on representation learning. Table 7 reports the results for low-resource fine-tuning and linear classification on ImageNet. The prototypical term plays an important role, especially in the fine-tuning experiment. The warm-up also improves the result by bootstrapping the clustering with better representations.
+
+Table 7: Effect of instance-wise contrastive loss and prototypical contrastive loss.   
+
+<table><tr><td>Method</td><td></td><td>1% fine-tuning (top-5 acc.)|linear classification (top-1 acc.)</td></tr><tr><td>instance only</td><td>56.9</td><td>60.6</td></tr><tr><td>proto only (w/o warm-up)</td><td>60.7</td><td>60.4</td></tr><tr><td>proto only (w/ warm-up)</td><td>72.3</td><td>60.9</td></tr><tr><td>instance + proto (w/o warm-up)</td><td>74.6</td><td>61.3</td></tr><tr><td>instance + proto (w/ warm-up)</td><td>75.3</td><td>61.5</td></tr></table>
+
+# APPENDIX B PSEUDO-CODE FOR PROTOTYPICAL CONTRASTIVE LEARNING
+
+# Algorithm 1: Prototypical Contrastive Learning.
+
+1 Input: encoder $f _ { \theta }$ , training dataset $X$ , number of clusters $K = \{ k _ { m } \} _ { m = 1 } ^ { M }$   
+2 $\theta ^ { \prime } = \theta$ // initialize momentum encoder as the encoder   
+3 while not MaxEpoch do /\* E-step \*/   
+4 $V ^ { \prime } = f _ { \theta ^ { \prime } } ( X )$ // get momentum features for all training data   
+5 for $m = 1$ to $M$ do   
+6 $C ^ { m } = k { \mathrm { - m e a n s } } ( V ^ { \prime } , k _ { m } )$ // cluster $V ^ { \prime }$ into $k _ { m }$ clusters, return prototypes   
+7 $\phi _ { m } = \mathrm { C o n c e n t r a t i o n } ( C ^ { m } , V ^ { \prime } )$ // estimate the distribution concentration around each prototype with Equation 12   
+8 end /\* M-step \*/   
+9 for $_ x$ in Dataloader $( X )$ do // load a minibatch $x$   
+10 $v = f _ { \theta } ( x ) , v ^ { \prime } = \dot { f } _ { \theta ^ { \prime } } ( x )$ // forward pass through encoder and momentum encoder   
+11 $\begin{array} { r l } { \mathcal { L } _ { \mathrm { P r o t o N C E } } ( v , v ^ { \prime } , \{ C ^ { m } \} _ { m = 1 } ^ { M } , \{ \phi _ { m } \} _ { m = 1 } ^ { M } ) } & { { } } \end{array}$ // calculate loss with Equation 11   
+12 $\theta = \mathrm { S G D } ( \mathcal { L } _ { \mathrm { P r o t o N C E } } , \theta )$ ) // update encoder parameters   
+13 $\theta ^ { \prime } = 0 . 9 9 9 * \theta ^ { \prime } + 0 . 0 0 1 * \theta$ // update momentum encoder   
+14 end   
+15 end
+
+# APPENDIX D COCO OBJECT DETECTION AND SEGMENTATION
+
+Following the experiment setting in (He et al., 2020), we use Mask R-CNN (He et al., 2017) with C4 backbone. We finetune all layers end-to-end on the COCO train2017 set and evaluate on val2017. The schedule is the default $2 \times$ in (Girshick et al., 2018). PCL outperforms both MoCo (He et al., 2020) and supervised pre-training in all metrics.
+
+<table><tr><td>Method</td><td>Apbb</td><td>AP</td><td>AP</td><td>Apmk</td><td>AP</td><td>AP</td></tr><tr><td>Supervised</td><td>40.0</td><td>59.9</td><td>43.1</td><td>34.7</td><td>56.5</td><td>36.9</td></tr><tr><td>MoCo (He et al., 2020)</td><td>40.7</td><td>60.5</td><td>44.1</td><td>35.4</td><td>57.3</td><td>37.6</td></tr><tr><td>PCL (ours)</td><td>41.0</td><td>60.8</td><td>44.2</td><td>35.6</td><td>57.4</td><td>37.8</td></tr></table>
+
+Table 9: Object detection and instance segmentation fine-tuned on COCO. We evaluate bounding-box AP $( \mathsf { A P } ^ { \mathsf { b b } } )$ and mask AP $( \mathbf { A P } ^ { \mathrm { m k } } )$ on val2017.
+
+# APPENDIX E TRAINING DETAILS FOR TRANSFER LEARNING EXPERIMENTS
+
+For training linear SVMs on Places and VOC, we follow the procedure in (Goyal et al., 2019) and use the LIBLINEAR (Fan et al., 2008) package. We preprocess all images by resizing to 256 pixels along the shorter side and taking a $2 2 4 \times 2 2 4$ center crop. The linear SVMs are trained on the global average pooling features of ResNet-50.
+
+For image classification with linear models, we use the pretrained representations from the global average pooling features (2048-D) for ImageNet and VOC, and the conv5 features (averaged pooled to ${ \sim } 9 0 0 0 { \cdot } \mathrm { D }$ ) for Places. We train a linear SVM for VOC, and a logistic regression classifier (a fully-connected layer followed by softmax) for ImageNet and Places. The logistic regression classifier is trained using SGD with a momentum of 0.9. For ImageNet, we train for 100 epochs with an initial learning rate of 10 and a weight decay of 0. Similar hyper-parameters are used by (He et al., 2020). For Places, we train for 40 epochs with an initial learning rate of 0.3 and a weight decay of 0.
+
+For semi-supervised learning, we finetune ResNet-50 with pretrained weights on a subset of ImageNet with labels. We optimize the model with SGD, using a batch size of 256, a momentum of 0.9, and a weight decay of 0.0005. We apply different learning rate to the ConvNet and the linear classifier. The learning rate for the ConvNet is 0.01, and the learning rate for the classifier is 0.1 (for $10 \%$ labels) or 1 (for $1 \%$ labels). We train for 20 epochs, and drop the learning rate by 0.2 at 12 and 16 epochs.
+
+For object detection on VOC, We use the R50-FPN backbone for the Faster R-CNN detector available in the MMdetection (Chen et al., 2019) codebase. We freeze all the conv layers and also fix the BatchNorm parameters. The model is optimized with SGD, using a batch size of 8, a momentum of 0.9, and a weight decay of 0.0001. The initial learning rate is set as 0.05. We finetune the models for 15 epochs, and drop the learning rate by 0.1 at 12 epochs.
+
+# APPENDIX F EVALUATION OF CLUSTERING
+
+In order to evaluate the quality of the clusters produced by PCL, we compute the adjusted mutual information score (AMI) (Nguyen et al., 2010) between the clusterings and the ground-truth labels for ImageNet training data. AMI is adjusted for chance which accounts for the bias in MI to give high values to clusterings with a larger number of clusters. AMI has a value of 1 when two partitions are identical, and an expected value of 0 for random (independent) partitions. In Figure 5, we show the AMI scores for three clusterings obtained by PCL, with number of clusters $\bar { K ^ { - } } = \{ 2 5 0 0 0 , 5 0 0 0 0 , 1 0 0 0 0 0 \}$ . In Table 5, we show that compared to DeepCluster (Caron et al., 2018) and MoCo (He et al., 2020), PCL produces clusters of substantially higher quality.
+
+![](images/dfc398fbd4dac745833851887787811eb9242fa23b4ab3f02fe67df9d6d4f7e1.jpg)  
+Figure 5: Adjusted mutual information score between the clusterings generated by PCL and the ground-truth labels for ImageNet training data.
+
+# APPENDIX G CONVERGENCE PROOF
+
+Here we provide the proof that the proposed PCL would converge. Suppose let
+
+$$
+\begin{array} { r } { F ( \theta ) = \displaystyle \sum _ { i = 1 } ^ { n } \log p ( x _ { i } ; \theta ) = \displaystyle \sum _ { i = 1 } ^ { n } \log \sum _ { c _ { i } \in C } p ( x _ { i } , c _ { i } ; \theta ) = \displaystyle \sum _ { i = 1 } ^ { n } \log \sum _ { c _ { i } \in C } Q ( c _ { i } ) \frac { p ( x _ { i } , c _ { i } ; \theta ) } { Q ( c _ { i } ) } } \\ { \geq \displaystyle \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ( c _ { i } ) \log \frac { p ( x _ { i } , c _ { i } ; \theta ) } { Q ( c _ { i } ) } . } \end{array}
+$$
+
+We have shown in Section 3.2 that the above inequality holds with equality when $Q ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \theta )$ . At the $t$ -th E-step, we have estimated $Q ^ { t } ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \theta ^ { t } )$ . Therefore we have:
+
+$$
+F ( \theta ^ { t } ) = \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ^ { t } ( c _ { i } ) \log \frac { p ( x _ { i } , c _ { i } ; \theta ^ { t } ) } { Q ^ { t } ( c _ { i } ) } .
+$$
+
+At the $t$ -th M-step, we fix $Q ^ { t } ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \theta ^ { t } )$ and train parameter $\theta$ to maximize Equation 14. Therefore we always have:
+
+$$
+F ( \theta ^ { t + 1 } ) \geq \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ^ { t } ( c _ { i } ) \log \frac { p ( x _ { i } , c _ { i } ; \theta ^ { t + 1 } ) } { Q ^ { t } ( c _ { i } ) } \geq \sum _ { i = 1 } ^ { n } \sum _ { c _ { i } \in C } Q ^ { t } ( c _ { i } ) \log \frac { p ( x _ { i } , c _ { i } ; \theta ^ { t } ) } { Q ^ { t } ( c _ { i } ) } = F ( \theta ^ { t } ) .
+$$
+
+The above result suggests that $F ( \theta ^ { t } )$ monotonously increase along with more iterations. Hence the algorithm will converge.
+
+# APPENDIX H VISUALIZATION OF CLUSTERS
+
+In Figure 6, we show ImageNet training images that are randomly chosen from clusters generated by the proposed PCL. PCL not only clusters images from the same class together, but also finds fine-grained patterns that distinguish sub-classes, demonstrating its capability to learn useful semantic representations.
+
+![](images/1e4146cb6ce2c5169a5ec1608ea8593463e090a9f89e6ba8e6b80c0addd06d27.jpg)  
+Figure 6: Visualization of randomly chosen clusters generated by PCL. Green boarder marks top-5 images that are closest to fine-grained prototypes $K = 1 0 0 k$ ). Orange boarder marks images randomly chosen from coarse-grained clusters $K = 5 0 k$ ) that also cover the same green images. PCL can discover hierarchical semantic structures within the data (e.g. images with horse and man form a fine-grained cluster within the coarse-grained horse cluster.)

parse/train/KmykpuSrjcq/KmykpuSrjcq_content_list.json

@@ -0,0 +1,1861 @@
+[
+    {
+        "type": "text",
+        "text": "PROTOTYPICAL CONTRASTIVE LEARNING OF UNSUPERVISED REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            718,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Junnan Li, Pan Zhou, Caiming Xiong, Steven C.H. Hoi ",
+        "bbox": [
+            184,
+            169,
+            566,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Salesforce Research {junnan.li,pzhou,cxiong,shoi}@salesforce.com ",
+        "bbox": [
+            186,
+            185,
+            616,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            242,
+            544,
+            258
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper presents Prototypical Contrastive Learning (PCL), an unsupervised representation learning method that bridges contrastive learning with clustering. PCL not only learns low-level features for the task of instance discrimination, but more importantly, it encodes semantic structures discovered by clustering into the learned embedding space. Specifically, we introduce prototypes as latent variables to help find the maximum-likelihood estimation of the network parameters in an Expectation-Maximization framework. We iteratively perform E-step as finding the distribution of prototypes via clustering and M-step as optimizing the network via contrastive learning. We propose ProtoNCE loss, a generalized version of the InfoNCE loss for contrastive learning, which encourages representations to be closer to their assigned prototypes. PCL outperforms state-of-the-art instance-wise contrastive learning methods on multiple benchmarks with substantial improvement in low-resource transfer learning. Code and pretrained models are available at https://github.com/salesforce/PCL. ",
+        "bbox": [
+            233,
+            276,
+            766,
+            469
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            500,
+            336,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised visual representation learning aims to learn image representations from pixels themselves without relying on semantic annotations, and recent advances are largely driven by instance discrimination tasks (Wu et al., 2018; Ye et al., 2019; He et al., 2020; Misra & van der Maaten, 2020; Hjelm et al., 2019; Oord et al., 2018; Tian et al., 2019). These methods usually consist of two key components: image transformation and contrastive loss. Image transformation aims to generate multiple embeddings that represent the same image, by data augmentation (Ye et al., 2019; Bachman et al., 2019; Chen et al., 2020a), patch perturbation (Misra & van der Maaten, 2020), or using momentum features (He et al., 2020). The contrastive loss, in the form of a noise contrastive estimator (Gutmann & Hyvärinen, 2010), aims to bring closer samples from the same instance and separate samples from different instances. Essentially, instance-wise contrastive learning leads to an embedding space where all instances are well-separated, and each instance is locally smooth (i.e. input with perturbations have similar representations). ",
+        "bbox": [
+            174,
+            526,
+            825,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite their improved performance, instance discrimination methods share a common weakness: the representation is not encouraged to encode the semantic structure of data. This problem arises because instance-wise contrastive learning treats two samples as a negative pair as long as they are from different instances, regardless of their semantic similarity. This is magnified by the fact that thousands of negative samples are generated to form the contrastive loss, leading to many negative pairs that share similar semantics but are undesirably pushed apart in the embedding space. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose prototypical contrastive learning (PCL), a new framework for unsupervised representation learning that implicitly encodes the semantic structure of data into the embedding space. Figure 1 shows an illustration of PCL. A prototype is defined as “a representative embedding for a group of semantically similar instances”. We assign several prototypes of different granularity to each instance, and construct a contrastive loss which enforces the embedding of a sample to be more similar to its corresponding prototypes compared to other prototypes. In practice, we can find prototypes by performing clustering on the embeddings. ",
+        "bbox": [
+            174,
+            791,
+            823,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We formulate prototypical contrastive learning as an Expectation-Maximization (EM) algorithm, where the goal is to find the parameters of a Deep Neural Network (DNN) that best describes the data distribution, by iteratively approximating and maximizing the log-likelihood function. Specifically, we introduce prototypes as additional latent variables, and estimate their probability in the E-step by performing $k$ -means clustering. In the M-step, we update the network parameters by minimizing our proposed contrastive loss, namely ProtoNCE. We show that minimizing ProtoNCE is equivalent to maximizing the estimated log-likelihood, under the assumption that the data distribution around each prototype is isotropic Gaussian. Under the EM framework, the widely used instance discrimination task can be explained as a special case of prototypical contrastive learning, where the prototype for each instance is its augmented feature, and the Gaussian distribution around each prototype has the same fixed variance. The contributions of this paper can be summarized as follows: ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/0612404d791db647e84c0565fc5fc55d0773e5012448b77f5e6b956269c5d548.jpg",
+        "image_caption": [
+            "Figure 1: Illustration of Prototypical Contrastive Learning. Each instance is assigned to multiple prototypes with different granularity. PCL learns an embedding space which encodes the semantic structure of data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            87,
+            782,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            332,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose prototypical contrastive learning, a novel framework for unsupervised representation learning that bridges contrastive learning and clustering. The learned representation is encouraged to capture the hierarchical semantic structure of the dataset. • We give a theoretical framework that formulates PCL as an Expectation-Maximization (EM) based algorithm. The iterative steps of clustering and representation learning can be interpreted as approximating and maximizing the log-likelihood function. The previous methods based on instance discrimination form a special case in the proposed EM framework. • We propose ProtoNCE, a new contrastive loss which improves the widely used InfoNCE by dynamically estimating the concentration for the feature distribution around each prototype. ProtoNCE also includes an InfoNCE term in which the instance embeddings can be interpreted as instancebased prototypes. We provide explanations for PCL from an information theory perspective, by showing that the learned prototypes contain more information about the image classes. PCL outperforms instance-wise contrastive learning on multiple benchmarks with substantial improvements in low-resource transfer learning. PCL also leads to better clustering results. ",
+        "bbox": [
+            173,
+            464,
+            826,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            341,
+            695
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work is closely related to two main branches of studies in unsupervised/self-supervised learning: instance-wise contrastive learning and deep unsupervised clustering. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instance-wise contrastive learning (Wu et al., 2018; Ye et al., 2019; He et al., 2020; Misra & van der Maaten, 2020; Zhuang et al., 2019; Hjelm et al., 2019; Oord et al., 2018; Tian et al., 2019; Chen et al., 2020a) aims to learn an embedding space where samples (e.g. crops) from the same instance (e.g. an image) are pulled closer and samples from different instances are pushed apart. To construct the contrastive loss, positive instance features and negative instance features are generated for each sample. Different contrastive learning methods vary in their strategy to generate instance features. The memory bank approach (Wu et al., 2018) stores the features of all samples calculated in the previous step. The end-to-end approach (Ye et al., 2019; Tian et al., 2019; Chen et al., 2020a) generates instance features using all samples within the current mini-batch. The momentum encoder approach (He et al., 2020) encodes samples on-the-fly by a momentum-updated encoder, and maintains a queue of instance features. ",
+        "bbox": [
+            174,
+            738,
+            825,
+            890
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Despite their improved performance, the existing methods based on instance-wise contrastive learning have the following two major limitations, which can be addressed by the proposed PCL framework. ",
+        "bbox": [
+            174,
+            897,
+            825,
+            926
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• The task of instance discrimination could be solved by exploiting low-level image differences, thus the learned embeddings do not necessarily capture high-level semantics. This is supported by the fact that the accuracy of instance classification often rapidly rises to a high level $( > 9 0 \\%$ within 10 epochs) and further training gives limited informative signals. A recent study also shows that better performance of instance discrimination could worsen the performance on downstream tasks (Tschannen et al., 2020). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• A sufficiently large number of negative instances need to be sampled, which inevitably yields negative pairs that share similar semantic meaning and should be closer in the embedding space. However, they are undesirably pushed apart by the contrastive loss. Such problem is defined as class collision in (Saunshi et al., 2019) and is shown to hurt representation learning. Essentially, instance discrimination learns an embedding space that only preserves the local smoothness around each instance but largely ignores the global semantic structure of the dataset. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep unsupervised clustering. Clustering based methods have been proposed for deep unsupervised learning. Xie et al. (2016); Yang et al. (2016); Liao et al. (2016); Yang et al. (2017); Chang et al. (2017); Ji et al. (2019); Gansbeke et al. (2020) jointly learn image embeddings and cluster assignments, but they have not shown the ability to learn transferable representations from a large scale of images. Closer to our work, DeepCluster (Caron et al., 2018) performs iterative clustering and unsupervised representation learning, which is further improved by Zhan et al. (2020) with online clustering. However, our method is conceptually different from DeepCluster. In DeepCluster, the cluster assignments are considered as pseudo-labels and a classification objective is optimized, which results in two weaknesses: (1) the high-dimensional features from the penultimate layer of a ConvNet are not optimal for clustering and need to be PCA-reduced; (2) an additional linear classification layer is frequently re-initialized which interferes with representation learning. In our method, representation learning happens directly in a low-dimensional embedding space, by optimizing a contrastive loss on the prototypes (cluster centroids). Concurrent to our work, SwAV (Caron et al., 2020) also brings together a clustering objective with contrastive learning. ",
+        "bbox": [
+            173,
+            287,
+            826,
+            482
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised pretext tasks. Another line of self-supervised learning methods focus on training DNNs to solve pretext tasks, which usually involve hiding certain information about the input and training the network to recover those missing information. Examples include image inpainting (Pathak et al., 2016), colorization (Zhang et al., 2016; 2017), prediction of patch orderings (Doersch et al., 2015; Noroozi & Favaro, 2016) and image transformations (Dosovitskiy et al., 2014; Gidaris et al., 2018; Caron et al., 2019; Zhang et al., 2019). Compared to heuristic pretext task designs, the proposed PCL is a more general learning framework with better theoretical justification. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROTOTYPICAL CONTRASTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            609,
+            557,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            326,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a training set $X = \\{ x _ { 1 } , x _ { 2 } , . . . , x _ { n } \\}$ of $n$ images, unsupervised visual representation learning aims to learn an embedding function $f _ { \\theta }$ (realized via a DNN) that maps $X$ to $V = \\{ v _ { 1 } , v _ { 2 } , . . . , v _ { n } \\}$ with $v _ { i } = f _ { \\theta } ( x _ { i } )$ , such that $v _ { i }$ best describes $x _ { i }$ . Instance-wise contrastive learning achieves this objective by optimizing a contrastive loss function, such as InfoNCE (Oord et al., 2018; He et al., 2020), defined as: ",
+        "bbox": [
+            174,
+            670,
+            825,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2dd4c1e6d69f324736ddc81d9b6455df0df1e0078ca5f84d5b8d83e7305d0a50.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { I n f o N C E } } = \\sum _ { i = 1 } ^ { n } - \\log \\frac { \\exp ( v _ { i } \\cdot v _ { i } ^ { \\prime } / \\tau ) } { \\sum _ { j = 0 } ^ { r } \\exp ( v _ { i } \\cdot v _ { j } ^ { \\prime } / \\tau ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            742,
+            647,
+            784
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $v _ { i }$ and $\\boldsymbol { v } _ { i } ^ { \\prime }$ are positive embeddings for instance $i$ , and $\\boldsymbol { v } _ { j } ^ { \\prime }$ includes one positive embedding and $r$ negative embeddings for other instances, and $\\tau$ is a temperature hyper-parameter. In MoCo (He et al., 2020), these embeddings are obtained by feeding $x _ { i }$ to a momentum encoder parametrized by $\\theta ^ { \\prime }$ , $, v _ { i } ^ { \\prime } = f _ { \\theta ^ { \\prime } } ( x _ { i } )$ , where $\\theta ^ { \\prime }$ is a moving average of $\\theta$ . ",
+        "bbox": [
+            173,
+            790,
+            825,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In prototypical contrastive learning, we use prototypes $c$ instead of $v ^ { \\prime }$ , and replace the fixed temperature $\\tau$ with a per-prototype concentration estimation $\\phi$ . An overview of our training framework is shown in Figure 2, where clustering and representation learning are performed iteratively at each epoch. Next, we will delineate the theoretical framework of PCL based on EM. A pseudo-code of our algorithm is given in appendix B. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f1ab2fc7ccccdda98417ee196e1fadceac522f5ec844708adc2491697a3ab43.jpg",
+        "image_caption": [
+            "Figure 2: Training framework of Prototypical Contrastive Learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            104,
+            761,
+            237
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PCL AS EXPECTATION-MAXIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            490,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our objective is to find the network parameters $\\theta$ that maximizes the log-likelihood function of the observed $n$ samples: ",
+        "bbox": [
+            179,
+            314,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d41c6adf37c434068d9670785ee936e351532035ca20d9659fafb9e3356b16f.jpg",
+        "text": "$$\n\\theta ^ { * } = \\arg \\operatorname* { m a x } _ { \\theta } \\sum _ { i = 1 } ^ { n } \\log p ( x _ { i } ; \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            335,
+            599,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We assume that the observed data $\\{ x _ { i } \\} _ { i = 1 } ^ { n }$ are related to latent variable $C = \\{ c _ { i } \\} _ { i = 1 } ^ { k }$ which denotes the prototypes of the data. In this way, we can re-write the log-likelihood function as: ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ea378dc783c73d3325fc6e376a13cb4549341bc2d5dc9df2331e451ac661bca.jpg",
+        "text": "$$\n\\theta ^ { * } = \\arg \\operatorname* { m a x } _ { \\theta } \\sum _ { i = 1 } ^ { n } \\log p ( x _ { i } ; \\theta ) = \\arg \\operatorname* { m a x } _ { \\theta } \\sum _ { i = 1 } ^ { n } \\log \\sum _ { c _ { i } \\in C } p ( x _ { i } , c _ { i } ; \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            410,
+            717,
+            454
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is hard to optimize this function directly, so we use a surrogate function to lower-bound it: ",
+        "bbox": [
+            176,
+            460,
+            776,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8324f674d2cfaefa53fea3512bdc6b402ba0f26dfc524e44fc28cdcb037a1bc.jpg",
+        "text": "$$\n\\sum _ { i = 1 } ^ { n } \\log \\sum _ { { c _ { i } } \\in C } p ( x _ { i } , c _ { i } ; \\theta ) = \\sum _ { i = 1 } ^ { n } \\log \\sum _ { { c _ { i } } \\in C } Q ( c _ { i } ) \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { Q ( c _ { i } ) } \\geq \\sum _ { i = 1 } ^ { n } \\sum _ { { c _ { i } } \\in C } Q ( c _ { i } ) \\log \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { Q ( c _ { i } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            476,
+            789,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Q ( c _ { i } )$ denotes some distribution over $c$ ’s $\\begin{array} { r } { ( \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) = 1 ) } \\end{array}$ , and the last step of derivation uses Jensen’s inequality. To make the inequality hold with equality, we require $\\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { Q ( c _ { i } ) }$ to be a constant. Therefore, we have: ",
+        "bbox": [
+            173,
+            525,
+            826,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/856135205fa941127c79143fabb7cec89e1da9fe8caa17a0190c152bee650978.jpg",
+        "text": "$$\nQ ( c _ { i } ) = \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { \\sum _ { c _ { i } \\in C } p ( x _ { i } , c _ { i } ; \\theta ) } = \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { p ( x _ { i } ; \\theta ) } = p ( c _ { i } ; x _ { i } , \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            575,
+            687,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By ignoring the constant $- \\textstyle \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) \\log Q ( c _ { i } )$ in eqn.(4), we should maximize: ",
+        "bbox": [
+            171,
+            618,
+            766,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8491a0251ddb98d3e9aa1c315e0ad47e40d8cd2fc58fd09ef75fb2d04aae6664.jpg",
+        "text": "$$\n\\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) \\log p ( x _ { i } , c _ { i } ; \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            642,
+            599,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { E }$ -step. In this step, we aim to estimate $p ( c _ { i } ; x _ { i } , \\theta )$ . To this end, we perform $k$ -means on the features $v _ { i } ^ { \\prime } = \\bar { f } _ { \\theta ^ { \\prime } } ( x _ { i } )$ given by the momentum encoder to obtain $k$ clusters. We define prototype $c _ { i }$ as the centroid for the $i$ -th cluster. Then, we compute $p ( c _ { i } ; x _ { i } , \\theta ) = \\mathbb { 1 } ( x _ { i } \\in c _ { i } )$ , where $\\mathbb { 1 } ( x _ { i } \\in c _ { i } ) = 1$ if $x _ { i }$ belongs to the cluster represented by $c _ { i }$ ; otherwise $\\mathbb { 1 } ( x _ { i } \\in c _ { i } ) = 0$ . Similar to MoCo, we found features from the momentum encoder yield more consistent clusters. ",
+        "bbox": [
+            173,
+            691,
+            826,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "M-step. Based on the E-step, we are ready to maximize the lower-bound in eqn.(6). ",
+        "bbox": [
+            173,
+            768,
+            722,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca62357a6a00db923909fe56b916644c8606f016450fdbf2c2e1cf8da0b69032.jpg",
+        "text": "$$\n\\begin{array} { r } { \\displaystyle \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) \\log p ( x _ { i } , c _ { i } ; \\theta ) = \\displaystyle \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } p ( c _ { i } ; x _ { i } , \\theta ) \\log p ( x _ { i } , c _ { i } ; \\theta ) } \\\\ { = \\displaystyle \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } \\mathbb { 1 } ( x _ { i } \\in c _ { i } ) \\log p ( x _ { i } , c _ { i } ; \\theta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            790,
+            723,
+            878
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Under the assumption of a uniform prior over cluster centroids, we have: ",
+        "bbox": [
+            174,
+            882,
+            650,
+            897
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46c528161360177b1d1c78280c11c5a0924e44e3c4555f4c637b193ab6691b69.jpg",
+        "text": "$$\np ( x _ { i } , c _ { i } ; \\theta ) = p ( x _ { i } ; c _ { i } , \\theta ) p ( c _ { i } ; \\theta ) = \\frac { 1 } { k } \\cdot p ( x _ { i } ; c _ { i } , \\theta ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            898,
+            666,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we set the prior probability $p ( c _ { i } ; \\theta )$ for each $c _ { i }$ as $1 / k$ since we are not provided any samples. We assume that the distribution around each prototype is an isotropic Gaussian, which leads to: ",
+        "bbox": [
+            173,
+            102,
+            826,
+            140
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9c39fc5b146b89001f51706f4796452e7f3ab4ffef311e9f963ea69a3d2289b5.jpg",
+        "text": "$$\np ( x _ { i } ; c _ { i } , \\theta ) = \\exp { \\left( \\frac { - ( v _ { i } - c _ { s } ) ^ { 2 } } { 2 \\sigma _ { s } ^ { 2 } } \\right) } \\bigg / \\sum _ { j = 1 } ^ { k } \\exp { \\left( \\frac { - ( v _ { i } - c _ { j } ) ^ { 2 } } { 2 \\sigma _ { j } ^ { 2 } } \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            146,
+            704,
+            190
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $v _ { i } = f _ { \\theta } ( x _ { i } )$ and $x _ { i } \\in c _ { s }$ . If we apply $\\ell _ { 2 }$ -normalization to both $v$ and $c$ , then $( v - c ) ^ { 2 } = 2 - 2 v \\cdot c .$ . Combining this with eqn.(3, 4, 6, 7, 8, 9), we can write maximum log-likelihood estimation as ",
+        "bbox": [
+            173,
+            198,
+            831,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80523ddf51b56dbb708f3864ab1368e98faab591dad6ae482adc9a2f6fddd6dc.jpg",
+        "text": "$$\n\\theta ^ { * } = \\underset { \\theta } { \\arg \\operatorname* { m i n } } \\sum _ { i = 1 } ^ { n } - \\log \\frac { \\exp ( v _ { i } \\cdot c _ { s } / \\phi _ { s } ) } { \\sum _ { j = 1 } ^ { k } \\exp ( v _ { i } \\cdot c _ { j } / \\phi _ { j } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            233,
+            655,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi \\propto \\sigma ^ { 2 }$ denotes the concentration level of the feature distribution around a prototype and will be introduced later. Note that eqn.(10) has a similar form as the InfoNCE loss in eqn.(1). Therefore, InfoNCE can be interpreted as a special case of the maximum log-likelihood estimation, where the prototype for a feature $v _ { i }$ is the augmented feature $\\boldsymbol { v } _ { i } ^ { \\prime }$ from the same instance (i.e. $c = v ^ { \\prime }$ ), and the concentration of the feature distribution around each instance is fixed (i.e. $\\phi = \\tau$ ). ",
+        "bbox": [
+            173,
+            281,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, we take the same approach as NCE and sample $r$ negative prototypes to calculate the normalization term. We also cluster the samples $M$ times with different number of clusters $K = \\{ k _ { m } \\} _ { m = 1 } ^ { M }$ , which enjoys a more robust probability estimation of prototypes that encodestructure. Furthermore, we add the InfoNCE loss to retain the property of local smoothness and help bootstrap clustering. Our overall objective, namely ProtoNCE, is defined as ",
+        "bbox": [
+            174,
+            358,
+            823,
+            430
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/76fe824335ceeb4fba6226aa93d91d74498ac823aae540b75ba5782820e1d470.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { P r o t o N C E } } = \\sum _ { i = 1 } ^ { n } - \\left( \\log \\frac { \\exp ( v _ { i } \\cdot v _ { i } ^ { \\prime } / \\tau ) } { \\sum _ { j = 0 } ^ { r } \\exp ( v _ { i } \\cdot v _ { j } ^ { \\prime } / \\tau ) } + \\frac { 1 } { M } \\sum _ { m = 1 } ^ { M } \\log \\frac { \\exp ( v _ { i } \\cdot c _ { s } ^ { m } / \\phi _ { s } ^ { m } ) } { \\sum _ { j = 0 } ^ { r } \\exp ( v _ { i } \\cdot c _ { j } ^ { m } / \\phi _ { j } ^ { m } ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            435,
+            781,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 CONCENTRATION ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            428,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The distribution of embeddings around each prototype has different level of concentration. We use $\\phi$ to denote the concentration estimation, where a smaller $\\phi$ indicates larger concentration. Here we calculate $\\phi$ using the momentum features $\\{ v _ { z } ^ { \\prime } \\} _ { z = 1 } ^ { Z }$ that are within the same cluster as a prototype $c$ The desired $\\phi$ should be small (high concentration) if (1) the average distance between $v _ { z } ^ { \\prime }$ and $c$ is small, and (2) the cluster contains more feature points (i.e. $Z$ is large). Therefore, we define $\\phi$ as: ",
+        "bbox": [
+            173,
+            518,
+            826,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af4e33a7d662f0cb8c0564960b55c51492bf96353346d908aeb01507da438bde.jpg",
+        "text": "$$\n\\phi = \\frac { \\sum _ { z = 1 } ^ { Z } \\| v _ { z } ^ { \\prime } - c \\| _ { 2 } } { Z \\log ( Z + \\alpha ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            594,
+            573,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is a smooth parameter to ensure that small clusters do not have an overly-large $\\phi$ . We normalize $\\phi$ for each set of prototypes $C ^ { m }$ such that they have a mean of $\\tau$ . ",
+        "bbox": [
+            174,
+            638,
+            825,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the ProtoNCE loss (eqn.(11)), $\\phi _ { s } ^ { m }$ acts as a scaling factor on the similarity between an embedding $v _ { i }$ and its prototype $c _ { s } ^ { m }$ . With the proposed $\\phi$ , the similarity in a loose cluster (larger $\\phi$ ) are down-scaled, pulling embeddings closer to the prototype. On the contrary, embeddings in a tight cluster (smaller $\\phi$ ) have an up-scaled similarity, thus less encouraged to approach the prototype. Therefore, learning with ProtoNCE yields more balanced clusters with similar concentration, as shown in Figure 3(a). It prevents a trivial solution where most embeddings collapse to a single cluster, a problem that could only be heuristically addressed by data-resampling in DeepCluster (Caron et al., 2018). ",
+        "bbox": [
+            173,
+            672,
+            825,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 MUTUAL INFORMATION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            452,
+            794
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It has been shown that minimizing InfoNCE is maximizing a lower bound on the mutual information (MI) between representations $V$ and $V ^ { \\prime }$ (Oord et al., 2018). Similarly, minimizing the proposed ProtoNCE can be considered as simultaneously maximizing the mutual information between $V$ and all the prototypes $\\{ V ^ { \\prime } , C ^ { 1 } , . . . , C ^ { M } \\}$ . This leads to better representation learning, for two reasons. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First, the encoder would learn the shared information among prototypes, and ignore the individual noise that exists in each prototype. The shared information is more likely to capture higher-level semantic knowledge. Second, we show that compared to instance features, prototypes have a larger mutual information with the class labels. We estimate the mutual information between the instance features (or their assigned prototypes) and the ground-truth class labels for all images in ImageNet (Deng et al., 2009) training set, following the method in (Ross, 2014). We compare the obtained MI of our method (ProtoNCE) and that of MoCo (InfoNCE). As shown in Figure 3(b), compared to instance features, the prototypes have a larger MI with the class labels due to the effect of clustering. Furthermore, compared to InfoNCE, training on ProtoNCE can increase the MI of prototypes as training proceeds, indicating that better representations are learned to form more semantically-meaningful clusters. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e44aaf5d7dd1acb2ac523a000209506c1f567d1121bdcb1883a0700f0057f543.jpg",
+        "image_caption": [
+            "Figure 3: (a) Histogram of cluster size for PCL ( $\\#$ clusters $k { = } 5 0 0 0 0 )$ ) with fixed or estimated concentration. Using a different $\\phi$ for each prototype yields more balanced clusters with similar sizes, which leads to better representation learning. (b) Mutual info between instance features (or their assigned prototypes) and class labels of all images in ImageNet. Compared to InfoNCE, our ProtoNCE learns better prototypes with more semantics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            102,
+            813,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            353,
+            825,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 PROTOTYPES AS LINEAR CLASSIFIER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            467,
+            479
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another interpretation of PCL can provide more insights into the nature of the learned prototypes. The optimization in eqn.(10) is similar to optimizing the cluster-assignment probability $p ( s ; x _ { i } , \\theta )$ using the cross-entropy loss, where the prototypes $c$ represent weights for a linear classifier. With $k$ -means clustering, the linear classifier has a fixed set of weights as the mean vectors for the representations in each cluster, $\\begin{array} { r } { c = { \\frac { 1 } { Z } } \\sum _ { z = 1 } ^ { Z } v _ { z } ^ { \\prime } } \\end{array}$ . A similar idea has been used for few-shot learning (Snell et al., 2017), where a non-parametric prototypical classifier performs better than a parametric linear classifier. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            574
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            592,
+            326,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate PCL on transfer learning tasks, based on the principle that good representations should transfer with limited supervision and fine-tuning. We follow the settings in MoCo, therefore direct comparisons with MoCo could demonstrate the improvement from the prototypical contrastive loss. ",
+        "bbox": [
+            174,
+            625,
+            826,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            403,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To enable a fair comparison, we follow the same setting as MoCo. We perform training on the ImageNet-1M dataset. A ResNet-50 (He et al., 2016) is adopted as the encoder, whose last fullyconnected layer outputs a 128-D and L2-normalized feature. We follow previous works (He et al., 2020; Wu et al., 2018) and perform data augmentation with random crop, random color jittering, random horizontal flip, and random grayscale conversion. We use SGD as our optimizer, with a weight decay of 0.0001, a momentum of 0.9, and a batch size of 256. We train for 200 epochs, where we warm-up the network in the first 20 epochs by only using the InfoNCE loss. The initial learning rate is 0.03, and is multiplied by 0.1 at 120 and 160 epochs. In terms of the hyper-parameters, we set $\\tau = 0 . 1$ , $\\alpha = 1 0$ , $r = 1 6 0 0 0$ , and number of clusters $K = \\{ 2 5 0 0 0 , 5 0 0 0 { \\bar { 0 } } , 1 0 { \\bar { 0 } } 0 0 0 \\}$ . We also experiment with PCL v2 using improvements introduced by Chen et al. (2020a;b), which includes a MLP projection layer, stronger data augmentation with additional Gaussian blur, and temperature $\\tau = 0 . 2$ . We adopt faiss (Johnson et al., 2017) for efficient $k$ -means clustering. The clustering is performed per-epoch on center-cropped images. We find over-clustering to be beneficial. Recent advances in self-supervised learning have been propelled by huge compute which is inaccessible to many researchers. We instead target a more commonly accessible training resource for PCL with 4 NVIDIA-V100 GPUs and approximately 5 days of training. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ca9cb431426433fadea98b2089bd92770e7571a005dc10b7db72ef0283888af2.jpg",
+        "table_caption": [
+            "Table 1: Low-shot image classification on both VOC07 and Places205 datasets using linear SVMs trained on fixed representations. All methods were pretrained on ImageNet-1M dataset for 200 epochs (except for Jigsaw trained on ImageNet-14M). We vary the number of labeled examples $k$ and report the mAP (for VOC) and accuracy (for Places) across 5 runs. We use the released pretrained model for MoCo, and re-implement SimCLR. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">architecture</td><td colspan=\"5\">vOC07</td><td colspan=\"5\">Places205</td></tr><tr><td>k=1</td><td>k=2</td><td>k=4</td><td>k=8</td><td>k=16</td><td>k=1</td><td>k=2</td><td>k=4</td><td>k=8</td><td>k=16</td></tr><tr><td>Random Supervised</td><td>ResNet-50</td><td>8.0 54.3</td><td>8.2 67.8</td><td>8.2 73.9</td><td>8.2 79.6</td><td>8.5 82.3</td><td>0.7 14.9</td><td>0.7 21.0</td><td>0.7 26.9</td><td>0.7 32.1</td><td>0.7 36.0</td></tr><tr><td>Jigsaw MoCo PCL (ours)</td><td>ResNet-50</td><td>26.5 31.4 46.9</td><td>31.1 42.0 56.4</td><td>40.0 49.5 62.8</td><td>46.7 60.0 70.2</td><td>51.8 65.9 74.3</td><td>4.6 8.8 11.3</td><td>6.4 13.2 15.7</td><td>9.4 18.2 19.5</td><td>12.9 23.2 24.1</td><td>17.4 28.0 28.4</td></tr><tr><td>SimCLR MoCo v2 PCL v2 (ours)</td><td>ResNet-50-MLP</td><td>32.7 46.3 47.9 59.6</td><td>43.1 58.3</td><td>52.5 64.9</td><td>61.0 72.5</td><td>67.1 76.1</td><td>9.4 10.9</td><td>14.2 16.3</td><td>19.3 20.8</td><td>23.7 26.0</td><td>28.3 30.1 32.3</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            821,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 IMAGE CLASSIFICATION WITH LIMITED TRAINING DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            339,
+            599,
+            353
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Low-shot classification. We evaluate the learned representation on image classification tasks with few training samples per-category. We follow the setup in Goyal et al. (2019) and train linear SVMs using fixed representations on two datasets: Places205 (Zhou et al., 2014) for scene recognition and PASCAL VOC2007 (Everingham et al., 2010) for object classification. We vary the number $k$ of samples per-class and report the average result across 5 independent runs (standard deviation is reported in appendix C). Table 1 shows the results, in which our method substantially outperforms both MoCo and SimCLR. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            465
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised image classification. We perform semi-supervised learning experiments to evaluate whether the learned representation can provide a good basis for fine-tuning. Following the setup from Wu et al. (2018); Misra & van der Maaten (2020), we randomly select a subset $1 \\%$ or $10 \\%$ ) of ImageNet training data (with labels), and fine-tune the self-supervised trained model on these subsets. Table 2 reports the top-5 accuracy on ImageNet validation set. Our method sets a new state-of-the-art under 200 training epochs, outperforming both self-supervised learning methods and semi-supervised learning methods. The standard deviation across 5 runs is low $< 0 . 6$ for $1 \\%$ labels). ",
+        "bbox": [
+            173,
+            472,
+            826,
+            570
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/60e1ce1cf464d231121b8e1bd60407a047df61505bc94c6667ed08630e5d7106.jpg",
+        "table_caption": [
+            "Table 2: Semi-supervised learning on ImageNet. We report top-5 accuracy on the ImageNet validation set of self-supervised models that are finetuned on $1 \\%$ or $10 \\%$ of labeled data. ‡: SimCLR, BYOL, and SwAV use a large batch size of 4096. ‡: SwAV uses multi-crop augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>architecture</td><td>#pretrain epochs</td><td>Top-5 Accuracy 1%</td><td>10%</td></tr><tr><td>Random (Wu et al., 2018)</td><td>ResNet-50</td><td></td><td>22.0</td><td>59.0</td></tr><tr><td>Supervised baseline (Zhai et al., 2019)</td><td>ResNet-50</td><td></td><td>48.4</td><td>80.4</td></tr><tr><td>Semi-supervised learningmethods:</td><td></td><td></td><td></td><td></td></tr><tr><td>Pseudolabels (Zhai etal.,2019)</td><td>ResNet-50v2</td><td></td><td>51.6</td><td>82.4</td></tr><tr><td>VAT + Entropy Min. (Miyato et al., 2019)</td><td>ResNet-50v2</td><td></td><td>47.0</td><td>83.4</td></tr><tr><td>S4L Rotation (Zhai et al.,2019)</td><td>ResNet-50v2</td><td></td><td>53.4</td><td>83.8</td></tr><tr><td>Self-supervised learningmethods:</td><td></td><td></td><td></td><td></td></tr><tr><td>Instance Discrimination (Wu et al.,2018)</td><td>ResNet-50</td><td>200</td><td>39.2</td><td>77.4</td></tr><tr><td>Jigsaw (Noroozi &amp; Favaro,2016)</td><td>ResNet-50</td><td>90</td><td>45.3</td><td>79.3</td></tr><tr><td>SimCLR (Chen et al.,2020a)</td><td>ResNet-50-MLP</td><td>200</td><td>56.5</td><td>82.7</td></tr><tr><td>MoCo (He et al.,2020)</td><td>ResNet-50</td><td>200</td><td>56.9</td><td>83.0</td></tr><tr><td>MoCo v2 (Chen et al., 2020b)</td><td>ResNet-50-MLP</td><td>200</td><td>66.3</td><td>84.4</td></tr><tr><td>PCL v2 (ours)</td><td>ResNet-50-MLP</td><td>200</td><td>73.9</td><td>85.0</td></tr><tr><td>PCL (ours)</td><td>ResNet-50</td><td>200</td><td>75.3</td><td>85.6</td></tr><tr><td>PIRL (Misra &amp; van der Maaten, 2020)</td><td>ResNet-50</td><td>800</td><td>57.2</td><td>83.8</td></tr><tr><td>SimCLR Chen et al. (2020a)</td><td>ResNet-50-MLP</td><td>1000</td><td>75.5†</td><td>87.8†</td></tr><tr><td>BYOL (Grill et al., 2020)</td><td>ResNet-50-MLPbig</td><td>1000</td><td>78.4t</td><td>89.0†</td></tr><tr><td>SwAV (Caron et al., 2020)</td><td>ResNet-50-MLP</td><td>800</td><td>78.5</td><td>89.9t</td></tr></table>",
+        "bbox": [
+            207,
+            589,
+            787,
+            864
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 IMAGE CLASSIFICATION BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            482,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Linear classifiers. Next, we train linear classifiers on fixed image representations using the entire labeled training data. We evaluate the performance of such linear classifiers on three datasets: ImageNet, VOC07, and Places205. Table 3 reports the results. PCL outperforms MoCo under direct comparison, which demonstrate the advantage of the proposed prototypical contrastive loss. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            184
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e4ad8c5f3f3b112193948590e2ae2451923f89b7bc417492a14b6d345ae74f2.jpg",
+        "table_caption": [
+            "Table 3: Image classification with linear models. We report top-1 accuracy. Numbers with ∗ are from released pretrained model; all other numbers are adopted from corresponding papers. †: LocalAgg uses 10-crop evaluation. ADMIM uses FastAutoAugment (Lim et al., 2019) that is supervised by ImageNet labels. SwAV uses multi-crop augmentation. SimCLR, BYOL, and SwAV use a large batch size of 4096. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>architecture (#params)</td><td>#pretrain epochs</td><td>ImageNet</td><td>Dataset VOC07</td><td>Places205</td></tr><tr><td>Jigsaw (Noroozi &amp; Favaro,2016) Rotation (Gidaris et al.,2018) DeepCluster (Caron et al., 2018) BigBiGAN (Donahue &amp; Simonyan, 2019) InstDisc (Wu et al., 2018) MoCo (He et al., 2020)</td><td>R50 (24M) R50 (24M) VGG(15M) R50 (24M) R50 (24M) R50 (24M)</td><td>90 1 100 200</td><td>45.7 48.9 48.4 56.6 54.0</td><td>64.5 63.9 71.9 1 一</td><td>41.2 41.4 37.9 1 45.5</td></tr><tr><td>SimCLR(Chen et al.,2020a) MoCo v2(Chen et al.,2020b) PCL v2 (ours)</td><td>R50 (24M) R50-MLP (28M) R50-MLP (28M) R50-MLP (28M)</td><td>200 200 200 200</td><td>61.5 61.9 67.5 67.6</td><td>82.3 一 84.0* 85.4</td><td>49.2 50.1* 50.3</td></tr><tr><td>SelfLabel (Asano et al.,2020) CPC (Oord et al., 2018)</td><td>R50 (24M) R50 (24M)</td><td>200 400</td><td>60.2† 61.5</td><td>1 1</td><td>50.1†</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>R50 (24M)</td><td>800</td><td></td><td></td><td>49.8</td></tr><tr><td></td><td></td><td>280</td><td>64.0</td><td></td><td></td></tr><tr><td></td><td>R101 (28M)</td><td></td><td>48.7</td><td>1</td><td>1</td></tr><tr><td>CMC (Tian et al.,2019)</td><td>R50L+ab (47M)</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>1</td><td>一</td></tr><tr><td>PIRL (Misra &amp; van der Maaten,2020)</td><td></td><td></td><td>63.6</td><td>81.1</td><td></td></tr><tr><td>AMDIM (Bachman et al.,2019)</td><td>Custom (626M)</td><td>150</td><td>68.1†</td><td>一</td><td>55.0+</td></tr><tr><td>SimCLR (Chen et al.,2020a)</td><td>R50-MLP (28M)</td><td>1000</td><td>69.3†</td><td>80.5†</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1</td></tr><tr><td>BYOL (Grill et al., 2020)</td><td>R50-MLPbig(35M)</td><td>1000</td><td>74.3†</td><td>-</td><td></td></tr><tr><td>SwAV (Caron et al.,2020)</td><td>R50-MLP (28M)</td><td>800</td><td>75.3t</td><td>88.9t</td><td>56.7+</td></tr></table>",
+        "bbox": [
+            171,
+            190,
+            823,
+            470
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "KNN classifiers. We perform $\\mathbf { k }$ -nearest neighbor (kNN) classification on ImageNet. For a query image with feature $v$ , we take its top $k$ nearest neighbors from the momentum features, and perform weighted-combination of their labels where the weights are calculated by $\\exp ( v \\cdot v _ { i } ^ { \\prime } / \\tau )$ . Table 4 reports the accuracy. Our method substantially outperforms previous methods. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/9ae5ce0e3bf9fa3680738d9341f16afc9ffd22d91dbb85f97b1de39a9bd6ad76.jpg",
+        "table_caption": [
+            "Table 4: Image classification with kNN classifiers using ResNet-50 features on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Inst.Disc.(Wu et al.,2018)|MoCo (He et al.,2020)|LA (Zhuang et al.,2019)|PCL (ours)</td><td></td><td></td><td></td></tr><tr><td>Accuracy</td><td>46.5</td><td>47.1</td><td>49.4</td><td>54.5</td></tr></table>",
+        "bbox": [
+            169,
+            630,
+            821,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 CLUSTERING EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            400,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 5, we evaluate the $k$ -means clustering performance on ImageNet using representations learned by different methods. PCL leads to substantially higher adjusted mutual information (AMI) score. Details are given in appendix F. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc065f856a144a657aaf105c5177db44602c055287ed23b79ffbe8ef09b048a2.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 5: AMI score for $\\mathbf { k }$ -means clustering $k = 2 5 0 0 0 )$ on ImageNet representation. "
+        ],
+        "table_body": "<table><tr><td></td><td>Method|DeepCluster (Caron et al., 2018)|MoCo (He et al.,2020)|PCL (ours)</td><td></td><td></td></tr><tr><td>AMI</td><td>0.281</td><td>0.285</td><td>0.410</td></tr></table>",
+        "bbox": [
+            241,
+            782,
+            751,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            861,
+            354,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We assess the representation on object detection. Following Goyal et al. (2019), we train a Faster R-CNN (Ren et al., 2015) on VOC07 or $\\mathrm { v o c } 0 7 { + } 1 2$ , and evaluate on the test set of VOC07. We keep the pretrained backbone frozen to better evaluate the learned representation, and use the same schedule for all methods. Table 6 reports the average mAP across three runs. Our method substantially closes the gap between self-supervised methods and supervised training. In appendix D, we show the results for fine-tuning the pretrained model for object detection and instance segmentation on COCO (Lin et al., 2014), where PCL outperforms both MoCo and supervised training. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1dbd4dfbdc7608f131bc9f56180a2536212ff888741d06b0d0d2ec7baed4cd44.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 6: Object detection for frozen conv body on VOC using Faster R-CNN. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Pretrain Dataset|Architecture</td><td rowspan=1 colspan=1>Pretrain Dataset|Architecture</td><td rowspan=1 colspan=2>Training dataVOC07 VOC07+12</td></tr><tr><td rowspan=1 colspan=1>Supervised</td><td rowspan=1 colspan=1>ImageNet-1M</td><td rowspan=1 colspan=1>Resnet-50-FPN</td><td rowspan=1 colspan=1>72.8</td><td rowspan=1 colspan=1>79.3</td></tr><tr><td rowspan=1 colspan=1>MoCo (He et al.,2020)PCL (ours)</td><td rowspan=1 colspan=1>ImageNet-1MImageNet-1M</td><td rowspan=1 colspan=1>Resnet-50-FPNResnet-50-FPN</td><td rowspan=1 colspan=1>66.471.7</td><td rowspan=1 colspan=1>73.578.5</td></tr></table>",
+        "bbox": [
+            232,
+            175,
+            763,
+            256
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 VISUALIZATION OF LEARNED REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            301,
+            602,
+            316
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we visualize the unsupervised learned representation of ImageNet training images using t-SNE (Maaten & Hinton, 2008). Compared to the representation learned by MoCo, the representation learned by the proposed PCL forms more separated clusters, which also suggests representation of lower entropy. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/79db6061c20db4241e80f5466ea60ca4ddbd74e67a6138faa58313f4f6748406.jpg",
+        "image_caption": [
+            "Figure 4: T-SNE visualization of the unsupervised learned representation for ImageNet training images from the first 40 classes. Left: MoCo; Right: PCL (ours). Colors represent classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            411,
+            818,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            811,
+            318,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper proposes Prototypical Contrastive Learning, a generic unsupervised representation learning framework that finds network parameters to maximize the log-likelihood of the observed data. We introduce prototypes as latent variables, and perform iterative clustering and representation learning in an EM-based framework. PCL learns an embedding space which encodes the semantic structure of data, by training on the proposed ProtoNCE loss. Our extensive experiments on multiple benchmarks demonstrate the advantage of PCL for unsupervised representation learning. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuki Markus Asano, Christian Rupprecht, and Andrea Vedaldi. Self-labelling via simultaneous clustering and representation learning. In ICLR, 2020. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philip Bachman, R. Devon Hjelm, and William Buchwalter. Learning representations by maximizing mutual information across views. arXiv preprint arXiv:1906.00910, 2019. ",
+        "bbox": [
+            171,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathilde Caron, Piotr Bojanowski, Armand Joulin, and Matthijs Douze. Deep clustering for unsupervised learning of visual features. In ECCV, pp. 139–156, 2018. ",
+        "bbox": [
+            171,
+            203,
+            823,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathilde Caron, Piotr Bojanowski, Julien Mairal, and Armand Joulin. Unsupervised pre-training of image features on non-curated data. In ICCV, pp. 2959–2968, 2019. ",
+        "bbox": [
+            169,
+            242,
+            825,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mathilde Caron, Ishan Misra, Julien Mairal, Priya Goyal, Piotr Bojanowski, and Armand Joulin. Unsupervised learning of visual features by contrasting cluster assignments. In NeurIPS, 2020. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jianlong Chang, Lingfeng Wang, Gaofeng Meng, Shiming Xiang, and Chunhong Pan. Deep adaptive image clustering. In ICCV, pp. 5880–5888, 2017. ",
+        "bbox": [
+            171,
+            320,
+            821,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, Zheng Zhang, Dazhi Cheng, Chenchen Zhu, Tianheng Cheng, Qijie Zhao, Buyu Li, Xin Lu, Rui Zhu, Yue Wu, Jifeng Dai, Jingdong Wang, Jianping Shi, Wanli Ouyang, Chen Change Loy, and Dahua Lin. MMDetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019. ",
+        "bbox": [
+            173,
+            358,
+            826,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In ICML, 2020a. ",
+        "bbox": [
+            169,
+            439,
+            823,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinlei Chen, Haoqi Fan, Ross Girshick, and Kaiming He. Improved baselines with momentum contrastive learning. arXiv preprint arXiv:2003.04297, 2020b. ",
+        "bbox": [
+            171,
+            478,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Fei-Fei Li. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255, 2009. ",
+        "bbox": [
+            169,
+            517,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Carl Doersch, Abhinav Gupta, and Alexei A. Efros. Unsupervised visual representation learning by context prediction. In ICCV, pp. 1422–1430, 2015. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue and Karen Simonyan. Large scale adversarial representation learning. In NeurIPS, pp. 10541–10551, 2019. ",
+        "bbox": [
+            173,
+            594,
+            823,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Jost Tobias Springenberg, Martin A. Riedmiller, and Thomas Brox. Discriminative unsupervised feature learning with convolutional neural networks. In NIPS, pp. 766–774, 2014. ",
+        "bbox": [
+            174,
+            633,
+            826,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Everingham, Luc Van Gool, Christopher K. I. Williams, John M. Winn, and Andrew Zisserman. The pascal visual object classes (VOC) challenge. International Journal of Computer Vision, 88 (2):303–338, 2010. ",
+        "bbox": [
+            173,
+            686,
+            826,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rong-En Fan, Kai-Wei Chang, Cho-Jui Hsieh, Xiang-Rui Wang, and Chih-Jen Lin. LIBLINEAR: A library for large linear classification. JMLR, 9:1871–1874, 2008. ",
+        "bbox": [
+            171,
+            739,
+            825,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wouter Van Gansbeke, Simon Vandenhende, Stamatios Georgoulis, Marc Proesmans, and Luc Van Gool. SCAN: learning to classify images without labels. In ECCV, pp. 268–285, 2020. ",
+        "bbox": [
+            171,
+            779,
+            823,
+            808
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Spyros Gidaris, Praveer Singh, and Nikos Komodakis. Unsupervised representation learning by predicting image rotations. In ICLR, 2018. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ross Girshick, Ilija Radosavovic, Georgia Gkioxari, Piotr Dollár, and Kaiming He. Detectron. https://github.com/facebookresearch/detectron, 2018. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Dhruv Mahajan, Abhinav Gupta, and Ishan Misra. Scaling and benchmarking selfsupervised visual representation learning. In ICCV, pp. 6391–6400, 2019. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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, Bilal Piot, Koray Kavukcuoglu, Rémi Munos, and Michal Valko. Bootstrap your own latent: A new approach to self-supervised learning. In NeurIPS, 2020. ",
+        "bbox": [
+            174,
+            103,
+            826,
+            160
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Gutmann and Aapo Hyvärinen. Noise-contrastive estimation: A new estimation principle for unnormalized statistical models. In AISTATS, pp. 297–304, 2010. ",
+        "bbox": [
+            174,
+            169,
+            821,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            176,
+            207,
+            821,
+            236
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. In ICCV, pp. 2980–2988, 2017. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, 2020. ",
+        "bbox": [
+            173,
+            284,
+            821,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            320,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xu Ji, João F Henriques, and Andrea Vedaldi. Invariant information clustering for unsupervised image classification and segmentation. In ICCV, pp. 9865–9874, 2019. ",
+        "bbox": [
+            173,
+            372,
+            823,
+            402
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeff Johnson, Matthijs Douze, and Hervé Jégou. Billion-scale similarity search with gpus. arXiv preprint arXiv:1702.08734, 2017. ",
+        "bbox": [
+            174,
+            410,
+            823,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Renjie Liao, Alexander G. Schwing, Richard S. Zemel, and Raquel Urtasun. Learning deep parsimonious representations. In NIPS, pp. 5076–5084, 2016. ",
+        "bbox": [
+            174,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sungbin Lim, Ildoo Kim, Taesup Kim, Chiheon Kim, and Sungwoong Kim. Fast autoaugment. In NeurIPS, pp. 6662–6672, 2019. ",
+        "bbox": [
+            174,
+            486,
+            823,
+            516
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge J. Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C. Lawrence Zitnick. Microsoft COCO: common objects in context. In ECCV, pp. 740–755, 2014. ",
+        "bbox": [
+            173,
+            525,
+            823,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of machine learning research, 9:2579–2605, 2008. ",
+        "bbox": [
+            169,
+            577,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ishan Misra and Laurens van der Maaten. Self-supervised learning of pretext-invariant representations. In CVPR, 2020. ",
+        "bbox": [
+            169,
+            614,
+            825,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: A regularization method for supervised and semi-supervised learning. IEEE Trans. Pattern Anal. Mach. Intell., 41(8):1979–1993, 2019. ",
+        "bbox": [
+            176,
+            652,
+            825,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xuan Vinh Nguyen, Julien Epps, and James Bailey. Information theoretic measures for clusterings comparison: Variants, properties, normalization and correction for chance. J. Mach. Learn. Res., 11:2837–2854, 2010. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            747
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, pp. 69–84, 2016. ",
+        "bbox": [
+            173,
+            757,
+            823,
+            786
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. ",
+        "bbox": [
+            173,
+            794,
+            821,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Philipp Krähenbühl, Jeff Donahue, Trevor Darrell, and Alexei A. Efros. Context encoders: Feature learning by inpainting. In CVPR, pp. 2536–2544, 2016. ",
+        "bbox": [
+            176,
+            833,
+            821,
+            863
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards real-time object detection with region proposal networks. In NIPS, pp. 91–99, 2015. ",
+        "bbox": [
+            173,
+            871,
+            821,
+            900
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brian C Ross. Mutual information between discrete and continuous data sets. PloS one, 9(2), 2014. ",
+        "bbox": [
+            171,
+            909,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikunj Saunshi, Orestis Plevrakis, Sanjeev Arora, Mikhail Khodak, and Hrishikesh Khandeparkar. A theoretical analysis of contrastive unsupervised representation learning. In ICML, pp. 5628–5637, 2019.   \nJake Snell, Kevin Swersky, and Richard S. Zemel. Prototypical networks for few-shot learning. In NIPS, pp. 4077–4087, 2017.   \nYonglong Tian, Dilip Krishnan, and Phillip Isola. Contrastive multiview coding. arXiv preprint arXiv:1906.05849, 2019.   \nMichael Tschannen, Josip Djolonga, Paul K. Rubenstein, Sylvain Gelly, and Mario Lucic. On mutual information maximization for representation learning. In ICLR, 2020.   \nZhirong Wu, Yuanjun Xiong, Stella X. Yu, and Dahua Lin. Unsupervised feature learning via non-parametric instance discrimination. In CVPR, pp. 3733–3742, 2018.   \nJunyuan Xie, Ross B. Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In ICML, pp. 478–487, 2016.   \nBo Yang, Xiao Fu, Nicholas D. Sidiropoulos, and Mingyi Hong. Towards k-means-friendly spaces: Simultaneous deep learning and clustering. In ICML, pp. 3861–3870, 2017.   \nJianwei Yang, Devi Parikh, and Dhruv Batra. Joint unsupervised learning of deep representations and image clusters. In CVPR, pp. 5147–5156, 2016.   \nMang Ye, Xu Zhang, Pong C. Yuen, and Shih-Fu Chang. Unsupervised embedding learning via invariant and spreading instance feature. In CVPR, pp. 6210–6219, 2019.   \nXiaohua Zhai, Avital Oliver, Alexander Kolesnikov, and Lucas Beyer. S4l: Self-supervised semisupervised learning. In ICCV, pp. 1476–1485, 2019.   \nXiaohang Zhan, Jiahao Xie, Ziwei Liu, Yew-Soon Ong, and Chen Change Loy. Online deep clustering for unsupervised representation learning. In CVPR, pp. 6687–6696, 2020.   \nLiheng Zhang, Guo-Jun Qi, Liqiang Wang, and Jiebo Luo. AET vs. AED: unsupervised representation learning by auto-encoding transformations rather than data. In CVPR, 2019.   \nRichard Zhang, Phillip Isola, and Alexei A. Efros. Colorful image colorization. In ECCV, pp. 649–666, 2016.   \nRichard Zhang, Phillip Isola, and Alexei Efros. Split-brain autoencoders: Unsupervised learning by cross-channel prediction. In CVPR, pp. 1058–1067, 2017.   \nBolei Zhou, Àgata Lapedriza, Jianxiong Xiao, Antonio Torralba, and Aude Oliva. Learning deep features for scene recognition using places database. In NIPS, pp. 487–495, 2014.   \nChengxu Zhuang, Alex Lin Zhai, and Daniel Yamins. Local aggregation for unsupervised learning of visual embeddings. In ICCV, pp. 6002–6012, 2019. ",
+        "bbox": [
+            171,
+            92,
+            828,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A ABLATION ON PROTONCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            526,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The proposed loss in eqn.(11) contains two terms: the instance-wise contrastive loss and the proposed prototypical contrastive loss. Here we study the effect of each term on representation learning. Table 7 reports the results for low-resource fine-tuning and linear classification on ImageNet. The prototypical term plays an important role, especially in the fine-tuning experiment. The warm-up also improves the result by bootstrapping the clustering with better representations. ",
+        "bbox": [
+            173,
+            131,
+            825,
+            202
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/fdce67821e8b791dcc1edda4e64fc3119f67348555a325e502c67bfed5d9142b.jpg",
+        "table_caption": [
+            "Table 7: Effect of instance-wise contrastive loss and prototypical contrastive loss. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td></td><td>1% fine-tuning (top-5 acc.)|linear classification (top-1 acc.)</td></tr><tr><td>instance only</td><td>56.9</td><td>60.6</td></tr><tr><td>proto only (w/o warm-up)</td><td>60.7</td><td>60.4</td></tr><tr><td>proto only (w/ warm-up)</td><td>72.3</td><td>60.9</td></tr><tr><td>instance + proto (w/o warm-up)</td><td>74.6</td><td>61.3</td></tr><tr><td>instance + proto (w/ warm-up)</td><td>75.3</td><td>61.5</td></tr></table>",
+        "bbox": [
+            178,
+            217,
+            820,
+            318
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B PSEUDO-CODE FOR PROTOTYPICAL CONTRASTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            373,
+            816,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Prototypical Contrastive Learning. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            417,
+            470,
+            431
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1 Input: encoder $f _ { \\theta }$ , training dataset $X$ , number of clusters $K = \\{ k _ { m } \\} _ { m = 1 } ^ { M }$   \n2 $\\theta ^ { \\prime } = \\theta$ // initialize momentum encoder as the encoder   \n3 while not MaxEpoch do /\\* E-step \\*/   \n4 $V ^ { \\prime } = f _ { \\theta ^ { \\prime } } ( X )$ // get momentum features for all training data   \n5 for $m = 1$ to $M$ do   \n6 $C ^ { m } = k { \\mathrm { - m e a n s } } ( V ^ { \\prime } , k _ { m } )$ // cluster $V ^ { \\prime }$ into $k _ { m }$ clusters, return prototypes   \n7 $\\phi _ { m } = \\mathrm { C o n c e n t r a t i o n } ( C ^ { m } , V ^ { \\prime } )$ // estimate the distribution concentration around each prototype with Equation 12   \n8 end /\\* M-step \\*/   \n9 for $_ x$ in Dataloader $( X )$ do // load a minibatch $x$   \n10 $v = f _ { \\theta } ( x ) , v ^ { \\prime } = \\dot { f } _ { \\theta ^ { \\prime } } ( x )$ // forward pass through encoder and momentum encoder   \n11 $\\begin{array} { r l } { \\mathcal { L } _ { \\mathrm { P r o t o N C E } } ( v , v ^ { \\prime } , \\{ C ^ { m } \\} _ { m = 1 } ^ { M } , \\{ \\phi _ { m } \\} _ { m = 1 } ^ { M } ) } & { { } } \\end{array}$ // calculate loss with Equation 11   \n12 $\\theta = \\mathrm { S G D } ( \\mathcal { L } _ { \\mathrm { P r o t o N C E } } , \\theta )$ ) // update encoder parameters   \n13 $\\theta ^ { \\prime } = 0 . 9 9 9 * \\theta ^ { \\prime } + 0 . 0 0 1 * \\theta$ // update momentum encoder   \n14 end   \n15 end ",
+        "bbox": [
+            158,
+            435,
+            810,
+            705
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX D COCO OBJECT DETECTION AND SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            707,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Following the experiment setting in (He et al., 2020), we use Mask R-CNN (He et al., 2017) with C4 backbone. We finetune all layers end-to-end on the COCO train2017 set and evaluate on val2017. The schedule is the default $2 \\times$ in (Girshick et al., 2018). PCL outperforms both MoCo (He et al., 2020) and supervised pre-training in all metrics. ",
+        "bbox": [
+            176,
+            141,
+            825,
+            198
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/356938be14859d8e136b044aad19f323b9788aa6bec2a3092378b9ef9a837620.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 9: Object detection and instance segmentation fine-tuned on COCO. We evaluate bounding-box AP $( \\mathsf { A P } ^ { \\mathsf { b b } } )$ and mask AP $( \\mathbf { A P } ^ { \\mathrm { m k } } )$ on val2017. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Apbb</td><td>AP</td><td>AP</td><td>Apmk</td><td>AP</td><td>AP</td></tr><tr><td>Supervised</td><td>40.0</td><td>59.9</td><td>43.1</td><td>34.7</td><td>56.5</td><td>36.9</td></tr><tr><td>MoCo (He et al., 2020)</td><td>40.7</td><td>60.5</td><td>44.1</td><td>35.4</td><td>57.3</td><td>37.6</td></tr><tr><td>PCL (ours)</td><td>41.0</td><td>60.8</td><td>44.2</td><td>35.6</td><td>57.4</td><td>37.8</td></tr></table>",
+        "bbox": [
+            256,
+            222,
+            740,
+            295
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX E TRAINING DETAILS FOR TRANSFER LEARNING EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            387,
+            805,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For training linear SVMs on Places and VOC, we follow the procedure in (Goyal et al., 2019) and use the LIBLINEAR (Fan et al., 2008) package. We preprocess all images by resizing to 256 pixels along the shorter side and taking a $2 2 4 \\times 2 2 4$ center crop. The linear SVMs are trained on the global average pooling features of ResNet-50. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            481
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For image classification with linear models, we use the pretrained representations from the global average pooling features (2048-D) for ImageNet and VOC, and the conv5 features (averaged pooled to ${ \\sim } 9 0 0 0 { \\cdot } \\mathrm { D }$ ) for Places. We train a linear SVM for VOC, and a logistic regression classifier (a fully-connected layer followed by softmax) for ImageNet and Places. The logistic regression classifier is trained using SGD with a momentum of 0.9. For ImageNet, we train for 100 epochs with an initial learning rate of 10 and a weight decay of 0. Similar hyper-parameters are used by (He et al., 2020). For Places, we train for 40 epochs with an initial learning rate of 0.3 and a weight decay of 0. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            585
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For semi-supervised learning, we finetune ResNet-50 with pretrained weights on a subset of ImageNet with labels. We optimize the model with SGD, using a batch size of 256, a momentum of 0.9, and a weight decay of 0.0005. We apply different learning rate to the ConvNet and the linear classifier. The learning rate for the ConvNet is 0.01, and the learning rate for the classifier is 0.1 (for $10 \\%$ labels) or 1 (for $1 \\%$ labels). We train for 20 epochs, and drop the learning rate by 0.2 at 12 and 16 epochs. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For object detection on VOC, We use the R50-FPN backbone for the Faster R-CNN detector available in the MMdetection (Chen et al., 2019) codebase. We freeze all the conv layers and also fix the BatchNorm parameters. The model is optimized with SGD, using a batch size of 8, a momentum of 0.9, and a weight decay of 0.0001. The initial learning rate is set as 0.05. We finetune the models for 15 epochs, and drop the learning rate by 0.1 at 12 epochs. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX F EVALUATION OF CLUSTERING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            550,
+            789
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the quality of the clusters produced by PCL, we compute the adjusted mutual information score (AMI) (Nguyen et al., 2010) between the clusterings and the ground-truth labels for ImageNet training data. AMI is adjusted for chance which accounts for the bias in MI to give high values to clusterings with a larger number of clusters. AMI has a value of 1 when two partitions are identical, and an expected value of 0 for random (independent) partitions. In Figure 5, we show the AMI scores for three clusterings obtained by PCL, with number of clusters $\\bar { K ^ { - } } = \\{ 2 5 0 0 0 , 5 0 0 0 0 , 1 0 0 0 0 0 \\}$ . In Table 5, we show that compared to DeepCluster (Caron et al., 2018) and MoCo (He et al., 2020), PCL produces clusters of substantially higher quality. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/dfc398fbd4dac745833851887787811eb9242fa23b4ab3f02fe67df9d6d4f7e1.jpg",
+        "image_caption": [
+            "Figure 5: Adjusted mutual information score between the clusterings generated by PCL and the ground-truth labels for ImageNet training data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            103,
+            689,
+            300
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX G CONVERGENCE PROOF ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            493,
+            385
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we provide the proof that the proposed PCL would converge. Suppose let ",
+        "bbox": [
+            174,
+            398,
+            692,
+            415
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b093164f117033f27da77ec45fb3d2f7431c80f5a1a66ab73c4a8203f595935f.jpg",
+        "text": "$$\n\\begin{array} { r } { F ( \\theta ) = \\displaystyle \\sum _ { i = 1 } ^ { n } \\log p ( x _ { i } ; \\theta ) = \\displaystyle \\sum _ { i = 1 } ^ { n } \\log \\sum _ { c _ { i } \\in C } p ( x _ { i } , c _ { i } ; \\theta ) = \\displaystyle \\sum _ { i = 1 } ^ { n } \\log \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { Q ( c _ { i } ) } } \\\\ { \\geq \\displaystyle \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ( c _ { i } ) \\log \\frac { p ( x _ { i } , c _ { i } ; \\theta ) } { Q ( c _ { i } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            205,
+            421,
+            764,
+            508
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We have shown in Section 3.2 that the above inequality holds with equality when $Q ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \\theta )$ . At the $t$ -th E-step, we have estimated $Q ^ { t } ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \\theta ^ { t } )$ . Therefore we have: ",
+        "bbox": [
+            174,
+            512,
+            825,
+            551
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6a994f250cb1ef4a2d8227072040c20cafe5bfc26008bb53947ce3a781ed6899.jpg",
+        "text": "$$\nF ( \\theta ^ { t } ) = \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ^ { t } ( c _ { i } ) \\log \\frac { p ( x _ { i } , c _ { i } ; \\theta ^ { t } ) } { Q ^ { t } ( c _ { i } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            556,
+            638,
+            599
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "At the $t$ -th M-step, we fix $Q ^ { t } ( c _ { i } ) = p ( c _ { i } ; x _ { i } , \\theta ^ { t } )$ and train parameter $\\theta$ to maximize Equation 14. Therefore we always have: ",
+        "bbox": [
+            173,
+            613,
+            826,
+            642
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/649ed45c52c27bbe7509ef11d2eeed177708c5eb380528aa3b6d8d836369bb52.jpg",
+        "text": "$$\nF ( \\theta ^ { t + 1 } ) \\geq \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ^ { t } ( c _ { i } ) \\log \\frac { p ( x _ { i } , c _ { i } ; \\theta ^ { t + 1 } ) } { Q ^ { t } ( c _ { i } ) } \\geq \\sum _ { i = 1 } ^ { n } \\sum _ { c _ { i } \\in C } Q ^ { t } ( c _ { i } ) \\log \\frac { p ( x _ { i } , c _ { i } ; \\theta ^ { t } ) } { Q ^ { t } ( c _ { i } ) } = F ( \\theta ^ { t } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            648,
+            787,
+            691
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The above result suggests that $F ( \\theta ^ { t } )$ monotonously increase along with more iterations. Hence the algorithm will converge. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            736
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX H VISUALIZATION OF CLUSTERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            755,
+            557,
+            772
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we show ImageNet training images that are randomly chosen from clusters generated by the proposed PCL. PCL not only clusters images from the same class together, but also finds fine-grained patterns that distinguish sub-classes, demonstrating its capability to learn useful semantic representations. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            843
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/1e4146cb6ce2c5169a5ec1608ea8593463e090a9f89e6ba8e6b80c0addd06d27.jpg",
+        "image_caption": [
+            "Figure 6: Visualization of randomly chosen clusters generated by PCL. Green boarder marks top-5 images that are closest to fine-grained prototypes $K = 1 0 0 k$ ). Orange boarder marks images randomly chosen from coarse-grained clusters $K = 5 0 k$ ) that also cover the same green images. PCL can discover hierarchical semantic structures within the data (e.g. images with horse and man form a fine-grained cluster within the coarse-grained horse cluster.) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            143,
+            823,
+            796
+        ],
+        "page_idx": 15
+    }
+]

parse/train/MRYuRHsHzK4/MRYuRHsHzK4.md

@@ -0,0 +1,462 @@
+# Similarity-aware Positive Instance Sampling for Graph Contrastive Pre-training
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Graph instance contrastive learning has been proved as an effective task for Graph Neural Network (GNN) pre-training. However, one key issue may seriously impede the representative power in existing works: Positive instances created by current methods often miss crucial information of graphs or even yield illegal instances (such as non-chemically-aware graphs in molecular generation). To remedy this issue, we propose to select positive graph instances directly from existing graphs in the training set, which ultimately maintains the legality and similarity to the target graphs. Our selection is based on certain domain-specific pair-wise similarity measurements as well as sampling from a hierarchical graph encoding similarity relations among graphs. Besides, we develop an adaptive node-level pre-training method to dynamically mask nodes to distribute them evenly in the graph. We conduct extensive experiments on 13 graph classification and node classification benchmark datasets from various domains. The results demonstrate that the GNN models pre-trained by our strategies can outperform those trained-from-scratch models as well as the variants obtained by existing methods.
+
+# 16 1 Introduction
+
+17 Pre-training on graph data has received wide interests in recent years, with a large range of insightful   
+18 works focused on learning universal graph structural patterns lying in different kinds of graph   
+19 data [25, 15, 40, 28]. For instance, Hu et al. [15] pre-train graph neural networks on molecules   
+20 and transfer the learned model to molecular graph classification tasks, while Qiu et al. [25] pioneer   
+21 pre-training on big graphs. Compared with traditional semi-supervised or supervised training methods   
+22 for graph neural networks [12, 18, 38, 10, 33], pre-training tasks formulate the training objective   
+23 without the access of training labels, and they empower graph neural networks to be generalized to   
+24 unseen graphs or nodes with no or minor fine-tuning training cost. How to define proper pre-training   
+25 tasks comes as the principal and also the most challenging part in graph self-supervised learning.   
+26 Among current works, graph instance contrastive learning based pre-training tasks have been proved   
+27 effective to learn graph strcutrual information [25, 40]. It preforms contrast between positive/negative   
+28 instance pairs extracted from real graphs observed in the dataset. Though positive pairs for graph   
+29 contrastive learning seems easy to define for those tasks not performed on graph instances, like   
+30 DeepWalk [22], node2vec [11], where near node-node pairs are treated as positive pairs and Infomax   
+31 based models like DGI [34], InfoGraph [31], where node-graph pairs from a same graph are treated   
+32 as positive pairs, it is not the case for graph instance contrastive learning. Attempts from previous   
+33 literature mainly focus on devising suitable graph augmentation methods, such as graph sampling [25,   
+34 40], node dropping [40], edge perturbation [40], and diffusion graph [13] to get positive graph   
+35 instances from the original graph. Despite the achievements they have made using such graph data   
+36 augmentation strategies, we assume that such perturbation based graph data augmentation methods   
+37 are not universal strategies to get ideal positive samples preserving necessary information for graph   
+38 contrastive learning for various kinds of graph data such as molecular graphs, social graphs, and   
+39 academic graphs.   
+40 We make our assumptions on the necessary in  
+41 formation that should be preserved in positive in  
+42 stances in the contrastive learning process, which   
+43 though have not been proved theoretically, are rea  
+44 sonable and are arrived from the re-thinking of the   
+45 purpose and inherent principle of the contrastive   
+46 learning and what should positive samples pre  
+47 serve to get an effective method. Such unproved   
+48 but reasonable assumptions for positive instances   
+49 are as follows:
+
+• Positive instances should be semantically similar with the target instance; • Positive samples for the same target instance should also be similar with each other; • Positive instances should preserve certain domain information if necessary.
+
+![](images/13d38801a2f1f29601d38a7afe3b2605083fea5c809ac5c60539b3f80d673180.jpg)  
+Figure 1: The fingerprint similarity scores (in orange) and percent of legal molecular outputs (in blue) generated by graph data augmentation strategies: dropping nodes and dropping edges from a same molecule w.r.t. the ratio of nodes / edges being dropped on 1000 molecular graphs. The fingerprint similarity and the percent of legal molecular outputs decreased dramatically even for the small proportion of nod/edge dropping.
+
+56 Based on such assumptions, we can see that some widely used graph data augmentation strategies   
+57 cannot always get positive instances with such properties preserved when being applied on different   
+58 kinds of graph data. As shown in Fig. 1, simple edge-perturbation or node-dropping for molecular   
+59 graph contrastive learning strategies can hardly get legal graph instances given the fact that molecules   
+60 are specifically formulated in accordance to strict chemical constraints which will be easily broken if   
+61 some edges/nodes, even of a very small number, are perturbed. Moreover, subgraph sampling strategy,   
+62 though effective when applied on graphs without node/edge attributes, may always lead to positive   
+63 instances that are dissimilar with the target instance when applied on molecular graphs. Statistical   
+64 results for subgraph sampling and another data augmentation strategy suffering from similar problems   
+65 – attribute masking, are presented in Appendix A.5.1.   
+66 Thus, in this paper, we move beyond the widely used graph data augmentation strategies for an   
+67 effective and more universal method to get positive graph instances for graph instance contrastive   
+68 learning. We propose a simple but effective similarity based positive instances sampling strategy that   
+69 can be applied on various kinds of graph data. Unlike previous methods that construct contrastive   
+70 pairs by graph augmentation, our method encodes the pair-wise similarity information, measured by   
+71 certain domain-specific similarity/proximity, into a hierarchical structure and selects positive graph   
+72 instances from such a structure which ultimately maintains the legality of the sampled instances   
+73 and high similarity to the target graphs (see Appendix C for details). Moreover, we also propose   
+74 an improvement for a widely-used node-level pre-training strategy [15], which, together with our   
+75 similarity aware graph positive sampling strategy, brings us an upper strategy design philosophy. That   
+76 is, the necessary of introducing prior knowledge or bias in random strategies.   
+77 We conduct extensive experiments on three representative kinds of graph data: molecular graphs,   
+78 social graphs as well as big social and academic graphs where nodes are of interest to demonstrate the   
+79 effectiveness and superiority of our proposed sampling based strategy over previous graph contrastive   
+80 learning strategies and also some other strategies not based on contrastive learning for different   
+81 kinds of graph data. Besides, some additional experiments which try to transfer the GNN models   
+82 pre-trained on molecular graph dataset to downstream social graph classification task let us have   
+83 a glimpse of the potential possibility of the pre-trained models’ ability to capture universal graph   
+84 structural information underlying different kinds of graph data as well as the possibility to get such   
+85 a universally transferable pre-trained model. Similar things have been explored in other domains   
+86 such as multi-lingual language models. However, to our best knowledge, we are the first to propose   
+87 such possibility for pre-trained GNN models, which, though lacks further and thorough exploration   
+88 in the paper, can probably point out a new possibly meaningful research direction and cast light on   
+89 successive work.   
+91 Graph Representation Learning. How to generate expressive representation vectors for nodes or   
+92 graphs that can capture both node-level information, like node attributes and node proximities [32,   
+93 22, 11], as well as graph-level information, like structural proximity between nodes [26] and graph   
+94 property [10], is a vital question and has aroused great interests from graph learning community.   
+95 Common approaches include unsupervised manners [22, 11, 32, 31, 34, 42, 24, 23], which always   
+96 adopt a shallow architecture, semi-supervised and supervised approaches [33, 18, 12, 10, 38], which   
+97 always leverage expressive graph neural networks to capture critical information from both graph   
+98 structure and node/edge attributes. In this work, we adopt graph neural networks as our graph encoder   
+99 to generate expressive representations for nodes or graphs.   
+100 Contrastive Learning. Contrastive learning has proved its efficiency to learn highly expressive   
+101 representations in Computer Vision domain [5, 14]. Moreover, contrastive learning has also been   
+102 used in graph learning for a long time, like doing contrast between node-node pairs [22, 11] to   
+103 encode various node proximities into node representations. Recently, there are also efforts focusing   
+104 on using contrastive learning on graph instances to learn instance-level representations that can be   
+105 aware of critical graph structural information [25, 40]. In this work, we also focus on graph instance   
+106 contrastive learning, but turn to approach this problem in a new manner.   
+107 Graph Pre-training. Pre-trained models have proved their highly transferable ability when being   
+108 applied on downstream datasets in other domains, such as the language models [6] in NLP domain.   
+109 Famous pre-training strategies for GNNs on graph data largely fall into two genres: node-level and   
+110 graph-level strategies. Node-level strategies aim to design proper tasks that can help GNNs learn   
+111 node/edge attribute distribution information [15, 28]. More universally, graph-level strategies try to   
+112 learn design tasks that can learn structural information for both nodes and graphs [25, 40]. In this   
+113 work, we aim to design more powerful pre-training strategies for graph data from both graph-level   
+114 and node-level.
+
+# 115 3 Preliminary
+
+116 We denote an attributed graph as $G ( \nu , \mathcal { E } , \mathcal { X } )$ , where $| \nu | = n$ refers to a set of $n$ nodes and $| { \mathcal { E } } | = m$   
+117 refers to a set of $m$ edges. We denote $\pmb { x } _ { v } \in \mathbb { R } ^ { d }$ as the initial feature of node $v$ and $e _ { u v }$ as the initial   
+118 feature of edge $( u , v )$ .   
+119 Graph Neural Networks (GNNs) can be modeled as the a messaging passing process, which involves   
+120 neighborhood aggregation among nodes in graph and message updating to the next layer. Namely,   
+121 the general message passing process is defined as:
+
+$$
+\begin{array} { r l } & { \pmb { m } _ { v } ^ { ( l + 1 ) } = \mathrm { A G G R E G A T E } ( \{ ( \pmb { h } _ { v } ^ { ( l ) } , \pmb { h } _ { u } ^ { ( l ) } , \pmb { e } _ { u v } ) | u \in \mathcal { N } _ { v } \} ) , } \\ & { \quad \pmb { h } _ { v } ^ { l + 1 } = \sigma ( \pmb { W } ^ { ( l ) } \pmb { m } _ { v } ^ { ( l + 1 ) } + \pmb { b } ^ { ( l ) } ) , } \end{array}
+$$
+
+122 where $h _ { v } ^ { l + 1 }$ refers to the hidden state of $v$ at $( l + 1 )$ -th layer with $\pmb { h } _ { v } ^ { ( 0 ) } = \pmb { x } _ { v }$ and $m _ { v } ^ { ( l + 1 ) }$ refers   
+123 to the aggregated message of $v$ at $( l + 1 )$ -th layer. $\mathcal { N } _ { v }$ denotes the neighbor node set of node $v$ .   
+124 AGGREGATE $( \cdot )$ aggregates the hidden states of $v$ ’s neighbor nodes and edges, such as mean/max   
+125 pooling and graph attention[38, 33]. are the trainable parameters. If the m $\sigma ( \cdot )$ $\mathcal { M } _ { L }$ e activaticontains $L$ function, such aslayers, the outpu $\mathrm { R e L U } ( \cdot )$ . a $W ^ { ( l ) }$ $\{ h _ { v } ^ { ( L ) } \} _ { v \in v }$ $\mathbf { \delta } _ { b } ( l )$   
+127 usually represents the node-level embeddings of input graph. Moreover, the graph-level embedding   
+128 $_ { h _ { G } }$ is derived by simply applying a READOUT function as
+
+$$
+\pmb { h } _ { G } = \mathrm { R E A D O U T } \big ( \{ \pmb { h } _ { v } ^ { ( L ) } \} _ { v \in \mathcal { N } _ { v } } \big ) .
+$$
+
+129 Representations generated by GNNs over graphs, including node-level and graph-level representa  
+130 tions, are meaningful embeddings to perform various downstream graph learning tasks, like node   
+131 classification [44, 4], graph classification [31, 15, 28], and so on.
+
+# 32 4 Similarity-aware Positive Graph Instance Sampling
+
+133 In this section, we propose our similarity-aware hierarchical graph positive instance sampling method   
+134 to sample positive graph instances with three kinds of information mentioned in Sec. 1 preserved. We   
+135 first explain our motivation w.r.t. why we turn to other graph instances in the pre-training dataset   
+136 for positive instances and why it may work for graph data. Then we propose our sampling strategies   
+137 as well as two versions of the sampling process. We also give some further discussions for such   
+138 two sampling strategies. Moreover, we also propose an improvement of the widely used node-level   
+139 pre-training strategy, which is an additional contribution of our work.
+
+![](images/8d52af2eb5d0619a23ae71785a516350e228e907f893e181d09ec1458754f970.jpg)  
+Figure 2: Illustration of the hierarchical graph instance sampling process for the molecular graphs.
+
+# 140 4.1 Motivation: Sampling or Constructing?
+
+141 As discussed in Sec. 1, it is hard to design a clean and elegant data augmentation strategy universally   
+142 for various kinds of graph data to get positive instances that are similar enough with the target graph   
+143 instance and can also preserve necessary domain specific information. Since what we care about   
+144 for positive graph instances are their similarity with the target graph instance, rather than the way   
+145 to obtaining them, we move beyond popular graph data augmentation skills and propose to sample   
+146 positive instances from the pre-training dataset for the target graph instance. Specifically, we propose   
+147 to use approximate similarity functions that can reveal the semantic similarity between two graph   
+148 instances to some extend to estimate the semantic similarity scores between two graph instances. The   
+149 similarity relations between each pair of graphs are then encoded into a similarity hierarchy, which is   
+150 then used for positive instance sampling. We also make some further discussions for the proposed   
+151 similarity-aware sampling process, which may inspire future design for other sampling strategies.
+
+# 152 4.2 Similarity-aware Positive Graph Instance Sampling
+
+153 Following [1], we assume that each graph instance $G _ { i } \in \mathcal G$ has its semantic class clas $\mathbf { s } ( G _ { i } ) = c _ { i }$   
+154 Thus, the optimal positive sampling strategy should choose graph instances of the same semantic   
+155 class with the graph instance $G _ { i }$ as its positive instances. Formally, the rate for sampling graph $G _ { j }$ as   
+156 the positive instance of $G _ { i }$ is:
+
+$$
+P _ { i } ^ { + } ( G _ { j } ) = { \left\{ \begin{array} { l l } { { \frac { 1 } { | \mathcal { G } _ { i } ^ { + } | } } } & { { \mathrm { I f } } \mathrm { c l a s s } ( G _ { i } ) = \mathrm { c l a s s } ( G _ { j } ) , } \\ { 0 } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+157 where $\mathcal { G } _ { i } ^ { + } = \{ G _ { k } | G _ { k } \in \mathcal { G } , \operatorname { c l a s s } ( G _ { k } ) = \operatorname { c l a s s } ( G _ { i } ) \}$ is the set of graph instances of the same class   
+158 with graph instance $G _ { i }$ . We can then assume that there exists a ground-truth semantic similarity   
+159 function $\mathrm { s i m } _ { \mathrm { g t } } ( \cdot , \cdot )$ which reveals whether two graph instances belong to a same semantic class   
+160 accurately:
+
+$$
+\begin{array} { r } { \mathrm { s i m } _ { \mathrm { g t } } ( G _ { i } , G _ { j } ) = \left\{ \begin{array} { l l } { 1 } & { \mathrm { I f } \mathrm { c l a s s } ( G _ { i } ) = \mathrm { c l a s s } ( G _ { j } ) , } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+161 However, we have no knowledge of the such ground-truth semantic similarity function since our   
+162 pre-training graph datasets are always unlabeled. Thus we propose to use approximate similarity   
+163 functions that can be obtained from the real-world and applied in practice easily to estimate the   
+164 similarity between two graph instances. We can make some assumptions for the chosen approximate   
+165 similarity functions to ensure their good quality, which are deferred to Appendix B.1.
+
+Specifically, we choose a similarity score function $\sin ( \cdot , \cdot )$ to estimate the semantic similarity between two graphs. To further use the similarity measurement to perform flexible positive sampling, we propose a two-step approach1 to encode pair-wise similarity into a more abstract and structural hierarchy efficiently – a similarity-based hierarchical graph ${ \mathcal { H } } ( { \mathcal { G } } , { \mathcal { E } } _ { H } )$ , where $\mathcal { G }$ is the set of graphs in our pre-training dataset, ${ \mathcal { E } } _ { H }$ is the edge set. Formally, we introduce a similarity threshold $\tau ( 0 < \tau <$
+
+171 1), and based on which the edge set is defined as: $\mathcal { E } _ { H } = \{ ( G _ { i } , G _ { j } ) | \mathrm { s i m } ( G _ { i } , G _ { j } ) \geq \tau , G _ { i } \in \mathcal { G } , G _ { j } \in$   
+172 $\dot { \mathcal { G } } \rbrace$ . Many similarity functions are good candidates for $\sin ( \cdot , \cdot )$ such as fingerprint similarity [27] for   
+173 molecular graphs, Weisfeiler-Lehman Graph Kernel [29] normalized similarity for graphs without   
+174 node/edge attributes and node proximity for nodes in a big graph.   
+175 The constructed hierarchical graph, which encodes more information beyond pair-wise similarity2,   
+176 can be used to design flexible sampling strategies for positive graph instance selection. We propose   
+177 two sampling strategies:
+
+• First-order neighbourhood sampling. For each graph $G _ { i }$ , sample a one-hop neighbour set of a fixed size as its positive instances. • High-order graph sampling. We perform $l$ -hops random walks starting from graph $G _ { i }$ for $k$ times and choose positive instances according to their appearance frequencies.
+
+An illustration for HGC is presented in Fig. 2. We will give some further discussions w.r.t. why we use similarity for positive instance sampling and how would high-order sampling potentially benefit the sampling process and the resulting positive instances in the next section.
+
+# 185 4.3 Further Discussion for Similarity-aware Sampling Strategy
+
+86 In this section, we want to answer two questions: Q1: Why we still sample positive instances based on   
+7 approximate pair-wise similarity scores, though it may not be an accurate similarity estimation? Q2:   
+88 How would high-order sampling potentially benefit the sampling process and the resulting positive   
+89 instances? Moreover, we also propose some further discussions for the proposed similarity-aware   
+90 positive instance sampling strategy.
+
+To begin with, we propose a property of the contrastive learning that is intuitively correct:
+
+Property 1. Avoiding false-positives is important in the contrastive learning process.
+
+Here, “false-positives” denotes positive instances selected by a non-optimal positive sampling strategy whose semantic classes are not same with the target graph instance. We explain why such a property holds in Appendix B.2 in detail, though it should be correct intuitively.
+
+Then, Q1 can be answered by proposing the following property of the positive instances sampled according to their similarity scores with the target graph instance:
+
+Property 2. If the similarity threshold $\tau$ is changing in a proper range, an instance that has a high similarity score with the target instance will also has a high probability to be a ground-truth positive instance.
+
+We would explain why this property holds in detail in Appendix B.3, based on our assumptions on 02 good properties of the approximate similarity function (Def. 2). Thus, the answer for Q1 could be: 03 sampling positive instances according to their similarity scores with the target graph instance may 04 help avoid sampling false-positives.
+
+To answer Q2, we first propose one limitation of the first-order similarity sampling strategy by pointing out a crucial property of the ground-truth similarity function that the approximate similarity functions always fail to preserve – the transitivity of the ground-truth similarity function:
+
+Property 3 (Transitivity of the ground-truth similarity function). Ground-truth similarity function is transitive: $i f s i m _ { g t } ( G _ { i } , G _ { j } ) = 1$ and $s i m _ { g t } ( G _ { i } , G _ { k } ) = 1$ , then $s i m _ { g t } ( G _ { j } , G _ { k } ) = 1$ .
+
+Such transitivity of the ground-truth similarity function ensures the transitivity of the relations between nodes in the hierarchical graph constructed based on the ground-truth similarity measurement. However, it is obvious that relations between nodes in our constructed similarity-based hierarchical graph – represented by edges, are not fully-transitive. It is because that the approximate similarity function we use in practice is not an optimal one.
+
+215 We introduce the definition of connectivity and connectivity order between nodes in the graph in   
+216 Appendix B.4. The transitivity of the ground-truth similarity function ensures that $G _ { i }$ ’s positive   
+217 instances sampled by first-order neighbourhood sampling strategy can have connectivity orders with   
+218 $G _ { i }$ ranging from 1 to $| \mathcal { G } _ { i } ^ { + } | - 1$ . It is hard for first-order sampling strategy applied on the hierarchical   
+219 graph constructed in practice to get positive instances that also have high-order connectivity (e.g.,   
+220 second-order connectivity) with the target graph instance. The reason is that first-order information   
+221 cannot reveal high-order information (e.g., high-order connectivity with the target graph instance)   
+222 in the constructed hierarchical graph, while it can fully reveal higher-order connectivity in the   
+223 constructed hierarchical graph based on ground-truth similarity function (i.e., if a graph instance $G _ { j }$   
+224 is 1-connected to $G _ { i }$ , then it is $2 , 3 , . . . , | \mathcal { G } _ { i } ^ { + } | - 1$ connected to $G _ { i }$ as well).   
+25 We can prove that first-order neighbouring positive instances sampled by second-order sampling   
+26 process are more likely to be connected with each other (see Appendix B.4 for details). This can   
+7 remedy the limitation of the first-order sampling strategy, which cannot guarantee the similarity   
+8 between positive instances. Moreover, it can be empirically verified that positive instances that are   
+9 both first-order and second-order connected to the target instance are also more similar with the target   
+0 instance. More details are deferred to Appendix B.4. We also expect that higher-order sampling   
+process can bring more benefit to the resulting positive instances and worth trying in practice.
+
+Additionally, we propose further discussions w.r.t. how would the changing similarity threshold $\tau$ influence the balance between the increasing sampling rate estimation accuracy for ground-truth positive instances and the risk of sampling more false-positive instances. Detailed discussions are deferred to Appendix B.5.
+
+# 4.4 Adaptive Masking for Node-level Pre-training
+
+In this section, we propose our improvement of the widely used attribute masking node-level pretraining strategy: Adaptive Masking, which is designed for attributed graphs only. As introduced in [15], attribute masking task, which is inspired from “masked language model” (MLM) in NLP, helps the model learn node/edge attribute distribution across the graph. Formally, attribute masking task is defined as:
+
+Definition 1. (Attribute masking task): Given an attributed graph $G ( \nu , \mathcal { E } , \mathcal { X } )$ , a target node $v \in \mathcal V$ and its corresponding feature vector $\mathbf { \boldsymbol { x } } _ { v }$ , attribute masking task is first to mask a subset of the features ${ \pmb x } _ { s u b } \subseteq { \pmb x } _ { v }$ in feature vector $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathit { v } }$ and produce a new feature vector $\pmb { x } _ { v } ^ { \prime }$ for node $v$ . Then let a model $\mathcal { M }$ to make the prediction of the masked feature set $\mathbf { \mathcal { x } } _ { s u b }$ given the new feature vector $\pmb { x } _ { v } ^ { \prime }$ as input.
+
+Hu et al. [15] follows the same protocol in MLM by uniformly selecting the nodes set from graphs to construct the attribute mask task. But, we argue that the uniform selection may break structural relations among nodes in graphs so that the model may miss critical information for node attribute distribution from such relations. We introduce a toy example in the Appendix A.4.2.
+
+Inspired by $\mathrm { K m e a n } \substack { + \mathrm { + } [ 2 ] }$ , which aims to obtain the good initial centroids with widely separated in space, we also adopt the adaptive masking (AdaM) to generate the mask node set within less correlations. In particular, we divide the masking process into $T$ steps. At the first step, we uniformly sample a small mask set. Secondly, the masking weight of each candidate node is adaptive by function PScore. The detail of PScore is demonstrate in Algorithm 2 (see Appendix A.4.2). In PScore, for the candidate node $v$ , we calculate the similarity of model output between before and after masking. High similarity indicates that node $v$ is not influenced by the mask operation at the current step, resulting in the low correlation between node $v$ and current mask set $S _ { \mathrm { c u r } }$ . Finally, we randomly sample a node set $\kappa$ with the probability constructed by masking weight. The algorithmic details are provided in the supplementary material.
+
+According to the adaptive masking operation, we can dynamically adjust the importance of nodes during training and obtain a more representative mask node set for the attribute masking task. Such intuition is further discussed in Appendix A.7.
+
+# 5 Experiments
+
+# 5.1 Experimental Configuration
+
+Pretraining Data Collection. We conduct the pretraining on four datasets from various domains: 1). academic and purchasing graphs: we collect four data sources from Deep Graph Library [36] and merge them into one pretraining dataset dubbed AP_NF. 2). social graphs: we construct two pretraining datasets termed SocS_NF and SocL_NF. SocS_NF contains five data sources, while
+
+Table 1: Experimental results (ROC-AUC) on molecular datasets. The numbers in brackets are standard deviations. Numbers in gray are the best results achieved by backbone models. Bold numbers represent the best results by different backbones. Bold numbers in green represent the best results over all backbones.   
+
+<table><tr><td rowspan=1 colspan=2>Backbone   Strategy</td><td rowspan=1 colspan=1>SIDER</td><td rowspan=1 colspan=1>ClinTox</td><td rowspan=1 colspan=1>BACE</td><td rowspan=1 colspan=1>HIV</td><td rowspan=1 colspan=1>BBBP</td><td rowspan=1 colspan=1>Tox21</td><td rowspan=1 colspan=1>ToxCast</td></tr><tr><td rowspan=1 colspan=2>#Molecules</td><td rowspan=1 colspan=1>1427</td><td rowspan=1 colspan=1>1478</td><td rowspan=1 colspan=1>1513</td><td rowspan=1 colspan=1>41127</td><td rowspan=1 colspan=1>2039</td><td rowspan=1 colspan=1>7831</td><td rowspan=1 colspan=1>8575</td></tr><tr><td rowspan=1 colspan=2>#Prediction tasks</td><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>617</td></tr><tr><td rowspan=8 colspan=1>GIN</td><td rowspan=1 colspan=1>GraphCL</td><td rowspan=1 colspan=1>0.5946(0.0055)</td><td rowspan=1 colspan=1>0.6592(0.0074)</td><td rowspan=1 colspan=1>0.7713(0.0057)</td><td rowspan=1 colspan=1>0.7754(0.0093)</td><td rowspan=1 colspan=1>0.7050(0.0012)</td><td rowspan=1 colspan=1>0.7562(0.0024)</td><td rowspan=1 colspan=1>0.6289(0.0023)</td></tr><tr><td rowspan=1 colspan=1>C_Subgraph</td><td rowspan=1 colspan=1>0.5838(0.0022)</td><td rowspan=1 colspan=1>0.6390(0.0071)</td><td rowspan=1 colspan=1>0.7736(0.0140)</td><td rowspan=1 colspan=1>0.7341(0.0079)</td><td rowspan=1 colspan=1>0.6901(0.0026)</td><td rowspan=1 colspan=1>0.7521(0.0044)</td><td rowspan=1 colspan=1>0.6263(0.0061)</td></tr><tr><td rowspan=1 colspan=1>Infomax</td><td rowspan=1 colspan=1>0.5755(0.0024)</td><td rowspan=1 colspan=1>0.6944(0.0187)</td><td rowspan=1 colspan=1>0.7571(0.0094)</td><td rowspan=1 colspan=1>0.7653(0.0040)</td><td rowspan=1 colspan=1>0.6929(0.0054)</td><td rowspan=1 colspan=1>0.7674(0.0020)</td><td rowspan=1 colspan=1>0.6302(0.0007)</td></tr><tr><td rowspan=1 colspan=1>Attr_Mask</td><td rowspan=1 colspan=1>0.5947(0.0083)</td><td rowspan=1 colspan=1>0.6685(0.0093)</td><td rowspan=1 colspan=1>0.8064(0.0042)</td><td rowspan=1 colspan=1>0.7668(0.0106)</td><td rowspan=1 colspan=1>0.6316(0.0007)</td><td rowspan=1 colspan=1>0.7657(0.0054)</td><td rowspan=1 colspan=1>0.6463(0.0029)</td></tr><tr><td rowspan=1 colspan=1>Context_Pred</td><td rowspan=1 colspan=1>0.6132(0.0050)</td><td rowspan=1 colspan=1>0.6476(0.0168)</td><td rowspan=1 colspan=1>0.8055(0.0115)</td><td rowspan=1 colspan=1>0.7807(0.0054)</td><td rowspan=1 colspan=1>0.7026(0.0097)</td><td rowspan=1 colspan=1>0.7715(0.0022)</td><td rowspan=1 colspan=1>0.6427(0.0024)</td></tr><tr><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6333(0.0121)</td><td rowspan=1 colspan=1>0.8134(0.0115)</td><td rowspan=1 colspan=1>0.8442(0.0138)</td><td rowspan=1 colspan=1>0.7853(0.0072)</td><td rowspan=1 colspan=1>0.7217(0.0042)</td><td rowspan=1 colspan=1>0.7770(0.0022)</td><td rowspan=1 colspan=1>0.6520(0.0052)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6164(0.0051)</td><td rowspan=1 colspan=1>0.7797(0.0040)</td><td rowspan=1 colspan=1>0.8224(0.0041)</td><td rowspan=1 colspan=1>0.7704(0.0073)</td><td rowspan=1 colspan=1>0.7273(0.0146)</td><td rowspan=1 colspan=1>0.7696(0.0014)</td><td rowspan=1 colspan=1>0.6603(0.0004)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6183(0.0063)</td><td rowspan=1 colspan=1>0.7845(0.0499)</td><td rowspan=1 colspan=1>0.8428(0.0064)</td><td rowspan=1 colspan=1>0.7839(0.0073)</td><td rowspan=1 colspan=1>0.7172(0.0052)</td><td rowspan=1 colspan=1>0.7692(0.0030)</td><td rowspan=1 colspan=1>0.6537(0.0030)</td></tr><tr><td rowspan=3 colspan=1>GCN</td><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6243(0.0044)</td><td rowspan=1 colspan=1>0.8638(0.0051)</td><td rowspan=1 colspan=1>0.8405(0.0006)</td><td rowspan=1 colspan=1>0.7724(0.0206)</td><td rowspan=1 colspan=1>0.7168(0.0014)</td><td rowspan=1 colspan=1>0.7581(0.0026)</td><td rowspan=1 colspan=1>0.6490(0.024)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6209(0.0028)</td><td rowspan=1 colspan=1>0.8553(0.0044)</td><td rowspan=1 colspan=1>0.8205(0.0120)</td><td rowspan=1 colspan=1>0.7693(0.0032)</td><td rowspan=1 colspan=1>0.7018(0.0074)</td><td rowspan=1 colspan=1>0.7533(0.0059)</td><td rowspan=1 colspan=1>0.6449(0.0035)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6164(0.0103)</td><td rowspan=1 colspan=1>0.8231(0.0325)</td><td rowspan=1 colspan=1>0.8249(0.0059)</td><td rowspan=1 colspan=1>0.7946(0.0102)</td><td rowspan=1 colspan=1>0.7189(0.0103)</td><td rowspan=1 colspan=1>0.7636(0.0070)</td><td rowspan=1 colspan=1>0.6525(0.0025)</td></tr><tr><td rowspan=3 colspan=1>GraphSAGE</td><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6286(0.0016)</td><td rowspan=1 colspan=1>0.7395(0.0284)</td><td rowspan=1 colspan=1>0.8368(0.0008)</td><td rowspan=1 colspan=1>0.7722(0.0149)</td><td rowspan=1 colspan=1>0.7129(0.0153)</td><td rowspan=1 colspan=1>0.7583(0.0012)</td><td rowspan=1 colspan=1>0.6505(0.0004)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6148(0.0100)</td><td rowspan=1 colspan=1>0.7098(0.0244)</td><td rowspan=1 colspan=1>0.8212(0.0019)</td><td rowspan=1 colspan=1>0.7730(0.0057)</td><td rowspan=1 colspan=1>0.6982(0.0088)</td><td rowspan=1 colspan=1>0.7643(0.0011)</td><td rowspan=1 colspan=1>0.6492(0.0004)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6250(0.0029)</td><td rowspan=1 colspan=1>0.8127(0.0213)</td><td rowspan=1 colspan=1>0.7812(0.0038)</td><td rowspan=1 colspan=1>0.7708(0.0053)</td><td rowspan=1 colspan=1>0.7187(0.0019)</td><td rowspan=1 colspan=1>0.7610(0.0008)</td><td rowspan=1 colspan=1>0.6442(0.0018)</td></tr></table>
+
+269 SocL_NF contains 13 data sources collected from TUDataset [19]. 3). molecular graphs: we use   
+270 the same pretraining dataset with 2 million molecules in [15] and denote it as MolD. The suffix NF   
+271 indicates “no feature”. Since the data sources have different features, we remove all feature and only   
+272 pretrain these datasets with HGC. The details are presented in Appendix A.1.
+
+Downstream Tasks. We mainly evaluate the peformance on two tasks, node classfication and graph classification. For the node classification, we conduct the experiments on two datasets, US-Airport [26] and H-index [41] following the same splitting protocol in [25]. For the graph classification, we conduct the experiments on 11 datasets from molecular graph (7 datasets from [37]) and social graphs (4 datasets from [39]). Details of those datasets are deferred to Appendix A.1.
+
+Baselines. For molecular graph classification, we comprehensively compare our pre-training strategies with recent 6 self-supervised learning strategies for graphs. Among them, Edge_Pred, Infomax, Attr_Mask, Context_Pred, are proposed in [15], all of which are node-level pre-training strategies. GraphCL [40] and C_Subgraph [25] are graph level contrastive pre-training strategies. For node classification and social network graph classification, we compare our model with the best result of GCC [25] and several other models (i.e., ProNE [42], GraphWave [7], DGK [39], graph2vec [20], InfoGraph [31], DGCNN [43] and GIN [38]). Details for the implementation, pre-training and fine-tuning settings of baseline models will be discussed in the Appendix A.2 and A.3.
+
+Pre-training Settings. We use Adam [17] for optimization with the learning rate of 0.001, $\beta _ { 1 } =$ $0 . 9 , \beta _ { 2 } = 0 . 9 9 9$ and weight decay of 0, learning rate warms up over the first $1 0 \%$ steps and then decays linearly. Gradient norm clipping is applied with range $[ - 1 , 1 ]$ . The temperature $\tau$ is set to 0.07 in HGC pre-training stage. The batch size of MolD pre-training is 256. For SocL_NF and SocS_NF pre-training, the batch size is 32. For the graph classification task, we use mean-pooling to get graph-level representations following [15]. More pre-training details, including backbones, hyper-parameters and training steps are deferred to Appendix A.2.2.
+
+Fine-tuning Settings. For each fine-tuning task, we train models for 100 epochs. For graph classification tasks (whether social graphs or molecular graphs), we select the best model by their corresponding validation metrics, while the last model after 100 epochs training on downstream training sets are used for further evaluation on downstream evaluation sets, the same with [25]. We adopt micro F1-score and ROC-AUC as the evaluation measures for different tasks. For molecular dataset, as suggested by [37], we apply three independent randomly initialized runs on each dataset and report the mean and standard deviation. More details are are deferred to Appendix A.2.2.
+
+# 5.2 Results of Downstream Tasks
+
+# 5.2.1 Graph Classification
+
+02 We evaluate both HGC and AdaM on 7 popular molecular graph classification datasets and HGC on 4   
+303 social network graph classification datasets.   
+304 The result of molecular graph classification. For molecular graph classification datasets, we   
+305 report our pre-training strategies on different backbones, including GIN [38], GCN [18], Graph  
+306 SAGE [12]. Meanwhile, since only MolD contain node features, we apply both HGC and AdaM   
+307 strategies on the molecular datasets. HGC_AdaM indicates the combination of two strategies.   
+308 As shown in Table 1, we have the following observations: (1). GIN model pre-trained by   
+309 our pre-training strategies can consistently outperform those pre-trained by other existing strate  
+310 gies, with large margin on most of them. The overall absolute improvement is $2 . 9 8 \%$ in av  
+311 erage. (2). Specially, HGC can consistently outperform those graph-data-augmentation-based   
+312 contrastive learning strategies (i.e., GraphCL and C_Subgraph) . It verifies our stand point that   
+313 the graph data augmentation will lose some crucial domain information and compromise the fi  
+314 nal performance, while HGC dose not lose such information and leads to better performance.
+
+(3). Even though GCN/GraphSAGE can not surpass the our pre-trained model on GIN pretrained model, they still outperform the other pretraining strategy, which reaffirms the effectiveness of our pre-training strategies. (4). The combined strategy HGC_AdaM achieve more benefits on GCN and GraphSAGE than that of GIN. We conjecture that GIN encodes the additional noise which is introduced by this simple combination due to its strong expressive power.
+
+Table 2: Results on graph classification datasets. The evaluation metric is micro F1-score.   
+
+<table><tr><td>Strategy</td><td>IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M</td></tr><tr><td># graphs #classes</td><td>1000 2</td><td>1500 3</td><td>2000 2</td><td>5000 5</td></tr><tr><td>DGK graph2vec InfoGraph</td><td>0.670 0.711</td><td>0.446 0.504</td><td>0.780 0.758</td><td>0.413 0.479</td></tr><tr><td>DGCNN</td><td>0.730 0.700</td><td>0.497 0.478</td><td>0.825 -</td><td>0.535 -</td></tr><tr><td>GIN(No-Pret.)</td><td>0.734</td><td>0.433</td><td>0.885</td><td>0.635</td></tr><tr><td>GIN_GCC(Best)</td><td>0.756</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>0.509</td><td>0.898</td><td>0.530</td></tr><tr><td>GIN_HGC(SocS_NF)</td><td>0.765</td><td>0.474</td><td>0.913</td><td>0.657</td></tr><tr><td>GIN_HGC(SocL_NF)</td><td>0.756</td><td>0.490</td><td>0.914</td><td>0.652</td></tr></table>
+
+The result of social graph classification. To check the transferability of HGC, we conduct the finetune experiments on two models pretrained by SocL_NF and SocS_NF. SocL_NF contains the unlabeled data set used in finetune while SocS_NF does not. Table 2 documents the performance of GIN model pre-trained by HGC on SocL_NF and SocS_NF datasets. Such results show that GIN model pre-trained by HGC achieves the best performance on three out of four datasets. The comparison between GIN_HGC and GIN(No-Pret.) also confirms the benefits of HGC. Another interesting observation is that the pretrain model based on SocS_NF can obtain the better performance than than SocL_NF on two out of four datasets. It implies that HGC dose not just memorize the training samples. It can encode the latent structural information from unseen graphs and transfer the knowledge to the downstream tasks.
+
+# 5.2.2 Node Classification.
+
+We evaluate our model pre-trained by HGC on AP_NF on two downstream node classification datasets and summarize the results in Table 3. Among different versions of GCC, the best ones are presented. From Table 3, the model pre-trained by our HGC strategy can outperform the best GCC model on both datasets. It is worth noting that the pre-training dataset AP_NF contains only 70k graphs, which is much smaller than that of GCC(9M graphs). This verifies the efficiency of HGC in the information extraction.
+
+Table 3: Results on node classification datasets. The evaluation metric is micro F1-score.   
+
+<table><tr><td rowspan=1 colspan=1>Datasets</td><td rowspan=1 colspan=1>US-Ariport</td><td rowspan=1 colspan=1>H-index</td></tr><tr><td rowspan=1 colspan=1>V|E</td><td rowspan=1 colspan=1>119013599</td><td rowspan=1 colspan=1>500044020</td></tr><tr><td rowspan=1 colspan=1>ProNE</td><td rowspan=1 colspan=1>0.623</td><td rowspan=1 colspan=1>0.691</td></tr><tr><td rowspan=1 colspan=1>GraphWave</td><td rowspan=1 colspan=1>0.602</td><td rowspan=1 colspan=1>0.703</td></tr><tr><td rowspan=1 colspan=1>Struc2vec</td><td rowspan=1 colspan=1>0.662</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>GCC (Best)</td><td rowspan=1 colspan=1>0.683</td><td rowspan=1 colspan=1>0.806</td></tr><tr><td rowspan=1 colspan=1>HGC(AP_NF)</td><td rowspan=1 colspan=1>0.706</td><td rowspan=1 colspan=1>0.824</td></tr></table>
+
+# 5.3 Ablation Study
+
+# How useful are the proposed self-supervised tasks?
+
+To evaluate the contribution of our pre-training strategies, we compare the the performance of the pre-trained model by HGC and AdaM, with the model without any pre-training, each of which shares the same hyper-parameter setting. Results are summarized in Table 4 for backbone GIN. It can be seen clearly that all GIN models benefit from self-supervised pre-training tasks on all datasets. To be more specific, for GIN, absolute $1 7 . 9 \%$ ROC-AUC increase is observed on the dataset BACE, $1 6 . 5 \%$ on ClinTox, and $6 . 9 6 \%$ on SIDER, leading to $7 . 5 3 \%$ on average. Furthermore, pre-trained models gain larger improve
+
+Table 4: Effectiveness of the pretraining on GIN. Bold numbers for absolute improvements larger than 0.05.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>No-Pret.</td><td rowspan=1 colspan=1>SS-Pret.</td><td rowspan=1 colspan=1>Abs.Imp.</td></tr><tr><td rowspan=1 colspan=1>SIDER</td><td rowspan=1 colspan=1>0.5637</td><td rowspan=1 colspan=1>0.6333</td><td rowspan=1 colspan=1>+0.0696</td></tr><tr><td rowspan=1 colspan=1>ClinTox</td><td rowspan=1 colspan=1>0.6480</td><td rowspan=1 colspan=1>0.8134</td><td rowspan=1 colspan=1>+0.1654</td></tr><tr><td rowspan=1 colspan=1>BACE</td><td rowspan=1 colspan=1>0.6653</td><td rowspan=1 colspan=1>0.8442</td><td rowspan=2 colspan=1>+0.1789+0.0378</td></tr><tr><td rowspan=1 colspan=1>HIV</td><td rowspan=1 colspan=1>0.7475</td><td rowspan=1 colspan=1>0.7853</td></tr><tr><td rowspan=1 colspan=1>BBBP</td><td rowspan=1 colspan=1>0.6939</td><td rowspan=1 colspan=1>0.7273</td><td rowspan=1 colspan=1>+0.0334</td></tr><tr><td rowspan=1 colspan=1>Tox21</td><td rowspan=1 colspan=1>0.7580</td><td rowspan=1 colspan=1>0.7770</td><td rowspan=1 colspan=1>+0.0190</td></tr><tr><td rowspan=1 colspan=1>ToxCast</td><td rowspan=1 colspan=1>0.6370</td><td rowspan=1 colspan=1>0.6603</td><td rowspan=1 colspan=1>+0.0233</td></tr></table>
+
+356 ment on datasets of relatively small size (e.g., BACE, ClinTox and SIDER), which is also observed in [28]. It indicates that self-supervised pre-training helps GNN models learn more inherent graph properties, thus getting better performance in small downstream datasets where labeled graphs are scarce.
+
+Can we transfer pre-trained models to downstream datasets that are dramatically different from the pre-training one? It has long been known that the pre-trained model can be generalized to unseen data in pretraining dataset [25, 15, 6, 28, 40]. However, previous literature [25, 15, 40] largely focuses on transferring the pre-trained model to downstream
+
+Table 5: Results for pretraining transferability on graph classification datasets. Numbers in red are the negative transfer cases.   
+
+<table><tr><td>Pretraining Type</td><td>Strategy</td><td>IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M</td></tr><tr><td>None</td><td>GIN(No-Pret.)</td><td>0.734</td><td>0.433</td><td>0.885</td><td>0.635</td></tr><tr><td rowspan="3">Social</td><td>GIN_GCC(best)</td><td>0.756</td><td>0.509</td><td>0.898</td><td>0.530</td></tr><tr><td>HGC(SocS_NF)</td><td>0.765</td><td>0.474</td><td>0.913</td><td>0.657</td></tr><tr><td>HGC(SocL_NF)</td><td>0.756</td><td>0.490</td><td>0.914</td><td>0.652</td></tr><tr><td rowspan="4">Molecular</td><td>Context_Pred (MolD)</td><td>0.734</td><td>0.473</td><td>0.875</td><td>0.635</td></tr><tr><td>S_Context_Pred (MolD)</td><td>0.763</td><td>0.460</td><td>0.818</td><td>0.625</td></tr><tr><td>HGC(MolD)</td><td>0.768</td><td>0.504</td><td>0.912</td><td>0.656</td></tr><tr><td>AdaM(MolD)</td><td>0.740</td><td>0.486</td><td>0.880</td><td>0.654</td></tr></table>
+
+HGC_AdaM(MolD) 0.743 0.509 0.896 0.665 datasets with similar type of data. Here, what we are interested in asking is can we transfer the pre-trained model to the downstream datasets with clearly different type of graphs compared to the ones in the pre-training dataset? To show this, we demonstrate the case from molecular graph to social network graph classification. We pre-train GIN in two different ways: one is pretrained by HGC on two social network graph datasets: SocS_NF and SocL_NF, the other is by HGC, AdaM or HGC_AdaM as well as Context_Pred or S_Context_Pred [15] on the molecular dataset MolD.
+
+376 The results are summarized in Table 5, which offers the following observations: (1). Perhaps   
+377 surprisingly, our methods including HGC and HGC_AdaM enable the models pre-trained on molec  
+378 ular graphs to even outperform those pre-trained on social graphs. For example, the accuracy of   
+379 HGC_AdaM on IMDB-M (0.509) and RDT-M (0.665) is much better than that of HGC(SocS_NF)   
+380 and HGC(SocL_NF). Apart from the universal graph-level properties, the results also inform that   
+381 larger pre-training datasets can help the model learn such inherent properties better. (2). Different pre  
+382 training strategies could deliver different performance. Models pre-trained by graph-level pre-training   
+383 strategies or combined strategies (i.e., HGC(MolD) and HGC_AdaM(MolD)) can always get better   
+384 results than those pre-trained by node-level strategies (i.e., AdaM(MolD) and Context_Pred(MolD)),   
+385 which indicates that graph-level pre-training strategies can help the model learn global graph-level   
+386 properties that can be easily transferred to other domains. (3). We also observe the negative transfer   
+387 brought by the supervised pretraining in some cases. For instance, S_Context_Pred $( { \mathsf { M o l D } } ) ^ { 3 }$ get   
+388 worse performance than its no supervised trained version Context_Pred (MolD) on two datasets:   
+389 RDT-B and RDT-M. It indicates that simple efforts to learn graph-level properties, such as training   
+390 with labeled graphs, is probable to be limited in the certain domain, thus performing bad in such   
+391 cross-domain transfer tasks. Despite this, our HGC and HGC_AdaM still consistently lead to better   
+392 performance compared to other pretraining strategies, which, once again, versifies our assumption   
+393 that our proposed graph contrastive learning strategy can learn more universal, even cross-domain,   
+394 graph-level patterns.
+
+# 395 6 Conclusion
+
+396   
+397   
+398   
+399   
+400   
+401   
+402   
+403   
+404   
+405   
+406   
+407   
+408   
+409
+
+In this work, we focus on developing an effective, efficient and more universal positive instances sampling method that can be applied on many different kinds of graph data for graph instance contrastive learning. We also propose an improvement for a widely used node-level pre-training strategy to adaptively select nodes to mask for an even distribution (AdaM). Moreover, we also discover the potential cross-domain transferring ability for the pre-trained GNN models. However, there are still some limitations in our work: 1). Though high-order graph sampling can get positive instances of better quality than those obtained by first-order sampling in our analysis, it cannot always outperform the model pre-trained by first-order sampling process. We guess that it is relevant with the pre-training dataset. 2). Just combining HGC and AdaM in a simple manner leads to no significant improvement. Though we make no further investigation into a more effective combination method since it is not the keypoint of the paper, it is a meaningful research direction. 3). We discover the potential cross-domain transferring ability for pre-trained GNN models. It is an interesting point but no further discussion is made in this paper. However, further relevant investigation is interesting and meaningful.
+
+410 References [1] Sanjeev Arora, Hrishikesh Khandeparkar, Mikhail Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. arXiv preprint arXiv:1902.09229, 2019. [2] David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. Technical report, Stanford, 2006. [3] Guy W Bemis and Mark A Murcko. The properties of known drugs. 1. molecular frameworks. Journal of medicinal chemistry, 39(15):2887–2893, 1996. [4] Smriti Bhagat, Graham Cormode, and S Muthukrishnan. Node classification in social networks. In Social network data analytics. 2011. [5] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020. [6] 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. [7] Claire Donnat, Marinka Zitnik, David Hallac, and Jure Leskovec. Learning structural node embeddings via diffusion wavelets. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1320–1329, 2018. [8] Greg Landrum et al. Rdkit: Open-source cheminformatics. 2006. [9] Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019. [10] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017. [11] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864, 2016. [12] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017. [13] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive multi-view representation learning on graphs. In International Conference on Machine Learning, pages 4116–4126. PMLR, 2020. [14] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020. [15] 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. [16] Max Jaderberg, Valentin Dalibard, Simon Osindero, Wojciech M Czarnecki, Jeff Donahue, Ali Razavi, Oriol Vinyals, Tim Green, Iain Dunning, Karen Simonyan, et al. Population based training of neural networks. arXiv preprint arXiv:1711.09846, 2017. [17] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [18] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+[19] Christopher Morris, Nils M. Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann. Tudataset: A collection of benchmark datasets for learning with graphs. In ICML 2020 Workshop on Graph Representation Learning and Beyond (GRL+ 2020), 2020. URL www.graphlearning.io.   
+[20] Annamalai Narayanan, Mahinthan Chandramohan, Rajasekar Venkatesan, Lihui Chen, Yang Liu, and Shantanu Jaiswal. graph2vec: Learning distributed representations of graphs. arXiv preprint arXiv:1707.05005, 2017.   
+[21] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   
+[22] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710, 2014.   
+[23] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Kuansan Wang, and Jie Tang. Network embedding as matrix factorization: Unifying deepwalk, line, pte, and node2vec. In Proceedings of the eleventh ACM international conference on web search and data mining, pages 459–467, 2018.   
+[24] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Chi Wang, Kuansan Wang, and Jie Tang. Netsmf: Large-scale network embedding as sparse matrix factorization. In The World Wide Web Conference, pages 1509–1520, 2019.   
+[25] Jiezhong Qiu, Qibin Chen, Yuxiao Dong, Jing Zhang, Hongxia Yang, Ming Ding, Kuansan Wang, and Jie Tang. Gcc: Graph contrastive coding for graph neural network pre-training. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1150–1160, 2020.   
+[26] Leonardo FR Ribeiro, Pedro HP Saverese, and Daniel R Figueiredo. struc2vec: Learning node representations from structural identity. In Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining, pages 385–394, 2017.   
+[27] David Rogers and Mathew Hahn. Extended-connectivity fingerprints. Journal of chemical information and modeling, 50(5):742–754, 2010.   
+[28] Yu Rong, Yatao Bian, Tingyang Xu, Weiyang Xie, Ying Wei, Wenbing Huang, and Junzhou Huang. Grover: Self-supervised message passing transformer on large-scale molecular data. arXiv preprint arXiv:2007.02835, 2020.   
+[29] Nino Shervashidze, Pascal Schweitzer, Erik Jan Van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(9), 2011.   
+[30] Teague Sterling and John J Irwin. Zinc 15–ligand discovery for everyone. Journal of chemical information and modeling, 55(11):2324–2337, 2015.   
+[31] Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semi-supervised graph-level representation learning via mutual information maximization. arXiv preprint arXiv:1908.01000, 2019.   
+[32] Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Largescale information network embedding. In Proceedings of the 24th international conference on world wide web, pages 1067–1077, 2015.   
+[33] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+[34] Petar Velickovic, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In ICLR (Poster), 2019.   
+[35] Minjie Wang, Lingfan Yu, Da Zheng, Quan Gan, Yu Gai, Zihao Ye, Mufei Li, Jinjing Zhou, Qi Huang, Chao Ma, et al. Deep graph library: Towards efficient and scalable deep learning on graphs. 2019.
+
+504 [36] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma,   
+505 Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang.   
+506 Deep graph library: A graph-centric, highly-performant package for graph neural networks.   
+507 arXiv preprint arXiv:1909.01315, 2019.   
+508 [37] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S   
+509 Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine   
+510 learning. Chemical science, 9(2):513–530, 2018.   
+511 [38] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural   
+512 networks? arXiv preprint arXiv:1810.00826, 2018.   
+513 [39] Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM   
+514 SIGKDD international conference on knowledge discovery and data mining, pages 1365–1374,   
+515 2015.   
+516 [40] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen.   
+517 Graph contrastive learning with augmentations. Advances in Neural Information Processing   
+518 Systems, 33, 2020.   
+519 [41] Fanjin Zhang, Xiao Liu, Jie Tang, Yuxiao Dong, Peiran Yao, Jie Zhang, Xiaotao Gu, Yan Wang,   
+520 Bin Shao, Rui Li, et al. Oag: Toward linking large-scale heterogeneous entity graphs. In   
+521 Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery &   
+522 Data Mining, pages 2585–2595, 2019.   
+523 [42] Jie Zhang, Yuxiao Dong, Yan Wang, Jie Tang, and Ming Ding. Prone: Fast and scalable network   
+524 representation learning. In IJCAI, volume 19, pages 4278–4284, 2019.   
+525 [43] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning   
+526 architecture for graph classification. In Proceedings of the AAAI Conference on Artificial   
+527 Intelligence, volume 32, 2018.   
+528 [44] Shenghuo Zhu, Kai Yu, Yun Chi, and Yihong Gong. Combining content and link for classifica  
+529 tion using matrix factorization. In SIGIR, 2007.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The main contribution of this paper is the proposal of an effective and more universal positive instance selection strategy that can be applied on various kinds of graph data in the contrastive learning process. We also propose an improvement of the a widely used node-level pre-training strategy to adaptively choose nodes to make them distributed evenly in the graph. Moreover, we discover the potential possibility of the cross-domain transferable ability of the pre-trained GNN models.   
+(b) Did you describe the limitations of your work? [Yes] See Sec. 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Sec. C.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Sec. A.7. We make reasonable assumptions on the possibility density function of the approximate similarity function on the ground-truth positive graph set and negative graph set. Some reasonable approximations are made in the derivation process.   
+(b) Did you include complete proofs of all theoretical results? [Yes] See Sec. A.7.
+
+3. If you ran experiments...
+
+(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)? [Yes] See Sec. A.1 for descriptions and download links for datasets. Download links for our pre-processed data are shared along with the code. Code is provided with supplemental material. Instructions for reproduction are stated in README.md file in the supplemental material.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Sec. A.2 for implementation details, including pre-training and fine-tuning configuration and hyper-parameter selection. See Sec. A.1 for descriptions for datasets and the splitting methods.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We report mean and std values for 3 independently random initialized run for each evaluation process on molecular graph datasets. See Table 1 and Table 12 for details.   
+(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] See Sec. A.2 for hardware configurations.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you citep the creators? [Yes] We provide links for data and code that are from public respiratory we used in our project. We also cite related papers. See Sec. A.1 and Sec. A.3.   
+(b) Did you mention the license of the assets? [Yes] Datasets obtained from published works are with related papers cited. See Sec. A.1   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new datasets are proposed.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] Download links for public datasets we used are provided. Datasets obtained from published works are with related papers cited. See Sec. A.1   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] Datasets we use are obtained from public datasets, containing no such information. We provide links for them in Sec. A.1. .
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+583 (a) Did you include the full text of instructions given to participants and screenshots, if   
+584 applicable? [N/A]   
+585 (b) Did you describe any potential participant risks, with links to Institutional Review   
+586 Board (IRB) approvals, if applicable? [N/A]   
+587 (c) Did you include the estimated hourly wage paid to participants and the total amount   
+588 spent on participant compensation? [N/A]

parse/train/MRYuRHsHzK4/MRYuRHsHzK4_content_list.json

@@ -0,0 +1,1237 @@
+[
+    {
+        "type": "text",
+        "text": "Similarity-aware Positive Instance Sampling for Graph Contrastive Pre-training ",
+        "text_level": 1,
+        "bbox": [
+            210,
+            122,
+            787,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph instance contrastive learning has been proved as an effective task for Graph Neural Network (GNN) pre-training. However, one key issue may seriously impede the representative power in existing works: Positive instances created by current methods often miss crucial information of graphs or even yield illegal instances (such as non-chemically-aware graphs in molecular generation). To remedy this issue, we propose to select positive graph instances directly from existing graphs in the training set, which ultimately maintains the legality and similarity to the target graphs. Our selection is based on certain domain-specific pair-wise similarity measurements as well as sampling from a hierarchical graph encoding similarity relations among graphs. Besides, we develop an adaptive node-level pre-training method to dynamically mask nodes to distribute them evenly in the graph. We conduct extensive experiments on 13 graph classification and node classification benchmark datasets from various domains. The results demonstrate that the GNN models pre-trained by our strategies can outperform those trained-from-scratch models as well as the variants obtained by existing methods. ",
+        "bbox": [
+            148,
+            349,
+            766,
+            558
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            584,
+            312,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 Pre-training on graph data has received wide interests in recent years, with a large range of insightful   \n18 works focused on learning universal graph structural patterns lying in different kinds of graph   \n19 data [25, 15, 40, 28]. For instance, Hu et al. [15] pre-train graph neural networks on molecules   \n20 and transfer the learned model to molecular graph classification tasks, while Qiu et al. [25] pioneer   \n21 pre-training on big graphs. Compared with traditional semi-supervised or supervised training methods   \n22 for graph neural networks [12, 18, 38, 10, 33], pre-training tasks formulate the training objective   \n23 without the access of training labels, and they empower graph neural networks to be generalized to   \n24 unseen graphs or nodes with no or minor fine-tuning training cost. How to define proper pre-training   \n25 tasks comes as the principal and also the most challenging part in graph self-supervised learning.   \n26 Among current works, graph instance contrastive learning based pre-training tasks have been proved   \n27 effective to learn graph strcutrual information [25, 40]. It preforms contrast between positive/negative   \n28 instance pairs extracted from real graphs observed in the dataset. Though positive pairs for graph   \n29 contrastive learning seems easy to define for those tasks not performed on graph instances, like   \n30 DeepWalk [22], node2vec [11], where near node-node pairs are treated as positive pairs and Infomax   \n31 based models like DGI [34], InfoGraph [31], where node-graph pairs from a same graph are treated   \n32 as positive pairs, it is not the case for graph instance contrastive learning. Attempts from previous   \n33 literature mainly focus on devising suitable graph augmentation methods, such as graph sampling [25,   \n34 40], node dropping [40], edge perturbation [40], and diffusion graph [13] to get positive graph   \n35 instances from the original graph. Despite the achievements they have made using such graph data   \n36 augmentation strategies, we assume that such perturbation based graph data augmentation methods   \n37 are not universal strategies to get ideal positive samples preserving necessary information for graph   \n38 contrastive learning for various kinds of graph data such as molecular graphs, social graphs, and   \n39 academic graphs.   \n40 We make our assumptions on the necessary in  \n41 formation that should be preserved in positive in  \n42 stances in the contrastive learning process, which   \n43 though have not been proved theoretically, are rea  \n44 sonable and are arrived from the re-thinking of the   \n45 purpose and inherent principle of the contrastive   \n46 learning and what should positive samples pre  \n47 serve to get an effective method. Such unproved   \n48 but reasonable assumptions for positive instances   \n49 are as follows: ",
+        "bbox": [
+            147,
+            617,
+            825,
+            741
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            747,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            140,
+            498,
+            277
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Positive instances should be semantically similar with the target instance; • Positive samples for the same target instance should also be similar with each other; • Positive instances should preserve certain domain information if necessary. ",
+        "bbox": [
+            181,
+            284,
+            498,
+            367
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/13d38801a2f1f29601d38a7afe3b2605083fea5c809ac5c60539b3f80d673180.jpg",
+        "image_caption": [
+            "Figure 1: The fingerprint similarity scores (in orange) and percent of legal molecular outputs (in blue) generated by graph data augmentation strategies: dropping nodes and dropping edges from a same molecule w.r.t. the ratio of nodes / edges being dropped on 1000 molecular graphs. The fingerprint similarity and the percent of legal molecular outputs decreased dramatically even for the small proportion of nod/edge dropping. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            516,
+            140,
+            820,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "56 Based on such assumptions, we can see that some widely used graph data augmentation strategies   \n57 cannot always get positive instances with such properties preserved when being applied on different   \n58 kinds of graph data. As shown in Fig. 1, simple edge-perturbation or node-dropping for molecular   \n59 graph contrastive learning strategies can hardly get legal graph instances given the fact that molecules   \n60 are specifically formulated in accordance to strict chemical constraints which will be easily broken if   \n61 some edges/nodes, even of a very small number, are perturbed. Moreover, subgraph sampling strategy,   \n62 though effective when applied on graphs without node/edge attributes, may always lead to positive   \n63 instances that are dissimilar with the target instance when applied on molecular graphs. Statistical   \n64 results for subgraph sampling and another data augmentation strategy suffering from similar problems   \n65 – attribute masking, are presented in Appendix A.5.1.   \n66 Thus, in this paper, we move beyond the widely used graph data augmentation strategies for an   \n67 effective and more universal method to get positive graph instances for graph instance contrastive   \n68 learning. We propose a simple but effective similarity based positive instances sampling strategy that   \n69 can be applied on various kinds of graph data. Unlike previous methods that construct contrastive   \n70 pairs by graph augmentation, our method encodes the pair-wise similarity information, measured by   \n71 certain domain-specific similarity/proximity, into a hierarchical structure and selects positive graph   \n72 instances from such a structure which ultimately maintains the legality of the sampled instances   \n73 and high similarity to the target graphs (see Appendix C for details). Moreover, we also propose   \n74 an improvement for a widely-used node-level pre-training strategy [15], which, together with our   \n75 similarity aware graph positive sampling strategy, brings us an upper strategy design philosophy. That   \n76 is, the necessary of introducing prior knowledge or bias in random strategies.   \n77 We conduct extensive experiments on three representative kinds of graph data: molecular graphs,   \n78 social graphs as well as big social and academic graphs where nodes are of interest to demonstrate the   \n79 effectiveness and superiority of our proposed sampling based strategy over previous graph contrastive   \n80 learning strategies and also some other strategies not based on contrastive learning for different   \n81 kinds of graph data. Besides, some additional experiments which try to transfer the GNN models   \n82 pre-trained on molecular graph dataset to downstream social graph classification task let us have   \n83 a glimpse of the potential possibility of the pre-trained models’ ability to capture universal graph   \n84 structural information underlying different kinds of graph data as well as the possibility to get such   \n85 a universally transferable pre-trained model. Similar things have been explored in other domains   \n86 such as multi-lingual language models. However, to our best knowledge, we are the first to propose   \n87 such possibility for pre-trained GNN models, which, though lacks further and thorough exploration   \n88 in the paper, can probably point out a new possibly meaningful research direction and cast light on   \n89 successive work.   \n91 Graph Representation Learning. How to generate expressive representation vectors for nodes or   \n92 graphs that can capture both node-level information, like node attributes and node proximities [32,   \n93 22, 11], as well as graph-level information, like structural proximity between nodes [26] and graph   \n94 property [10], is a vital question and has aroused great interests from graph learning community.   \n95 Common approaches include unsupervised manners [22, 11, 32, 31, 34, 42, 24, 23], which always   \n96 adopt a shallow architecture, semi-supervised and supervised approaches [33, 18, 12, 10, 38], which   \n97 always leverage expressive graph neural networks to capture critical information from both graph   \n98 structure and node/edge attributes. In this work, we adopt graph neural networks as our graph encoder   \n99 to generate expressive representations for nodes or graphs.   \n100 Contrastive Learning. Contrastive learning has proved its efficiency to learn highly expressive   \n101 representations in Computer Vision domain [5, 14]. Moreover, contrastive learning has also been   \n102 used in graph learning for a long time, like doing contrast between node-node pairs [22, 11] to   \n103 encode various node proximities into node representations. Recently, there are also efforts focusing   \n104 on using contrastive learning on graph instances to learn instance-level representations that can be   \n105 aware of critical graph structural information [25, 40]. In this work, we also focus on graph instance   \n106 contrastive learning, but turn to approach this problem in a new manner.   \n107 Graph Pre-training. Pre-trained models have proved their highly transferable ability when being   \n108 applied on downstream datasets in other domains, such as the language models [6] in NLP domain.   \n109 Famous pre-training strategies for GNNs on graph data largely fall into two genres: node-level and   \n110 graph-level strategies. Node-level strategies aim to design proper tasks that can help GNNs learn   \n111 node/edge attribute distribution information [15, 28]. More universally, graph-level strategies try to   \n112 learn design tasks that can learn structural information for both nodes and graphs [25, 40]. In this   \n113 work, we aim to design more powerful pre-training strategies for graph data from both graph-level   \n114 and node-level. ",
+        "bbox": [
+            145,
+            375,
+            825,
+            512
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            518,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            678,
+            825,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            125,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            262,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            372,
+            825,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "115 3 Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            501,
+            305,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "116 We denote an attributed graph as $G ( \\nu , \\mathcal { E } , \\mathcal { X } )$ , where $| \\nu | = n$ refers to a set of $n$ nodes and $| { \\mathcal { E } } | = m$   \n117 refers to a set of $m$ edges. We denote $\\pmb { x } _ { v } \\in \\mathbb { R } ^ { d }$ as the initial feature of node $v$ and $e _ { u v }$ as the initial   \n118 feature of edge $( u , v )$ .   \n119 Graph Neural Networks (GNNs) can be modeled as the a messaging passing process, which involves   \n120 neighborhood aggregation among nodes in graph and message updating to the next layer. Namely,   \n121 the general message passing process is defined as: ",
+        "bbox": [
+            142,
+            531,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            580,
+            826,
+            623
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8bf15fe02c6fe1c02c765fc43f69e8fe8c03ab76cf52e74ddc4663423e9dac6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\pmb { m } _ { v } ^ { ( l + 1 ) } = \\mathrm { A G G R E G A T E } ( \\{ ( \\pmb { h } _ { v } ^ { ( l ) } , \\pmb { h } _ { u } ^ { ( l ) } , \\pmb { e } _ { u v } ) | u \\in \\mathcal { N } _ { v } \\} ) , } \\\\ & { \\quad \\pmb { h } _ { v } ^ { l + 1 } = \\sigma ( \\pmb { W } ^ { ( l ) } \\pmb { m } _ { v } ^ { ( l + 1 ) } + \\pmb { b } ^ { ( l ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            623,
+            678,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "122 where $h _ { v } ^ { l + 1 }$ refers to the hidden state of $v$ at $( l + 1 )$ -th layer with $\\pmb { h } _ { v } ^ { ( 0 ) } = \\pmb { x } _ { v }$ and $m _ { v } ^ { ( l + 1 ) }$ refers   \n123 to the aggregated message of $v$ at $( l + 1 )$ -th layer. $\\mathcal { N } _ { v }$ denotes the neighbor node set of node $v$ .   \n124 AGGREGATE $( \\cdot )$ aggregates the hidden states of $v$ ’s neighbor nodes and edges, such as mean/max   \n125 pooling and graph attention[38, 33]. are the trainable parameters. If the m $\\sigma ( \\cdot )$ $\\mathcal { M } _ { L }$ e activaticontains $L$ function, such aslayers, the outpu $\\mathrm { R e L U } ( \\cdot )$ . a $W ^ { ( l ) }$ $\\{ h _ { v } ^ { ( L ) } \\} _ { v \\in v }$ $\\mathbf { \\delta } _ { b } ( l )$   \n127 usually represents the node-level embeddings of input graph. Moreover, the graph-level embedding   \n128 $_ { h _ { G } }$ is derived by simply applying a READOUT function as ",
+        "bbox": [
+            140,
+            667,
+            826,
+            772
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/917c23506866b0f7bd2f0c4cf1bbac2fe04f4837eb76bb6a8e94f4489d80a37b.jpg",
+        "text": "$$\n\\pmb { h } _ { G } = \\mathrm { R E A D O U T } \\big ( \\{ \\pmb { h } _ { v } ^ { ( L ) } \\} _ { v \\in \\mathcal { N } _ { v } } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            773,
+            607,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "129 Representations generated by GNNs over graphs, including node-level and graph-level representa  \n130 tions, are meaningful embeddings to perform various downstream graph learning tasks, like node   \n131 classification [44, 4], graph classification [31, 15, 28], and so on. ",
+        "bbox": [
+            142,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "32 4 Similarity-aware Positive Graph Instance Sampling ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            852,
+            637,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "133 In this section, we propose our similarity-aware hierarchical graph positive instance sampling method   \n134 to sample positive graph instances with three kinds of information mentioned in Sec. 1 preserved. We   \n135 first explain our motivation w.r.t. why we turn to other graph instances in the pre-training dataset   \n136 for positive instances and why it may work for graph data. Then we propose our sampling strategies   \n137 as well as two versions of the sampling process. We also give some further discussions for such   \n138 two sampling strategies. Moreover, we also propose an improvement of the widely used node-level   \n139 pre-training strategy, which is an additional contribution of our work. ",
+        "bbox": [
+            143,
+            882,
+            828,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d52af2eb5d0619a23ae71785a516350e228e907f893e181d09ec1458754f970.jpg",
+        "image_caption": [
+            "Figure 2: Illustration of the hierarchical graph instance sampling process for the molecular graphs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            826,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            226,
+            825,
+            295
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "140 4.1 Motivation: Sampling or Constructing? ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            310,
+            490,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "141 As discussed in Sec. 1, it is hard to design a clean and elegant data augmentation strategy universally   \n142 for various kinds of graph data to get positive instances that are similar enough with the target graph   \n143 instance and can also preserve necessary domain specific information. Since what we care about   \n144 for positive graph instances are their similarity with the target graph instance, rather than the way   \n145 to obtaining them, we move beyond popular graph data augmentation skills and propose to sample   \n146 positive instances from the pre-training dataset for the target graph instance. Specifically, we propose   \n147 to use approximate similarity functions that can reveal the semantic similarity between two graph   \n148 instances to some extend to estimate the semantic similarity scores between two graph instances. The   \n149 similarity relations between each pair of graphs are then encoded into a similarity hierarchy, which is   \n150 then used for positive instance sampling. We also make some further discussions for the proposed   \n151 similarity-aware sampling process, which may inspire future design for other sampling strategies. ",
+        "bbox": [
+            140,
+            337,
+            825,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "152 4.2 Similarity-aware Positive Graph Instance Sampling ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            505,
+            573,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "153 Following [1], we assume that each graph instance $G _ { i } \\in \\mathcal G$ has its semantic class clas $\\mathbf { s } ( G _ { i } ) = c _ { i }$   \n154 Thus, the optimal positive sampling strategy should choose graph instances of the same semantic   \n155 class with the graph instance $G _ { i }$ as its positive instances. Formally, the rate for sampling graph $G _ { j }$ as   \n156 the positive instance of $G _ { i }$ is: ",
+        "bbox": [
+            142,
+            530,
+            825,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d57d2b5121d6234a2876fbecc19155bd678c9bb373bf2263bb63015af69ed743.jpg",
+        "text": "$$\nP _ { i } ^ { + } ( G _ { j } ) = { \\left\\{ \\begin{array} { l l } { { \\frac { 1 } { | \\mathcal { G } _ { i } ^ { + } | } } } & { { \\mathrm { I f } } \\mathrm { c l a s s } ( G _ { i } ) = \\mathrm { c l a s s } ( G _ { j } ) , } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            592,
+            648,
+            635
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "157 where $\\mathcal { G } _ { i } ^ { + } = \\{ G _ { k } | G _ { k } \\in \\mathcal { G } , \\operatorname { c l a s s } ( G _ { k } ) = \\operatorname { c l a s s } ( G _ { i } ) \\}$ is the set of graph instances of the same class   \n158 with graph instance $G _ { i }$ . We can then assume that there exists a ground-truth semantic similarity   \n159 function $\\mathrm { s i m } _ { \\mathrm { g t } } ( \\cdot , \\cdot )$ which reveals whether two graph instances belong to a same semantic class   \n160 accurately: ",
+        "bbox": [
+            140,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd8110f5203f8b28a1a5d2e9e8ed972b4e3b6e5fdd3ff3b13e4aeb3f1030e240.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { s i m } _ { \\mathrm { g t } } ( G _ { i } , G _ { j } ) = \\left\\{ \\begin{array} { l l } { 1 } & { \\mathrm { I f } \\mathrm { c l a s s } ( G _ { i } ) = \\mathrm { c l a s s } ( G _ { j } ) , } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            696,
+            653,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "161 However, we have no knowledge of the such ground-truth semantic similarity function since our   \n162 pre-training graph datasets are always unlabeled. Thus we propose to use approximate similarity   \n163 functions that can be obtained from the real-world and applied in practice easily to estimate the   \n164 similarity between two graph instances. We can make some assumptions for the chosen approximate   \n165 similarity functions to ensure their good quality, which are deferred to Appendix B.1. ",
+        "bbox": [
+            142,
+            741,
+            825,
+            811
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we choose a similarity score function $\\sin ( \\cdot , \\cdot )$ to estimate the semantic similarity between two graphs. To further use the similarity measurement to perform flexible positive sampling, we propose a two-step approach1 to encode pair-wise similarity into a more abstract and structural hierarchy efficiently – a similarity-based hierarchical graph ${ \\mathcal { H } } ( { \\mathcal { G } } , { \\mathcal { E } } _ { H } )$ , where $\\mathcal { G }$ is the set of graphs in our pre-training dataset, ${ \\mathcal { E } } _ { H }$ is the edge set. Formally, we introduce a similarity threshold $\\tau ( 0 < \\tau <$ ",
+        "bbox": [
+            171,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "171 1), and based on which the edge set is defined as: $\\mathcal { E } _ { H } = \\{ ( G _ { i } , G _ { j } ) | \\mathrm { s i m } ( G _ { i } , G _ { j } ) \\geq \\tau , G _ { i } \\in \\mathcal { G } , G _ { j } \\in$   \n172 $\\dot { \\mathcal { G } } \\rbrace$ . Many similarity functions are good candidates for $\\sin ( \\cdot , \\cdot )$ such as fingerprint similarity [27] for   \n173 molecular graphs, Weisfeiler-Lehman Graph Kernel [29] normalized similarity for graphs without   \n174 node/edge attributes and node proximity for nodes in a big graph.   \n175 The constructed hierarchical graph, which encodes more information beyond pair-wise similarity2,   \n176 can be used to design flexible sampling strategies for positive graph instance selection. We propose   \n177 two sampling strategies: ",
+        "bbox": [
+            142,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            154,
+            826,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• First-order neighbourhood sampling. For each graph $G _ { i }$ , sample a one-hop neighbour set of a fixed size as its positive instances. • High-order graph sampling. We perform $l$ -hops random walks starting from graph $G _ { i }$ for $k$ times and choose positive instances according to their appearance frequencies. ",
+        "bbox": [
+            183,
+            200,
+            825,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An illustration for HGC is presented in Fig. 2. We will give some further discussions w.r.t. why we use similarity for positive instance sampling and how would high-order sampling potentially benefit the sampling process and the resulting positive instances in the next section. ",
+        "bbox": [
+            161,
+            263,
+            826,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "185 4.3 Further Discussion for Similarity-aware Sampling Strategy ",
+        "text_level": 1,
+        "bbox": [
+            151,
+            321,
+            624,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "86 In this section, we want to answer two questions: Q1: Why we still sample positive instances based on   \n7 approximate pair-wise similarity scores, though it may not be an accurate similarity estimation? Q2:   \n88 How would high-order sampling potentially benefit the sampling process and the resulting positive   \n89 instances? Moreover, we also propose some further discussions for the proposed similarity-aware   \n90 positive instance sampling strategy. ",
+        "bbox": [
+            155,
+            348,
+            826,
+            419
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To begin with, we propose a property of the contrastive learning that is intuitively correct: ",
+        "bbox": [
+            163,
+            424,
+            759,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Property 1. Avoiding false-positives is important in the contrastive learning process. ",
+        "bbox": [
+            165,
+            444,
+            733,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, “false-positives” denotes positive instances selected by a non-optimal positive sampling strategy whose semantic classes are not same with the target graph instance. We explain why such a property holds in Appendix B.2 in detail, though it should be correct intuitively. ",
+        "bbox": [
+            161,
+            469,
+            825,
+            512
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Then, Q1 can be answered by proposing the following property of the positive instances sampled according to their similarity scores with the target graph instance: ",
+        "bbox": [
+            158,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Property 2. If the similarity threshold $\\tau$ is changing in a proper range, an instance that has a high similarity score with the target instance will also has a high probability to be a ground-truth positive instance. ",
+        "bbox": [
+            169,
+            551,
+            823,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We would explain why this property holds in detail in Appendix B.3, based on our assumptions on 02 good properties of the approximate similarity function (Def. 2). Thus, the answer for Q1 could be: 03 sampling positive instances according to their similarity scores with the target graph instance may 04 help avoid sampling false-positives. ",
+        "bbox": [
+            151,
+            604,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To answer Q2, we first propose one limitation of the first-order similarity sampling strategy by pointing out a crucial property of the ground-truth similarity function that the approximate similarity functions always fail to preserve – the transitivity of the ground-truth similarity function: ",
+        "bbox": [
+            169,
+            666,
+            823,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Property 3 (Transitivity of the ground-truth similarity function). Ground-truth similarity function is transitive: $i f s i m _ { g t } ( G _ { i } , G _ { j } ) = 1$ and $s i m _ { g t } ( G _ { i } , G _ { k } ) = 1$ , then $s i m _ { g t } ( G _ { j } , G _ { k } ) = 1$ . ",
+        "bbox": [
+            166,
+            713,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Such transitivity of the ground-truth similarity function ensures the transitivity of the relations between nodes in the hierarchical graph constructed based on the ground-truth similarity measurement. However, it is obvious that relations between nodes in our constructed similarity-based hierarchical graph – represented by edges, are not fully-transitive. It is because that the approximate similarity function we use in practice is not an optimal one. ",
+        "bbox": [
+            161,
+            752,
+            825,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "215 We introduce the definition of connectivity and connectivity order between nodes in the graph in   \n216 Appendix B.4. The transitivity of the ground-truth similarity function ensures that $G _ { i }$ ’s positive   \n217 instances sampled by first-order neighbourhood sampling strategy can have connectivity orders with   \n218 $G _ { i }$ ranging from 1 to $| \\mathcal { G } _ { i } ^ { + } | - 1$ . It is hard for first-order sampling strategy applied on the hierarchical   \n219 graph constructed in practice to get positive instances that also have high-order connectivity (e.g.,   \n220 second-order connectivity) with the target graph instance. The reason is that first-order information   \n221 cannot reveal high-order information (e.g., high-order connectivity with the target graph instance)   \n222 in the constructed hierarchical graph, while it can fully reveal higher-order connectivity in the   \n223 constructed hierarchical graph based on ground-truth similarity function (i.e., if a graph instance $G _ { j }$   \n224 is 1-connected to $G _ { i }$ , then it is $2 , 3 , . . . , | \\mathcal { G } _ { i } ^ { + } | - 1$ connected to $G _ { i }$ as well).   \n25 We can prove that first-order neighbouring positive instances sampled by second-order sampling   \n26 process are more likely to be connected with each other (see Appendix B.4 for details). This can   \n7 remedy the limitation of the first-order sampling strategy, which cannot guarantee the similarity   \n8 between positive instances. Moreover, it can be empirically verified that positive instances that are   \n9 both first-order and second-order connected to the target instance are also more similar with the target   \n0 instance. More details are deferred to Appendix B.4. We also expect that higher-order sampling   \nprocess can bring more benefit to the resulting positive instances and worth trying in practice. ",
+        "bbox": [
+            142,
+            829,
+            825,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            825,
+            178
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            183,
+            825,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Additionally, we propose further discussions w.r.t. how would the changing similarity threshold $\\tau$ influence the balance between the increasing sampling rate estimation accuracy for ground-truth positive instances and the risk of sampling more false-positive instances. Detailed discussions are deferred to Appendix B.5. ",
+        "bbox": [
+            169,
+            286,
+            825,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.4 Adaptive Masking for Node-level Pre-training ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            358,
+            531,
+            373
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose our improvement of the widely used attribute masking node-level pretraining strategy: Adaptive Masking, which is designed for attributed graphs only. As introduced in [15], attribute masking task, which is inspired from “masked language model” (MLM) in NLP, helps the model learn node/edge attribute distribution across the graph. Formally, attribute masking task is defined as: ",
+        "bbox": [
+            176,
+            383,
+            825,
+            453
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. (Attribute masking task): Given an attributed graph $G ( \\nu , \\mathcal { E } , \\mathcal { X } )$ , a target node $v \\in \\mathcal V$ and its corresponding feature vector $\\mathbf { \\boldsymbol { x } } _ { v }$ , attribute masking task is first to mask a subset of the features ${ \\pmb x } _ { s u b } \\subseteq { \\pmb x } _ { v }$ in feature vector $\\scriptstyle { \\mathbf { { \\mathit { x } } } } _ { \\mathit { v } }$ and produce a new feature vector $\\pmb { x } _ { v } ^ { \\prime }$ for node $v$ . Then let a model $\\mathcal { M }$ to make the prediction of the masked feature set $\\mathbf { \\mathcal { x } } _ { s u b }$ given the new feature vector $\\pmb { x } _ { v } ^ { \\prime }$ as input. ",
+        "bbox": [
+            174,
+            457,
+            823,
+            513
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hu et al. [15] follows the same protocol in MLM by uniformly selecting the nodes set from graphs to construct the attribute mask task. But, we argue that the uniform selection may break structural relations among nodes in graphs so that the model may miss critical information for node attribute distribution from such relations. We introduce a toy example in the Appendix A.4.2. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inspired by $\\mathrm { K m e a n } \\substack { + \\mathrm { + } [ 2 ] }$ , which aims to obtain the good initial centroids with widely separated in space, we also adopt the adaptive masking (AdaM) to generate the mask node set within less correlations. In particular, we divide the masking process into $T$ steps. At the first step, we uniformly sample a small mask set. Secondly, the masking weight of each candidate node is adaptive by function PScore. The detail of PScore is demonstrate in Algorithm 2 (see Appendix A.4.2). In PScore, for the candidate node $v$ , we calculate the similarity of model output between before and after masking. High similarity indicates that node $v$ is not influenced by the mask operation at the current step, resulting in the low correlation between node $v$ and current mask set $S _ { \\mathrm { c u r } }$ . Finally, we randomly sample a node set $\\kappa$ with the probability constructed by masking weight. The algorithmic details are provided in the supplementary material. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            724
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "According to the adaptive masking operation, we can dynamically adjust the importance of nodes during training and obtain a more representative mask node set for the attribute masking task. Such intuition is further discussed in Appendix A.7. ",
+        "bbox": [
+            174,
+            732,
+            823,
+            773
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            792,
+            312,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Experimental Configuration ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            824,
+            410,
+            838
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Pretraining Data Collection. We conduct the pretraining on four datasets from various domains: 1). academic and purchasing graphs: we collect four data sources from Deep Graph Library [36] and merge them into one pretraining dataset dubbed AP_NF. 2). social graphs: we construct two pretraining datasets termed SocS_NF and SocL_NF. SocS_NF contains five data sources, while ",
+        "bbox": [
+            173,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/75af0c99b9c58f7faf42177cc32ab61148c8af2233eb3fa767ffea0a313cae06.jpg",
+        "table_caption": [
+            "Table 1: Experimental results (ROC-AUC) on molecular datasets. The numbers in brackets are standard deviations. Numbers in gray are the best results achieved by backbone models. Bold numbers represent the best results by different backbones. Bold numbers in green represent the best results over all backbones. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Backbone   Strategy</td><td rowspan=1 colspan=1>SIDER</td><td rowspan=1 colspan=1>ClinTox</td><td rowspan=1 colspan=1>BACE</td><td rowspan=1 colspan=1>HIV</td><td rowspan=1 colspan=1>BBBP</td><td rowspan=1 colspan=1>Tox21</td><td rowspan=1 colspan=1>ToxCast</td></tr><tr><td rowspan=1 colspan=2>#Molecules</td><td rowspan=1 colspan=1>1427</td><td rowspan=1 colspan=1>1478</td><td rowspan=1 colspan=1>1513</td><td rowspan=1 colspan=1>41127</td><td rowspan=1 colspan=1>2039</td><td rowspan=1 colspan=1>7831</td><td rowspan=1 colspan=1>8575</td></tr><tr><td rowspan=1 colspan=2>#Prediction tasks</td><td rowspan=1 colspan=1>27</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>617</td></tr><tr><td rowspan=8 colspan=1>GIN</td><td rowspan=1 colspan=1>GraphCL</td><td rowspan=1 colspan=1>0.5946(0.0055)</td><td rowspan=1 colspan=1>0.6592(0.0074)</td><td rowspan=1 colspan=1>0.7713(0.0057)</td><td rowspan=1 colspan=1>0.7754(0.0093)</td><td rowspan=1 colspan=1>0.7050(0.0012)</td><td rowspan=1 colspan=1>0.7562(0.0024)</td><td rowspan=1 colspan=1>0.6289(0.0023)</td></tr><tr><td rowspan=1 colspan=1>C_Subgraph</td><td rowspan=1 colspan=1>0.5838(0.0022)</td><td rowspan=1 colspan=1>0.6390(0.0071)</td><td rowspan=1 colspan=1>0.7736(0.0140)</td><td rowspan=1 colspan=1>0.7341(0.0079)</td><td rowspan=1 colspan=1>0.6901(0.0026)</td><td rowspan=1 colspan=1>0.7521(0.0044)</td><td rowspan=1 colspan=1>0.6263(0.0061)</td></tr><tr><td rowspan=1 colspan=1>Infomax</td><td rowspan=1 colspan=1>0.5755(0.0024)</td><td rowspan=1 colspan=1>0.6944(0.0187)</td><td rowspan=1 colspan=1>0.7571(0.0094)</td><td rowspan=1 colspan=1>0.7653(0.0040)</td><td rowspan=1 colspan=1>0.6929(0.0054)</td><td rowspan=1 colspan=1>0.7674(0.0020)</td><td rowspan=1 colspan=1>0.6302(0.0007)</td></tr><tr><td rowspan=1 colspan=1>Attr_Mask</td><td rowspan=1 colspan=1>0.5947(0.0083)</td><td rowspan=1 colspan=1>0.6685(0.0093)</td><td rowspan=1 colspan=1>0.8064(0.0042)</td><td rowspan=1 colspan=1>0.7668(0.0106)</td><td rowspan=1 colspan=1>0.6316(0.0007)</td><td rowspan=1 colspan=1>0.7657(0.0054)</td><td rowspan=1 colspan=1>0.6463(0.0029)</td></tr><tr><td rowspan=1 colspan=1>Context_Pred</td><td rowspan=1 colspan=1>0.6132(0.0050)</td><td rowspan=1 colspan=1>0.6476(0.0168)</td><td rowspan=1 colspan=1>0.8055(0.0115)</td><td rowspan=1 colspan=1>0.7807(0.0054)</td><td rowspan=1 colspan=1>0.7026(0.0097)</td><td rowspan=1 colspan=1>0.7715(0.0022)</td><td rowspan=1 colspan=1>0.6427(0.0024)</td></tr><tr><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6333(0.0121)</td><td rowspan=1 colspan=1>0.8134(0.0115)</td><td rowspan=1 colspan=1>0.8442(0.0138)</td><td rowspan=1 colspan=1>0.7853(0.0072)</td><td rowspan=1 colspan=1>0.7217(0.0042)</td><td rowspan=1 colspan=1>0.7770(0.0022)</td><td rowspan=1 colspan=1>0.6520(0.0052)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6164(0.0051)</td><td rowspan=1 colspan=1>0.7797(0.0040)</td><td rowspan=1 colspan=1>0.8224(0.0041)</td><td rowspan=1 colspan=1>0.7704(0.0073)</td><td rowspan=1 colspan=1>0.7273(0.0146)</td><td rowspan=1 colspan=1>0.7696(0.0014)</td><td rowspan=1 colspan=1>0.6603(0.0004)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6183(0.0063)</td><td rowspan=1 colspan=1>0.7845(0.0499)</td><td rowspan=1 colspan=1>0.8428(0.0064)</td><td rowspan=1 colspan=1>0.7839(0.0073)</td><td rowspan=1 colspan=1>0.7172(0.0052)</td><td rowspan=1 colspan=1>0.7692(0.0030)</td><td rowspan=1 colspan=1>0.6537(0.0030)</td></tr><tr><td rowspan=3 colspan=1>GCN</td><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6243(0.0044)</td><td rowspan=1 colspan=1>0.8638(0.0051)</td><td rowspan=1 colspan=1>0.8405(0.0006)</td><td rowspan=1 colspan=1>0.7724(0.0206)</td><td rowspan=1 colspan=1>0.7168(0.0014)</td><td rowspan=1 colspan=1>0.7581(0.0026)</td><td rowspan=1 colspan=1>0.6490(0.024)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6209(0.0028)</td><td rowspan=1 colspan=1>0.8553(0.0044)</td><td rowspan=1 colspan=1>0.8205(0.0120)</td><td rowspan=1 colspan=1>0.7693(0.0032)</td><td rowspan=1 colspan=1>0.7018(0.0074)</td><td rowspan=1 colspan=1>0.7533(0.0059)</td><td rowspan=1 colspan=1>0.6449(0.0035)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6164(0.0103)</td><td rowspan=1 colspan=1>0.8231(0.0325)</td><td rowspan=1 colspan=1>0.8249(0.0059)</td><td rowspan=1 colspan=1>0.7946(0.0102)</td><td rowspan=1 colspan=1>0.7189(0.0103)</td><td rowspan=1 colspan=1>0.7636(0.0070)</td><td rowspan=1 colspan=1>0.6525(0.0025)</td></tr><tr><td rowspan=3 colspan=1>GraphSAGE</td><td rowspan=1 colspan=1>HGC</td><td rowspan=1 colspan=1>0.6286(0.0016)</td><td rowspan=1 colspan=1>0.7395(0.0284)</td><td rowspan=1 colspan=1>0.8368(0.0008)</td><td rowspan=1 colspan=1>0.7722(0.0149)</td><td rowspan=1 colspan=1>0.7129(0.0153)</td><td rowspan=1 colspan=1>0.7583(0.0012)</td><td rowspan=1 colspan=1>0.6505(0.0004)</td></tr><tr><td rowspan=1 colspan=1>AdaM</td><td rowspan=1 colspan=1>0.6148(0.0100)</td><td rowspan=1 colspan=1>0.7098(0.0244)</td><td rowspan=1 colspan=1>0.8212(0.0019)</td><td rowspan=1 colspan=1>0.7730(0.0057)</td><td rowspan=1 colspan=1>0.6982(0.0088)</td><td rowspan=1 colspan=1>0.7643(0.0011)</td><td rowspan=1 colspan=1>0.6492(0.0004)</td></tr><tr><td rowspan=1 colspan=1>HGC_AdaM</td><td rowspan=1 colspan=1>0.6250(0.0029)</td><td rowspan=1 colspan=1>0.8127(0.0213)</td><td rowspan=1 colspan=1>0.7812(0.0038)</td><td rowspan=1 colspan=1>0.7708(0.0053)</td><td rowspan=1 colspan=1>0.7187(0.0019)</td><td rowspan=1 colspan=1>0.7610(0.0008)</td><td rowspan=1 colspan=1>0.6442(0.0018)</td></tr></table>",
+        "bbox": [
+            174,
+            137,
+            818,
+            311
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "269 SocL_NF contains 13 data sources collected from TUDataset [19]. 3). molecular graphs: we use   \n270 the same pretraining dataset with 2 million molecules in [15] and denote it as MolD. The suffix NF   \n271 indicates “no feature”. Since the data sources have different features, we remove all feature and only   \n272 pretrain these datasets with HGC. The details are presented in Appendix A.1. ",
+        "bbox": [
+            140,
+            321,
+            825,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Downstream Tasks. We mainly evaluate the peformance on two tasks, node classfication and graph classification. For the node classification, we conduct the experiments on two datasets, US-Airport [26] and H-index [41] following the same splitting protocol in [25]. For the graph classification, we conduct the experiments on 11 datasets from molecular graph (7 datasets from [37]) and social graphs (4 datasets from [39]). Details of those datasets are deferred to Appendix A.1. ",
+        "bbox": [
+            169,
+            390,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines. For molecular graph classification, we comprehensively compare our pre-training strategies with recent 6 self-supervised learning strategies for graphs. Among them, Edge_Pred, Infomax, Attr_Mask, Context_Pred, are proposed in [15], all of which are node-level pre-training strategies. GraphCL [40] and C_Subgraph [25] are graph level contrastive pre-training strategies. For node classification and social network graph classification, we compare our model with the best result of GCC [25] and several other models (i.e., ProNE [42], GraphWave [7], DGK [39], graph2vec [20], InfoGraph [31], DGCNN [43] and GIN [38]). Details for the implementation, pre-training and fine-tuning settings of baseline models will be discussed in the Appendix A.2 and A.3. ",
+        "bbox": [
+            169,
+            473,
+            825,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pre-training Settings. We use Adam [17] for optimization with the learning rate of 0.001, $\\beta _ { 1 } =$ $0 . 9 , \\beta _ { 2 } = 0 . 9 9 9$ and weight decay of 0, learning rate warms up over the first $1 0 \\%$ steps and then decays linearly. Gradient norm clipping is applied with range $[ - 1 , 1 ]$ . The temperature $\\tau$ is set to 0.07 in HGC pre-training stage. The batch size of MolD pre-training is 256. For SocL_NF and SocS_NF pre-training, the batch size is 32. For the graph classification task, we use mean-pooling to get graph-level representations following [15]. More pre-training details, including backbones, hyper-parameters and training steps are deferred to Appendix A.2.2. ",
+        "bbox": [
+            165,
+            595,
+            825,
+            694
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning Settings. For each fine-tuning task, we train models for 100 epochs. For graph classification tasks (whether social graphs or molecular graphs), we select the best model by their corresponding validation metrics, while the last model after 100 epochs training on downstream training sets are used for further evaluation on downstream evaluation sets, the same with [25]. We adopt micro F1-score and ROC-AUC as the evaluation measures for different tasks. For molecular dataset, as suggested by [37], we apply three independent randomly initialized runs on each dataset and report the mean and standard deviation. More details are are deferred to Appendix A.2.2. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Results of Downstream Tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            416,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2.1 Graph Classification ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            367,
+            871
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "02 We evaluate both HGC and AdaM on 7 popular molecular graph classification datasets and HGC on 4   \n303 social network graph classification datasets.   \n304 The result of molecular graph classification. For molecular graph classification datasets, we   \n305 report our pre-training strategies on different backbones, including GIN [38], GCN [18], Graph  \n306 SAGE [12]. Meanwhile, since only MolD contain node features, we apply both HGC and AdaM   \n307 strategies on the molecular datasets. HGC_AdaM indicates the combination of two strategies.   \n308 As shown in Table 1, we have the following observations: (1). GIN model pre-trained by   \n309 our pre-training strategies can consistently outperform those pre-trained by other existing strate  \n310 gies, with large margin on most of them. The overall absolute improvement is $2 . 9 8 \\%$ in av  \n311 erage. (2). Specially, HGC can consistently outperform those graph-data-augmentation-based   \n312 contrastive learning strategies (i.e., GraphCL and C_Subgraph) . It verifies our stand point that   \n313 the graph data augmentation will lose some crucial domain information and compromise the fi  \n314 nal performance, while HGC dose not lose such information and leads to better performance. ",
+        "bbox": [
+            151,
+            882,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            92,
+            826,
+            243
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(3). Even though GCN/GraphSAGE can not surpass the our pre-trained model on GIN pretrained model, they still outperform the other pretraining strategy, which reaffirms the effectiveness of our pre-training strategies. (4). The combined strategy HGC_AdaM achieve more benefits on GCN and GraphSAGE than that of GIN. We conjecture that GIN encodes the additional noise which is introduced by this simple combination due to its strong expressive power. ",
+        "bbox": [
+            173,
+            243,
+            485,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b2cd18409cb98acd522846f6f9d352460220ef6cc3511d421e6e818c57d85d77.jpg",
+        "table_caption": [
+            "Table 2: Results on graph classification datasets. The evaluation metric is micro F1-score. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Strategy</td><td>IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M</td></tr><tr><td># graphs #classes</td><td>1000 2</td><td>1500 3</td><td>2000 2</td><td>5000 5</td></tr><tr><td>DGK graph2vec InfoGraph</td><td>0.670 0.711</td><td>0.446 0.504</td><td>0.780 0.758</td><td>0.413 0.479</td></tr><tr><td>DGCNN</td><td>0.730 0.700</td><td>0.497 0.478</td><td>0.825 -</td><td>0.535 -</td></tr><tr><td>GIN(No-Pret.)</td><td>0.734</td><td>0.433</td><td>0.885</td><td>0.635</td></tr><tr><td>GIN_GCC(Best)</td><td>0.756</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td>0.509</td><td>0.898</td><td>0.530</td></tr><tr><td>GIN_HGC(SocS_NF)</td><td>0.765</td><td>0.474</td><td>0.913</td><td>0.657</td></tr><tr><td>GIN_HGC(SocL_NF)</td><td>0.756</td><td>0.490</td><td>0.914</td><td>0.652</td></tr></table>",
+        "bbox": [
+            496,
+            268,
+            821,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The result of social graph classification. To check the transferability of HGC, we conduct the finetune experiments on two models pretrained by SocL_NF and SocS_NF. SocL_NF contains the unlabeled data set used in finetune while SocS_NF does not. Table 2 documents the performance of GIN model pre-trained by HGC on SocL_NF and SocS_NF datasets. Such results show that GIN model pre-trained by HGC achieves the best performance on three out of four datasets. The comparison between GIN_HGC and GIN(No-Pret.) also confirms the benefits of HGC. Another interesting observation is that the pretrain model based on SocS_NF can obtain the better performance than than SocL_NF on two out of four datasets. It implies that HGC dose not just memorize the training samples. It can encode the latent structural information from unseen graphs and transfer the knowledge to the downstream tasks. ",
+        "bbox": [
+            171,
+            393,
+            825,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2.2 Node Classification. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            361,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our model pre-trained by HGC on AP_NF on two downstream node classification datasets and summarize the results in Table 3. Among different versions of GCC, the best ones are presented. From Table 3, the model pre-trained by our HGC strategy can outperform the best GCC model on both datasets. It is worth noting that the pre-training dataset AP_NF contains only 70k graphs, which is much smaller than that of GCC(9M graphs). This verifies the efficiency of HGC in the information extraction. ",
+        "bbox": [
+            174,
+            574,
+            614,
+            685
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/4d2ddaa17ae324a088d915cdc0d378210d3e86a3c9bdd4c1dcabcacd53dce283.jpg",
+        "table_caption": [
+            "Table 3: Results on node classification datasets. The evaluation metric is micro F1-score. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Datasets</td><td rowspan=1 colspan=1>US-Ariport</td><td rowspan=1 colspan=1>H-index</td></tr><tr><td rowspan=1 colspan=1>V|E</td><td rowspan=1 colspan=1>119013599</td><td rowspan=1 colspan=1>500044020</td></tr><tr><td rowspan=1 colspan=1>ProNE</td><td rowspan=1 colspan=1>0.623</td><td rowspan=1 colspan=1>0.691</td></tr><tr><td rowspan=1 colspan=1>GraphWave</td><td rowspan=1 colspan=1>0.602</td><td rowspan=1 colspan=1>0.703</td></tr><tr><td rowspan=1 colspan=1>Struc2vec</td><td rowspan=1 colspan=1>0.662</td><td rowspan=1 colspan=1>-</td></tr><tr><td rowspan=1 colspan=1>GCC (Best)</td><td rowspan=1 colspan=1>0.683</td><td rowspan=1 colspan=1>0.806</td></tr><tr><td rowspan=1 colspan=1>HGC(AP_NF)</td><td rowspan=1 colspan=1>0.706</td><td rowspan=1 colspan=1>0.824</td></tr></table>",
+        "bbox": [
+            625,
+            593,
+            820,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Ablation Study ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            705,
+            316,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How useful are the proposed self-supervised tasks? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            738,
+            529,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the contribution of our pre-training strategies, we compare the the performance of the pre-trained model by HGC and AdaM, with the model without any pre-training, each of which shares the same hyper-parameter setting. Results are summarized in Table 4 for backbone GIN. It can be seen clearly that all GIN models benefit from self-supervised pre-training tasks on all datasets. To be more specific, for GIN, absolute $1 7 . 9 \\%$ ROC-AUC increase is observed on the dataset BACE, $1 6 . 5 \\%$ on ClinTox, and $6 . 9 6 \\%$ on SIDER, leading to $7 . 5 3 \\%$ on average. Furthermore, pre-trained models gain larger improve",
+        "bbox": [
+            174,
+            760,
+            581,
+            905
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/08d74d097a9b5729a1f5d6ca49d647f5cd666e8f8caad7f96554d92d1be97e9d.jpg",
+        "table_caption": [
+            "Table 4: Effectiveness of the pretraining on GIN. Bold numbers for absolute improvements larger than 0.05. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>No-Pret.</td><td rowspan=1 colspan=1>SS-Pret.</td><td rowspan=1 colspan=1>Abs.Imp.</td></tr><tr><td rowspan=1 colspan=1>SIDER</td><td rowspan=1 colspan=1>0.5637</td><td rowspan=1 colspan=1>0.6333</td><td rowspan=1 colspan=1>+0.0696</td></tr><tr><td rowspan=1 colspan=1>ClinTox</td><td rowspan=1 colspan=1>0.6480</td><td rowspan=1 colspan=1>0.8134</td><td rowspan=1 colspan=1>+0.1654</td></tr><tr><td rowspan=1 colspan=1>BACE</td><td rowspan=1 colspan=1>0.6653</td><td rowspan=1 colspan=1>0.8442</td><td rowspan=2 colspan=1>+0.1789+0.0378</td></tr><tr><td rowspan=1 colspan=1>HIV</td><td rowspan=1 colspan=1>0.7475</td><td rowspan=1 colspan=1>0.7853</td></tr><tr><td rowspan=1 colspan=1>BBBP</td><td rowspan=1 colspan=1>0.6939</td><td rowspan=1 colspan=1>0.7273</td><td rowspan=1 colspan=1>+0.0334</td></tr><tr><td rowspan=1 colspan=1>Tox21</td><td rowspan=1 colspan=1>0.7580</td><td rowspan=1 colspan=1>0.7770</td><td rowspan=1 colspan=1>+0.0190</td></tr><tr><td rowspan=1 colspan=1>ToxCast</td><td rowspan=1 colspan=1>0.6370</td><td rowspan=1 colspan=1>0.6603</td><td rowspan=1 colspan=1>+0.0233</td></tr></table>",
+        "bbox": [
+            594,
+            803,
+            821,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "356 ment on datasets of relatively small size (e.g., BACE, ClinTox and SIDER), which is also observed in [28]. It indicates that self-supervised pre-training helps GNN models learn more inherent graph properties, thus getting better performance in small downstream datasets where labeled graphs are scarce. ",
+        "bbox": [
+            151,
+            897,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            165,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Can we transfer pre-trained models to downstream datasets that are dramatically different from the pre-training one? It has long been known that the pre-trained model can be generalized to unseen data in pretraining dataset [25, 15, 6, 28, 40]. However, previous literature [25, 15, 40] largely focuses on transferring the pre-trained model to downstream ",
+        "bbox": [
+            173,
+            146,
+            421,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c13e8f68b781d4b4a6a06ca3b2057fa93a10dbf4967216feecc5106b8d67cb7e.jpg",
+        "table_caption": [
+            "Table 5: Results for pretraining transferability on graph classification datasets. Numbers in red are the negative transfer cases. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Pretraining Type</td><td>Strategy</td><td>IMDB-B</td><td>IMDB-M</td><td>RDT-B</td><td>RDT-M</td></tr><tr><td>None</td><td>GIN(No-Pret.)</td><td>0.734</td><td>0.433</td><td>0.885</td><td>0.635</td></tr><tr><td rowspan=\"3\">Social</td><td>GIN_GCC(best)</td><td>0.756</td><td>0.509</td><td>0.898</td><td>0.530</td></tr><tr><td>HGC(SocS_NF)</td><td>0.765</td><td>0.474</td><td>0.913</td><td>0.657</td></tr><tr><td>HGC(SocL_NF)</td><td>0.756</td><td>0.490</td><td>0.914</td><td>0.652</td></tr><tr><td rowspan=\"4\">Molecular</td><td>Context_Pred (MolD)</td><td>0.734</td><td>0.473</td><td>0.875</td><td>0.635</td></tr><tr><td>S_Context_Pred (MolD)</td><td>0.763</td><td>0.460</td><td>0.818</td><td>0.625</td></tr><tr><td>HGC(MolD)</td><td>0.768</td><td>0.504</td><td>0.912</td><td>0.656</td></tr><tr><td>AdaM(MolD)</td><td>0.740</td><td>0.486</td><td>0.880</td><td>0.654</td></tr></table>",
+        "bbox": [
+            431,
+            191,
+            821,
+            286
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "HGC_AdaM(MolD) 0.743 0.509 0.896 0.665 datasets with similar type of data. Here, what we are interested in asking is can we transfer the pre-trained model to the downstream datasets with clearly different type of graphs compared to the ones in the pre-training dataset? To show this, we demonstrate the case from molecular graph to social network graph classification. We pre-train GIN in two different ways: one is pretrained by HGC on two social network graph datasets: SocS_NF and SocL_NF, the other is by HGC, AdaM or HGC_AdaM as well as Context_Pred or S_Context_Pred [15] on the molecular dataset MolD. ",
+        "bbox": [
+            171,
+            285,
+            825,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "376 The results are summarized in Table 5, which offers the following observations: (1). Perhaps   \n377 surprisingly, our methods including HGC and HGC_AdaM enable the models pre-trained on molec  \n378 ular graphs to even outperform those pre-trained on social graphs. For example, the accuracy of   \n379 HGC_AdaM on IMDB-M (0.509) and RDT-M (0.665) is much better than that of HGC(SocS_NF)   \n380 and HGC(SocL_NF). Apart from the universal graph-level properties, the results also inform that   \n381 larger pre-training datasets can help the model learn such inherent properties better. (2). Different pre  \n382 training strategies could deliver different performance. Models pre-trained by graph-level pre-training   \n383 strategies or combined strategies (i.e., HGC(MolD) and HGC_AdaM(MolD)) can always get better   \n384 results than those pre-trained by node-level strategies (i.e., AdaM(MolD) and Context_Pred(MolD)),   \n385 which indicates that graph-level pre-training strategies can help the model learn global graph-level   \n386 properties that can be easily transferred to other domains. (3). We also observe the negative transfer   \n387 brought by the supervised pretraining in some cases. For instance, S_Context_Pred $( { \\mathsf { M o l D } } ) ^ { 3 }$ get   \n388 worse performance than its no supervised trained version Context_Pred (MolD) on two datasets:   \n389 RDT-B and RDT-M. It indicates that simple efforts to learn graph-level properties, such as training   \n390 with labeled graphs, is probable to be limited in the certain domain, thus performing bad in such   \n391 cross-domain transfer tasks. Despite this, our HGC and HGC_AdaM still consistently lead to better   \n392 performance compared to other pretraining strategies, which, once again, versifies our assumption   \n393 that our proposed graph contrastive learning strategy can learn more universal, even cross-domain,   \n394 graph-level patterns. ",
+        "bbox": [
+            140,
+            373,
+            826,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "395 6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            150,
+            657,
+            299,
+            674
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "396   \n397   \n398   \n399   \n400   \n401   \n402   \n403   \n404   \n405   \n406   \n407   \n408   \n409 ",
+        "bbox": [
+            140,
+            689,
+            161,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we focus on developing an effective, efficient and more universal positive instances sampling method that can be applied on many different kinds of graph data for graph instance contrastive learning. We also propose an improvement for a widely used node-level pre-training strategy to adaptively select nodes to mask for an even distribution (AdaM). Moreover, we also discover the potential cross-domain transferring ability for the pre-trained GNN models. However, there are still some limitations in our work: 1). Though high-order graph sampling can get positive instances of better quality than those obtained by first-order sampling in our analysis, it cannot always outperform the model pre-trained by first-order sampling process. We guess that it is relevant with the pre-training dataset. 2). Just combining HGC and AdaM in a simple manner leads to no significant improvement. Though we make no further investigation into a more effective combination method since it is not the keypoint of the paper, it is a meaningful research direction. 3). We discover the potential cross-domain transferring ability for pre-trained GNN models. It is an interesting point but no further discussion is made in this paper. However, further relevant investigation is interesting and meaningful. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "410 References [1] Sanjeev Arora, Hrishikesh Khandeparkar, Mikhail Khodak, Orestis Plevrakis, and Nikunj Saunshi. A theoretical analysis of contrastive unsupervised representation learning. arXiv preprint arXiv:1902.09229, 2019. [2] David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. Technical report, Stanford, 2006. [3] Guy W Bemis and Mark A Murcko. The properties of known drugs. 1. molecular frameworks. Journal of medicinal chemistry, 39(15):2887–2893, 1996. [4] Smriti Bhagat, Graham Cormode, and S Muthukrishnan. Node classification in social networks. In Social network data analytics. 2011. [5] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey Hinton. A simple framework for contrastive learning of visual representations. In International conference on machine learning, pages 1597–1607. PMLR, 2020. [6] 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. [7] Claire Donnat, Marinka Zitnik, David Hallac, and Jure Leskovec. Learning structural node embeddings via diffusion wavelets. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1320–1329, 2018. [8] Greg Landrum et al. Rdkit: Open-source cheminformatics. 2006. [9] Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019. [10] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning, pages 1263–1272. PMLR, 2017. [11] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864, 2016. [12] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. arXiv preprint arXiv:1706.02216, 2017. [13] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive multi-view representation learning on graphs. In International Conference on Machine Learning, pages 4116–4126. PMLR, 2020. [14] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. Momentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9729–9738, 2020. [15] 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. [16] Max Jaderberg, Valentin Dalibard, Simon Osindero, Wojciech M Czarnecki, Jeff Donahue, Ali Razavi, Oriol Vinyals, Tim Green, Iain Dunning, Karen Simonyan, et al. Population based training of neural networks. arXiv preprint arXiv:1711.09846, 2017. [17] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [18] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            147,
+            77,
+            828,
+            919
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[19] Christopher Morris, Nils M. Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann. Tudataset: A collection of benchmark datasets for learning with graphs. In ICML 2020 Workshop on Graph Representation Learning and Beyond (GRL+ 2020), 2020. URL www.graphlearning.io.   \n[20] Annamalai Narayanan, Mahinthan Chandramohan, Rajasekar Venkatesan, Lihui Chen, Yang Liu, and Shantanu Jaiswal. graph2vec: Learning distributed representations of graphs. arXiv preprint arXiv:1707.05005, 2017.   \n[21] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   \n[22] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710, 2014.   \n[23] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Kuansan Wang, and Jie Tang. Network embedding as matrix factorization: Unifying deepwalk, line, pte, and node2vec. In Proceedings of the eleventh ACM international conference on web search and data mining, pages 459–467, 2018.   \n[24] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Chi Wang, Kuansan Wang, and Jie Tang. Netsmf: Large-scale network embedding as sparse matrix factorization. In The World Wide Web Conference, pages 1509–1520, 2019.   \n[25] Jiezhong Qiu, Qibin Chen, Yuxiao Dong, Jing Zhang, Hongxia Yang, Ming Ding, Kuansan Wang, and Jie Tang. Gcc: Graph contrastive coding for graph neural network pre-training. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1150–1160, 2020.   \n[26] Leonardo FR Ribeiro, Pedro HP Saverese, and Daniel R Figueiredo. struc2vec: Learning node representations from structural identity. In Proceedings of the 23rd ACM SIGKDD international conference on knowledge discovery and data mining, pages 385–394, 2017.   \n[27] David Rogers and Mathew Hahn. Extended-connectivity fingerprints. Journal of chemical information and modeling, 50(5):742–754, 2010.   \n[28] Yu Rong, Yatao Bian, Tingyang Xu, Weiyang Xie, Ying Wei, Wenbing Huang, and Junzhou Huang. Grover: Self-supervised message passing transformer on large-scale molecular data. arXiv preprint arXiv:2007.02835, 2020.   \n[29] Nino Shervashidze, Pascal Schweitzer, Erik Jan Van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. Journal of Machine Learning Research, 12(9), 2011.   \n[30] Teague Sterling and John J Irwin. Zinc 15–ligand discovery for everyone. Journal of chemical information and modeling, 55(11):2324–2337, 2015.   \n[31] Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semi-supervised graph-level representation learning via mutual information maximization. arXiv preprint arXiv:1908.01000, 2019.   \n[32] Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Largescale information network embedding. In Proceedings of the 24th international conference on world wide web, pages 1067–1077, 2015.   \n[33] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   \n[34] Petar Velickovic, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In ICLR (Poster), 2019.   \n[35] Minjie Wang, Lingfan Yu, Da Zheng, Quan Gan, Yu Gai, Zihao Ye, Mufei Li, Jinjing Zhou, Qi Huang, Chao Ma, et al. Deep graph library: Towards efficient and scalable deep learning on graphs. 2019. ",
+        "bbox": [
+            166,
+            42,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "504 [36] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma,   \n505 Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang.   \n506 Deep graph library: A graph-centric, highly-performant package for graph neural networks.   \n507 arXiv preprint arXiv:1909.01315, 2019.   \n508 [37] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S   \n509 Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine   \n510 learning. Chemical science, 9(2):513–530, 2018.   \n511 [38] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural   \n512 networks? arXiv preprint arXiv:1810.00826, 2018.   \n513 [39] Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM   \n514 SIGKDD international conference on knowledge discovery and data mining, pages 1365–1374,   \n515 2015.   \n516 [40] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen.   \n517 Graph contrastive learning with augmentations. Advances in Neural Information Processing   \n518 Systems, 33, 2020.   \n519 [41] Fanjin Zhang, Xiao Liu, Jie Tang, Yuxiao Dong, Peiran Yao, Jie Zhang, Xiaotao Gu, Yan Wang,   \n520 Bin Shao, Rui Li, et al. Oag: Toward linking large-scale heterogeneous entity graphs. In   \n521 Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery &   \n522 Data Mining, pages 2585–2595, 2019.   \n523 [42] Jie Zhang, Yuxiao Dong, Yan Wang, Jie Tang, and Ming Ding. Prone: Fast and scalable network   \n524 representation learning. In IJCAI, volume 19, pages 4278–4284, 2019.   \n525 [43] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning   \n526 architecture for graph classification. In Proceedings of the AAAI Conference on Artificial   \n527 Intelligence, volume 32, 2018.   \n528 [44] Shenghuo Zhu, Kai Yu, Yun Chi, and Yihong Gong. Combining content and link for classifica  \n529 tion using matrix factorization. In SIGIR, 2007. ",
+        "bbox": [
+            137,
+            90,
+            828,
+            534
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            117,
+            339,
+            131
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] The main contribution of this paper is the proposal of an effective and more universal positive instance selection strategy that can be applied on various kinds of graph data in the contrastive learning process. We also propose an improvement of the a widely used node-level pre-training strategy to adaptively choose nodes to make them distributed evenly in the graph. Moreover, we discover the potential possibility of the cross-domain transferable ability of the pre-trained GNN models.   \n(b) Did you describe the limitations of your work? [Yes] See Sec. 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Sec. C.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            137,
+            825,
+            311
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            316,
+            493,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Sec. A.7. We make reasonable assumptions on the possibility density function of the approximate similarity function on the ground-truth positive graph set and negative graph set. Some reasonable approximations are made in the derivation process.   \n(b) Did you include complete proofs of all theoretical results? [Yes] See Sec. A.7. ",
+        "bbox": [
+            232,
+            335,
+            825,
+            409
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            414,
+            393,
+            428
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(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)? [Yes] See Sec. A.1 for descriptions and download links for datasets. Download links for our pre-processed data are shared along with the code. Code is provided with supplemental material. Instructions for reproduction are stated in README.md file in the supplemental material.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Sec. A.2 for implementation details, including pre-training and fine-tuning configuration and hyper-parameter selection. See Sec. A.1 for descriptions for datasets and the splitting methods.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We report mean and std values for 3 independently random initialized run for each evaluation process on molecular graph datasets. See Table 1 and Table 12 for details.   \n(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] See Sec. A.2 for hardware configurations. ",
+        "bbox": [
+            235,
+            433,
+            826,
+            676
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            681,
+            823,
+            695
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you citep the creators? [Yes] We provide links for data and code that are from public respiratory we used in our project. We also cite related papers. See Sec. A.1 and Sec. A.3.   \n(b) Did you mention the license of the assets? [Yes] Datasets obtained from published works are with related papers cited. See Sec. A.1   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new datasets are proposed.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] Download links for public datasets we used are provided. Datasets obtained from published works are with related papers cited. See Sec. A.1   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] Datasets we use are obtained from public datasets, containing no such information. We provide links for them in Sec. A.1. . ",
+        "bbox": [
+            238,
+            700,
+            825,
+            892
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            212,
+            897,
+            705,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "583 (a) Did you include the full text of instructions given to participants and screenshots, if   \n584 applicable? [N/A]   \n585 (b) Did you describe any potential participant risks, with links to Institutional Review   \n586 Board (IRB) approvals, if applicable? [N/A]   \n587 (c) Did you include the estimated hourly wage paid to participants and the total amount   \n588 spent on participant compensation? [N/A] ",
+        "bbox": [
+            137,
+            90,
+            826,
+            181
+        ],
+        "page_idx": 13
+    }
+]

parse/train/N33d7wjgzde/N33d7wjgzde.md

@@ -0,0 +1,383 @@
+# UNIVERSAL WEAKLY SUPERVISED SEGMENTATION BY PIXEL-TO-SEGMENT CONTRASTIVE LEARNING
+
+Tsung-Wei Ke Jyh-Jing Hwang Stella X. Yu UC Berkeley / ICSI {twke,jyh,stellayu}@berkeley.edu
+
+# ABSTRACT
+
+Weakly supervised segmentation requires assigning a label to every pixel based on training instances with partial annotations such as image-level tags, object bounding boxes, labeled points and scribbles. This task is challenging, as coarse annotations (tags, boxes) lack precise pixel localization whereas sparse annotations (points, scribbles) lack broad region coverage. Existing methods tackle these two types of weak supervision differently: Class activation maps are used to localize coarse labels and iteratively refine the segmentation model, whereas conditional random fields are used to propagate sparse labels to the entire image.
+
+We formulate weakly supervised segmentation as a semi-supervised metric learning problem, where pixels of the same (different) semantics need to be mapped to the same (distinctive) features. We propose 4 types of contrastive relationships between pixels and segments in the feature space, capturing low-level image similarity, semantic annotation, co-occurrence, and feature affinity. They act as priors; the pixel-wise feature can be learned from training images with any partial annotations in a data-driven fashion. In particular, unlabeled pixels in training images participate not only in data-driven grouping within each image, but also in discriminative feature learning within and across images. We deliver a universal weakly supervised segmenter with significant gains on Pascal VOC and DensePose. Our code is publicly available at https://github.com/twke18/SPML.
+
+# 1 INTRODUCTION
+
+Consider the task of learning a semantic segmenter given sparsely labeled training images (Fig. 1): Each body part is labeled with a single seed pixel and the task is to segment out the entire person by individual body parts, even though the ground-truth segmentation is not known during training. This task is challenging, as not only a single body part could contain several visually distinctive areas (e.g., head consists of eyes, nose, mouth, beard), but two adjacent body parts could also have the same visual appearance (e.g., upper arm, lower arm, and hand have the same skin appearance). Once the segmenter is learned, it can be applied to a test image without any annotations.
+
+![](images/fa37bfbc4a4cd059ca8d6709827f3e3ebb972d790524cd4c98ba7c06557fc65b.jpg)  
+Figure 1: Our task learns a segmenter given partially labeled training images and applies it to test images. A common baseline is to propagate labels within an image based on feature similarity. We model it as semi-supervised metric learning and learn the pixel-wise feature by contrasting it within and across images. Our results are fuller and more accurate, approaching the ground-truth.
+
+Figure 2: We propose a unified framework for weakly supervised semantic segmentation with different types of annotations. We demonstrate consistent performance gains compared to the state-ofthe-art (SOTA) methods: Chang et al. (2020) for image tags, Song et al. (2019) for bounding boxes, and Tang et al. (2018b) for points and scribbles. For tags and boxes, Class Activation Maps (CAM) (Zhou et al., 2016) are often used to localize semantics as an initial mask and iteratively refine the segmentation model, whereas for labeled points and scribbles, Conditional Random Fields (CRF) are used to propagate semantic labels to unlabeled regions based on low-level image similarity.   
+
+<table><tr><td>image</td><td>image tags</td><td colspan="2">bounding boxes</td><td>labeled points</td><td>scribbles</td></tr><tr><td></td><td rowspan="3">Person Motorbike</td><td></td><td></td><td rowspan="3">.</td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td>·</td></tr><tr><td>SOTA methods</td><td rowspan="2">CAM +refine</td><td></td><td>box-wise CAM</td><td>CRF loss</td><td>CRF loss</td></tr><tr><td>our method</td><td colspan="4">single pixel-to-segment contrastive learning loss formulation</td></tr><tr><td>our relative gain</td><td>+8.6%</td><td colspan="2">+4.7%</td><td>+24.7%</td><td>+1.4%</td></tr></table>
+
+This task belongs to a family of weakly supervised segmentation problems, the goal of which is to assign a label to each pixel despite that only partial supervision is available during training. It addresses the practical issue of learning segmentation from minimum annotations. Such weak supervision takes many forms, e.g., image tags (Kolesnikov & Lampert, 2016; Ahn & Kwak, 2018; Huang et al., 2018; Lee et al., 2019), bounding boxes (Dai et al., 2015; Khoreva et al., 2017; Song et al., 2019), keypoints (Bearman et al., 2016), and scribbles (Lin et al., 2016; Tang et al., 2018a;b). Tags and boxes are coarse annotations that lack precise pixel localization whereas points and scribbles are sparse annotations that lack broad region coverage.
+
+Weakly supervised semantic segmentation can be regarded as a semi-supervised pixel classification problem: Some pixels or pixel sets have labels, most don’t, and the key is how to propagate and refine annotations from coarsely and sparsely labeled pixels to unlabeled pixels.
+
+Existing methods tackle two types of weak supervision differently: Class Activation Maps (CAM) (Zhou et al., 2016) are used to localize coarse labels, generate pseudo pixel-wise labels, and iteratively refine the segmentation model, whereas Conditional Random Fields (CRF) (Krahenb ¨ uhl ¨ & Koltun, 2011) are used to propagate sparse labels to the entire image. These ideas can be incorporated as an additional unsupervised loss on the feature learned for segmentation (Tang et al., 2018b): While labeled pixels receive supervision, unlabeled pixels in different segments shall have distinctive feature representations.
+
+We propose a Semi-supervised Pixel-wise Metric Learning (SPML) model that can handle all these weak supervision varieties with a single pixel-to-segment contrastive learning formulation (Fig. 2). Instead of classifying pixels, our metric learning model learns a pixel-wise feature embedding based on common grouping relationships that can be derived from any form of weak supervision.
+
+Our key insight is to integrate unlabeled pixels into both supervised labeling and discriminative feature learning. They shall participate not only in data-driven grouping within each image, but also in discriminative feature learning within and more importantly across images. Intuitively, labeled pixels receive supervision not only for themselves, but also for their surround pixels that share visual similarity. On the other hand, unlabeled pixels are not just passively brought into discriminative learning induced by sparsely labeled pixels, they themselves are organized based on bottom-up grouping cues (such as grouping by color similarity and separation by strong contours). When they are examined across images, repeated patterns of frequent occurrences would also form a cluster that demand active discrimination from other patterns.
+
+We capture the above insight in a single pixel-wise metric learning objective for segmentation, the goal of which is to map each pixel into a point in the feature space so that pixels in the same (different) semantic groups are close (far) in the feature space. Our model extends SegSort (Hwang et al., 2019) from its fully supervised and unsupervised segmentation settings to a universal weaklysupervised segmentation setting. With a single consistent feature learning criterion, such a model sorts pixels discriminatively within individual images and sorts segment clusters discriminatively across images, both steps minimizing the same feature discrimination loss.
+
+Our experiments on Pascal VOC (Everingham et al., 2010) and DensePose (Alp Guler et al., 2018) ¨ demonstrate consistent gains over the state-of-the-art (SOTA), and the gain is substantial especially for the sparsest keypoint supervision.
+
+# 2 RELATED WORK
+
+Semi-supervised learning. Weston et al. (2012) treats it as a joint learning problem with both labeled and unlabeled data. One way is to capture the underlying structure of unlabeled data with generative models (Kingma et al., 2014; Rasmus et al., 2015). Another way is to regularize feature learning through a consistency loss, e.g., adversarial ensembling (Miyato et al., 2018), imitation learning and distillation (Tarvainen & Valpola, 2017), cross-view ensembling (Clark et al., 2018). These methods are most related to transductive learning (Joachims, 2003; Zhou et al., 2004; Fergus et al., 2009; Liu et al., 2019), where labels are propagated to unlabeled data via clustering in the pretrained feature space. Our work does transductive learning in an adaptively learned feature space.
+
+Weakly-supervised semantic segmentation. Partial annotations include scribbles (Lin et al., 2016; Tang et al., 2018a;b; Wang et al., 2019), bounding boxes (Dai et al., 2015; Khoreva et al., 2017; Song et al., 2019), points (Bearman et al., 2016), or image tags (Papandreou et al., 2015; Kolesnikov & Lampert, 2016; Ahn & Kwak, 2018; Huang et al., 2018; Li et al., 2018; Lee et al., 2019; Shimoda & Yanai, 2019; Zhang et al., 2019; Yao & Gong, 2020; Chang et al., 2020; Araslanov & Roth, 2020; Wang et al., 2020; Fan et al., 2020; Sun et al., 2020). Xu et al. (2015) formulates all types of weak supervision as linear constraints on a SVM. Papandreou et al. (2015) bootstraps segmentation predictions via EM-optimization. Recent works (Lin et al., 2016; Kolesnikov & Lampert, 2016; Pathak et al., 2015) typically use CAM (Zhou et al., 2016) to obtain an initial dense mask and then train a model iteratively. GAIN (Li et al., 2018) utilizes image tags or bounding boxes to refine these class-specific activation maps. Sun et al. (2020) considers within-image relationships and explores the idea of co-segmentation. Fan et al. (2020) estimates the foreground and background for each category, with which the network learns to generate more precise CAMs. Regularization is enforced at either the image level (Lin et al., 2016; Kolesnikov & Lampert, 2016; Pathak et al., 2015) or the feature level (Tang et al., 2018a;b) to produce better dense masks. We incorporate this concept into adaptive feature learning and train the model only once. All types of weak annotations are dealt with in a single contrastive learning framework.
+
+Non-parametric segmentation. Prior to deep learning, non-parametric models (Russell et al., 2009; Tighe & Lazebnik, 2010; Liu et al., 2011) usually use designed features with statistical or graphical models to segment images. Recently, inspired by non-parametric models for recognition (Wu et al., 2018b;a), SegSort (Hwang et al., 2019) captures pixel-to-segment relationships via a pixel-wise embedding and develops the first deep non-parametric semantic segmentation for supervised and unsupervised settings. Building upon SegSort, our work has the flexibility of a non-parametric model at capturing data relationships and modeling subclusters within a category.
+
+# 3 SEMI-SUPERVISED PIXEL-WISE METRIC LEARNING METHOD
+
+Metric learning develops a feature representation based on data grouping and separation cues. Our method (Fig. 3) segments an image by learning a pixel-wise embedding with a contrastive loss between pixels and segments: For each pixel $i$ , we learn a latent feature $\phi ( i )$ such that $i$ is close to its positive segments (exemplars) and far from its negative ones in that feature space.
+
+In the fully supervised setting, we can define pixel $i$ ’s positive and negative sets, denoted by $\mathcal { C } ^ { + }$ and $\scriptstyle { { \mathcal { C } } ^ { - } }$ respectively, as pixels in the same (different) category. However, this idea is not applicable to weakly- or un-supervised settings where the label is not available on every pixel. In the labeled points setting, $\mathcal { C } ^ { + }$ and $\scriptstyle { { \mathcal { C } } ^ { - } }$ would only contain a few exemplars according to the sparse pixel labels.
+
+![](images/81ee83f2586f6c3a6f60fa8528fffff40a62151178247a07f95ce4a88ce002e5.jpg)  
+Figure 3: Overall method diagram. We develop pixel-wise embeddings with contrastive learning between pixels and segments. We derive various forms of positive and negative segments for each pixel. Our goal is to attract (blue inward arrows) the pixel with positive segments, while repelling (red outward arrows) it from negative segments in the feature space.
+
+![](images/5f4d9d5557775ee093d6502f2ad5cfb8fe06ddc1c59d86f7180b5d4ee070c620.jpg)  
+Figure 4: Four types of pixel-to-segment attraction and repulsion relationships. A pixel is attracted to (repelled by) segments: a) of similar (different) visual appearances such as color or texture, b) of the same (different) class labels, c) in images with common (distinctive) labels, d) of nearby (far-away) feature embeddings. They form different positive and negative sets.
+
+Our basic idea is to enlarge the sets of $\mathcal { C } ^ { + }$ and $\scriptstyle { { \mathcal { C } } ^ { - } }$ to improve the feature learning efficacy. By exploring different relationships and assumptions in the image data, we are able to generate abundant positive and negative segments for any pixel at the same time, providing more supervision in the latent feature space. We propose four types of relationships between pixels and segments (Fig. 4):
+
+1. Low-level image similarity: We impose a spatial smoothness prior on the pixel-wise feature to keep pixels together in visually coherent regions. The segment pixel $i$ belongs to based on low-level image cues is a positive segment to pixel $i$ ; any other segments are negative ones.
+
+2. Semantic annotation: We expand the semantics from labeled points and scribbles to pseudolabels inferred from image- or box-wise CAM. The label of a segment can be estimated by majority vote among pixels; if it is the same as pixel $i$ ’s, the segment is a positive segment to $i$ .
+
+3. Semantic co-occurrence: We expand the semantics by assuming that pixels in similar semantic contexts tend to be grouped together. If a segment appears in an image that shares any of the semantic classes as pixel $i$ ’s image, it is a positive segment to $i$ and otherwise a negative one.
+
+4. Feature affinity: We impose a featural smoothness prior assuming that pixels and segments of the same semantics form a cluster in the feature space. We propagate the semantics within and across images from pixel $i$ to its closest segment $s$ in the feature space.
+
+3.1 PIXEL-TO-SEGMENT CONTRASTIVE GROUPING RELATIONSHIPS
+
+Our goal is to propagate known semantics from labeled data $\mathcal { C }$ to unlabeled data $\mathcal { U }$ with the aforementioned priors. $\mathcal { C }$ and $\mathcal { U }$ denote the sets of segment indices respectively. We detail how to augment positive / negative segment sets using both $\mathcal { C }$ and $\mathcal { U }$ for each type of relationships (Fig. 4).
+
+Low-level image similarity. To propagate labels within visually coherent regions, we generate a low-level over-segmentation. Following SegSort (Hwang et al., 2019), we use the HED contour detector (Xie & Tu, 2015) (pre-trained on BSDS500 dataset (Arbelaez et al., 2010)) and $\mathrm { g P b }$ -owtucm (Arbelaez et al., 2010) to generate a segmentation without semantic information. We define $i$ ’s positive and negative segments as $i$ ’s own segment and all the other segments, denoted as $\mathcal { V } ^ { + }$ and $\nu ^ { - }$ respectively. We only consider segments in the same image as pixel $i$ ’s. We align the contour-based over-segmentations with segmentations generated by K-Means clustering as in SegSort.
+
+Semantic annotation. Image tags and bounding boxes do not provide pixel-wise localization. We derive pseudo labels from image- or box-wise CAM and align them with oversegmentations induced by the pixel-wise feature. Pixel $i$ ’s positive (negative) segments are the ones with the same (different) semantic category, denoted by $\mathcal { C } ^ { + }$ and $\mathcal { C } ^ { - }$ respectively. We ignore all the unlabeled segments.
+
+Semantic co-occurrence. Semantic context characterizes the co-occurrences of different objects, which can be used as a prior to group and separate pixels. We define semantic context as the union of object classes in each image. Even without the pixel-wise localization of semantic labels, we can leverage semantic context to impose global regularization on the latent feature: The feature should separate images without any overlapping object categories.
+
+Let ${ \mathcal { O } } ^ { + } ~ ( { \mathcal { O } } ^ { - } )$ denote the set of segments in images with (without) overlapping categories as pixel $i$ ’s image. That is, if the image of pixel $i$ and another image share any semantic labels (Fig. 4c: {cat, sofa, table, chair} for the pixel in the Row 2 image vs. $\{ s o f a \}$ for the Row 1 image), then all the segments from that image are positive segments to $i$ and included in $\mathcal { O } ^ { + }$ ; otherwise they are considered negative segments in $\mathcal { O } ^ { - }$ (Fig. 4c: all the segments in the Row 3 image). In particular, all the segments in pixel $i$ ’s image are in ${ \bar { \mathcal { O } } } ^ { + }$ of $i$ . This semantic context relationship does not require localized annotations yet imposes regularization on pixel feature learning.
+
+Feature affinity. Our goal is to learn a pixel-wise feature that indicates semantic segmentation. It is thus reasonable to assume that pixels and segments of the same semantics form a cluster in the feature space, and we reinforce such clusters with a featural smoothness prior: We find nearest neighbours in the feature space and propagate labels accordingly.
+
+Specifically, we assign a semantic label to each unlabeled segment by finding its nearest labeled segment in the feature space. We denote this expanded labeled set by $\hat { \mathcal { C } }$ . For pixel $i$ , we define its positive (negative) segment set $\hat { \mathcal { C } } ^ { + } \left( \hat { \mathcal { C } } ^ { - } \right)$ according to whether a segment has the same label as $i$ .
+
+Our feature affinity relationship works best when: 1) the original labeled set is large enough to cover the feature space, 2) the labeled segments are distributed uniformly in the feature space, and 3) the pixel-wise feature already encodes certain semantic information. We thus only apply to DensePose keypoint annotations in our experiments, where each body part is annotated by a point.
+
+# 3.2 PIXEL-WISE METRIC LEARNING LOSS
+
+SegSort (Hwang et al., 2019) is an end-to-end segmentation model that generates a pixel-wise feature map and a resulting segmentation. Assuming independent normal distributions for individual segments, SegSort seeks a maximum likelihood estimation of the feature mapping, so that the feature induced partitioning in the image and clustering across images provide maximum discrimination among segments. During inference, the segment label is predicted by K-Nearest Neighbor retrievals.
+
+The feature induced partitioning in each image is calculated via spherical K-Means clustering (Banerjee et al., 2005). Let $\boldsymbol { e } _ { i }$ denote the feature vector at pixel $i$ , which contains the mapped feature $\phi ( i )$ and $i$ ’s spatial coordinates. Let $z _ { i }$ denote the index of the segment that pixel $i$ belongs to, $\pmb { R } _ { s }$ the set of pixels in segment $s$ , and $\pmb { \mu } _ { s }$ the segment feature calculated as the spherical cluster centroid of segment $s$ . In the Expectation-Maximization (EM) procedure for spherical $\mathbf { K }$ -means, the E-step calculates the most likely segment pixel $i$ belongs to: $z _ { i } = \arg \operatorname* { m a x } _ { s } \pmb { \mu } _ { s } ^ { \prime } \pmb { e } _ { i }$ , and the M-Step updates the segment feature as the mean pixel-wise feature: µs = Pi∈Rs eik Pi∈R eik .
+
+![](images/4372474c7bac351ff0de33bf8a220f92e739999857b394d6bf78afb530066b22.jpg)  
+Figure 5: Our method uses labeled and unlabeled portions of the training data more extensively. a) Training images and their labeled scribbles are sparse and incomplete. b) Existing methods train a pixel-wise classifier using only labeled pixels and propagate labels within each image. c) Our method leverages four types of pixel-to-segment semantic relationships to augment the labeled sets, includes unlabeled pixels (fuller segments than just thin scribbles) and unlabeled segments (e.g. desk outlined in magenta), forms dynamic contrastive relationships between segments (e.g. the desk can be positive, negative, or to be ignored to the sofa in different relations.
+
+Let $s$ denote the resulting segment that pixel $i$ belongs to per spherical clustering. The posterior probability of pixel $i$ in segment $s$ can be evaluated over the set of all segments $S$ as:
+
+$$
+p ( z _ { i } = s | \pmb { e } _ { i } , \pmb { \mu } ) = \frac { \exp ( \kappa \pmb { \mu } _ { s } ^ { \prime } \pmb { e } _ { i } ) } { \sum _ { t \in S } \exp ( \kappa \pmb { \mu } _ { t } ^ { \prime } \pmb { e } _ { i } ) }
+$$
+
+where $\kappa$ is a concentration hyper-parameter. SegSort minimizes the negative log-likelihood loss:
+
+$$
+L _ { \mathrm { S e g S o r t } } ( i ) = - \log p ( z _ { i } = s | e _ { i } , \mu ) = - \log \frac { \exp ( \kappa \mu _ { s } ^ { \prime } e _ { i } ) } { \sum _ { t \in S } \exp ( \kappa \mu _ { t } ^ { \prime } e _ { i } ) } .
+$$
+
+SegSort adopts soft neighborhood assignment (Goldberger et al., 2005) to further strengthen the grouping of same-category segments. Let ${ \mathcal { C } } ^ { + } \left( { \mathcal { C } } ^ { - } \right)$ denote the index set of segments in the same (different) category as pixel $i$ except $s -$ the segment $i$ belongs to. We have:
+
+$$
+L _ { \mathrm { S e g S o r t ^ { + } } } ( i , \mathcal { C } ^ { + } , \mathcal { C } ^ { - } ) = - \log \sum _ { t \in \mathcal { C } ^ { + } } p ( z _ { i } = t | e _ { i } , \mu ) = - \log \frac { \sum _ { t \in \mathcal { C } ^ { + } } \exp ( \kappa \mu _ { t } ^ { \prime } e _ { i } ) } { \sum _ { t \in \mathcal { C } ^ { + } \cup \mathcal { C } ^ { - } } \exp ( \kappa \mu _ { t } ^ { \prime } e _ { i } ) } .
+$$
+
+For our weakly supervised segmentation, the total pixel-to-segment contrastive loss for pixel $i$ consists of 4 terms, one for each of the 4 pixel-to-segment attraction and repulsion relationships:
+
+$$
+\begin{array} { r l } & { L ( i ) = \lambda _ { I } L _ { \mathrm { S e g S o r t } ^ { + } } ( i , \mathcal { V } ^ { + } , \mathcal { V } ^ { - } ) + \lambda _ { C } L _ { \mathrm { S e g S o r t } ^ { + } } ( i , \mathcal { C } ^ { + } , \mathcal { C } ^ { - } ) } \\ & { \qquad + \lambda _ { O } L _ { \mathrm { S e g S o r t } ^ { + } } ( i , \mathcal { O } ^ { + } , \mathcal { O } ^ { - } ) + \lambda _ { A } L _ { \mathrm { S e g S o r t } ^ { + } } ( i , \mathcal { \hat { C } } ^ { + } , \mathcal { \hat { C } } ^ { - } ) , } \end{array}
+$$
+
+where $\lambda _ { C } = 1$ . Fig. 5 shows how our metric learning method utilizes labeled and unlabeled pixels and segments more extensively than existing classification methods: Our pseudo-labeled sets are fuller than labeled thin scribbles and include unlabeled segments; there are 3 more relationships other than semantic annotations; our segments participate in contrastive learning with dynamic roles in different relations. By easily integrating a full range of pixel-to-segment attraction and repulsion relationships from low-level image similarity to mid-level feature affinity, and to high-level semantic co-occurrence, we go far beyond the direct supervision from semantic annotations.
+
+# 4 EXPERIMENTS ON PASCAL VOC AND DENSEPOSE
+
+Datasets. Pascal VOC 2012 Everingham et al. (2010) includes 20 object categories and one background class. Following Chen et al. (2017), we use the augmented training set with 10,582 images and validation set with 1,449 images. We use the scribble annotations provided by Lin et al.
+
+<table><tr><td>Dataset</td><td>Annotation</td><td>入1</td><td>入</td><td>入A</td></tr><tr><td rowspan="4">Pascal</td><td> image tags</td><td>0.3</td><td>1.0</td><td>0.0</td></tr><tr><td>boxes</td><td>0.3</td><td>1.0</td><td>0.0</td></tr><tr><td>points</td><td>1.0</td><td>1.0</td><td>0.0</td></tr><tr><td>scribbles</td><td>0.1</td><td>0.5</td><td>0.0</td></tr><tr><td>DensePose</td><td>points</td><td>0.1</td><td>0.0</td><td>0.5</td></tr></table>
+
+Table 1: Hyper-parameters for different types of annotations on Pascal and DensePose dataset.
+
+(2016) for training. DensePose (Alp Guler et al., 2018) is a human pose parsing dataset based on ¨ MSCOCO (Lin et al., 2014). The dataset is annotated with 14 body part classes. We extract the keypoints from the center of each part segmentation. The training set includes 26,437 images and we use minival2014 set for testing, which includes 1,508 images. See Appendix for more details.
+
+Architecture, training and testing. For all the experiments on PASCAL VOC, we base our architecture on DeepLab (Chen et al., 2017) with ResNet101 (He et al., 2016) as the backbone network. For the experiments on DensePose, we adopt PSPNet (Zhao et al., 2017) as the backbone network. Our models are pre-trained on ImageNet (Deng et al., 2009) dataset. See Appendix for details on our inference procedure and hyper-parameter selection for training and testing.
+
+For each type of annotations and dataset, we formulate four types of pixel-to-segment contrastive relationships and jointly optimize them in a single pixel-wise metric learning framework (Fig. 3). Table 1 shows the data-driven selection of hyperparameters $\lambda _ { I } , \lambda _ { O }$ and $\lambda _ { A }$ for different task settings.
+
+Pascal: Image tag annotations. Table 2 shows that, without using additional saliency labels, our method outperforms existing methods with saliency by $4 . 4 \%$ , and those without saliency by $5 . 1 \%$ .
+
+Pascal: Bounding box annotations. Table 2 shows that, with the same DeepLab/ResNet101 backbone network, our method outperforms existing methods by $3 . 2 \%$ .
+
+Table 2: Pascal VOC 2012 dataset with image tag (left) and bounding box (right) annotations.   
+
+<table><tr><td rowspan=1 colspan=1>Pascal: Image tags</td><td rowspan=1 colspan=1>Saliency</td><td rowspan=1 colspan=1>val</td><td rowspan=1 colspan=1>test</td></tr><tr><td rowspan=1 colspan=1>Huang et al. (2018)Lee et al. (2019)Zhang et al. (2019)Yao&amp;Gong (2020)Chang et al. (2020)</td><td rowspan=1 colspan=1>√√4</td><td rowspan=1 colspan=1>61.464.966.367.166.1</td><td rowspan=1 colspan=1>63.265.366.567.265.9</td></tr><tr><td rowspan=1 colspan=1>Our SPML</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>69.5</td><td rowspan=1 colspan=1>71.6</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Pascal: Bounding boxes</td><td rowspan=1 colspan=1>val</td><td rowspan=1 colspan=1>test</td></tr><tr><td rowspan=1 colspan=1>Khoreva et al. (2017)Song et al. (2019)</td><td rowspan=1 colspan=1>69.470.2</td><td rowspan=1 colspan=1>1-</td></tr><tr><td rowspan=1 colspan=1>Our SPML</td><td rowspan=1 colspan=1>73.5</td><td rowspan=1 colspan=1>74.7</td></tr></table>
+
+![](images/9fdc4f2b480b8d21b311c6b25e76dffa0d509af1b5856464e461935d96524b53.jpg)
+
+Table 3: Pascal VOC 2012 dataset using scribble annotations. Left: mIoU on validataion (white) and test (gray) set. WvF denotes relative mIoU w.r.t full supervision. Right: Relative mIoU performance w.r.t full supervision on different lengths of scribbles.   
+
+<table><tr><td rowspan=1 colspan=1>Pascal: Scribbles</td><td rowspan=1 colspan=1>CRF</td><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>Weak WvF</td></tr><tr><td rowspan=2 colspan=1>Tang et al. (2018a)Tang et al. (2018a)Tang et al. (2018b)Tang et al. (2018b)Wang et al. (2019)Wang et al. (2019)</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>75.6</td><td rowspan=1 colspan=1>72.8  96.3</td></tr><tr><td rowspan=1 colspan=1>√√</td><td rowspan=1 colspan=1>76.875.676.875.676.8</td><td rowspan=1 colspan=1>74.5  97.073.0  96.675.0  97.773.2  96.876.0  99.0</td></tr><tr><td rowspan=1 colspan=1>Our SPMLOur SPML</td><td rowspan=1 colspan=1>厂</td><td rowspan=1 colspan=1>76.177.3</td><td rowspan=1 colspan=1>74.2  97.576.1  98.4</td></tr></table>
+
+Pascal: Scribble annotations. Table 3 shows that, our method consistently delivers the best performance among methods without or with CRF post-processing. We get ${ \mathrm { 7 4 . 2 \% } }$ $( 7 6 . 1 \% )$ mIoU, achieving $9 7 . 5 \%$ ( $9 8 . 4 \% )$ of full supervision performance in these two categories respectively.
+
+Pascal: Varying sparsity of scribble and point annotations. Exploiting metric learning with different relationships in the data frees us from the classification framework and delivers a more powerful approach that requires fewer annotations. Table 3 shows that, as we shorten the length of scribbles from $1 0 0 \%$ , $8 0 \%$ , $5 0 \%$ , $3 0 \%$ to $0 \%$ (points), we reach $9 7 . 5 \%$ , $9 7 . 5 \%$ , $9 6 . 3 \%$ , $9 6 . 5 \%$ and $9 3 . 7 \%$ of full supervision performance. Compared to the full scribble annotations, our accuracy only drops $3 . 7 \%$ with point labels and is significantly better than the baseline.
+
+![](images/2e28ebadfcde0c3871f2ca5ec0c212a1098a100a676e220339644f3f29497d59.jpg)  
+Figure 6: Our results on Pascal and DensePose under various weak supervision settings are consistently better aligned with region boundaries and visually closer to fully supervised counterparts.
+
+![](images/b027b65eeabba2085aa8c49537d4a98a06c8c2d606c10c0ee0379a2ceb62ae0f.jpg)  
+Figure 7: Our segmentation results get better with more types of regularizations. We compare visual results by adding more regularizations. As we introduce more relationships for regularization, we observe significant improvement and our results are visually closer to fully supervised counterparts.
+
+<table><tr><td rowspan=1 colspan=1>DensePose: Points</td><td rowspan=1 colspan=1>mIoU</td><td rowspan=1 colspan=1>WvF</td></tr><tr><td rowspan=1 colspan=1>Tang et al. (2018b)</td><td rowspan=1 colspan=1>31.3</td><td rowspan=1 colspan=1>51.9</td></tr><tr><td rowspan=1 colspan=1>Our SPML</td><td rowspan=1 colspan=1>44.2</td><td rowspan=1 colspan=1>77.1</td></tr></table>
+
+Table 4: DensePose minival 2014 set.
+
+DensePose: Point annotations. We train our baseline using the code released by Tang et al. (2018b). Table 4 shows that, our method without CRF post-processing outperforms the baseline by $1 2 . 9 \%$ mIoU, reaching $7 7 . 1 \%$ of full supervision performance with only point supervision.
+
+Visual quality and ablation study. Fig. 6 shows that our results are better aligned with region boundaries and visually closer to fully-supervised counterparts. Fig. 7 shows that our results improve significantly with different relationships for more regularization. See Appendix for more details and ablation studies.
+
+Summary. We propose a novel weakly-supervised semantic segmentation method via Semisupervised Pixel-wise Metric Learning, based on four common types of pixel-to-segment attraction and repulsion relationships. It is universally applicable to various weak supervision settings, whether the training images are coarsely annotated by image tags or bounding boxes, or sparsely annotated by keypoints or scribbles. Our results on PASCAL VOC and DensePose show consistent and substantial gains over SOTA, especially for the sparsest keypoint supervision.
+
+Acknowledgements. This work was supported, in part, by Berkeley Deep Drive and Berkeley AI Research Commons with Facebook. This work used the Extreme Science and Engineering Discovery Environment (XSEDE), which is supported by National Science Foundation grant number ACI-1548562. Specifically, it used the Bridges system, which is supported by NSF award number ACI-1445606, at the Pittsburgh Supercomputing Center (PSC).
+
+# REFERENCES
+
+Jiwoon Ahn and Suha Kwak. Learning pixel-level semantic affinity with image-level supervision for weakly supervised semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4981–4990, 2018.
+
+Rıza Alp Guler, Natalia Neverova, and Iasonas Kokkinos. Densepose: Dense human pose estimation ¨ in the wild. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7297–7306, 2018.
+
+Nikita Araslanov and Stefan Roth. Single-stage semantic segmentation from image labels. Proceedings of the IEEE conference on computer vision and pattern recognition, 2020.
+
+Pablo Arbelaez, Michael Maire, Charless Fowlkes, and Jitendra Malik. Contour detection and hierarchical image segmentation. IEEE transactions on pattern analysis and machine intelligence, 33(5):898–916, 2010.
+
+Arindam Banerjee, Inderjit S Dhillon, Joydeep Ghosh, and Suvrit Sra. Clustering on the unit hypersphere using von mises-fisher distributions. Journal of Machine Learning Research, 2005.
+
+Amy Bearman, Olga Russakovsky, Vittorio Ferrari, and Li Fei-Fei. What’s the point: Semantic segmentation with point supervision. In European conference on computer vision, pp. 549–565. Springer, 2016.
+
+Yu-Ting Chang, Qiaosong Wang, Wei-Chih Hung, Robinson Piramuthu, Yi-Hsuan Tsai, and MingHsuan Yang. Weakly-supervised semantic segmentation via sub-category exploration. Proceedings of the IEEE conference on computer vision and pattern recognition, 2020.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE transactions on pattern analysis and machine intelligence, 40(4): 834–848, 2017.
+
+Kevin Clark, Thang Luong, and Quoc V Le. Cross-view training for semi-supervised learning. arXiv preprint arXiv:1809.08370, 2018.
+
+Jifeng Dai, Kaiming He, and Jian Sun. Boxsup: Exploiting bounding boxes to supervise convolutional networks for semantic segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1635–1643, 2015.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.
+
+Mark Everingham, Luc Van Gool, Christopher KI Williams, John Winn, and Andrew Zisserman. The pascal visual object classes (voc) challenge. IJCV, 2010.
+
+Junsong Fan, Zhaoxiang Zhang, Chunfeng Song, and Tieniu Tan. Learning integral objects with intra-class discriminator for weakly-supervised semantic segmentation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+Rob Fergus, Yair Weiss, and Antonio Torralba. Semi-supervised learning in gigantic image collections. In Advances in neural information processing systems, pp. 522–530, 2009.
+
+Jacob Goldberger, Geoffrey E Hinton, Sam T Roweis, and Ruslan R Salakhutdinov. Neighbourhood components analysis. In NIPS, 2005.
+
+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, pp. 770–778, 2016.
+
+Zilong Huang, Xinggang Wang, Jiasi Wang, Wenyu Liu, and Jingdong Wang. Weakly-supervised semantic segmentation network with deep seeded region growing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7014–7023, 2018.
+
+Jyh-Jing Hwang, Stella X Yu, Jianbo Shi, Maxwell D Collins, Tien-Ju Yang, Xiao Zhang, and Liang-Chieh Chen. Segsort: Segmentation by discriminative sorting of segments. In ICCV, 2019.
+
+Thorsten Joachims. Transductive learning via spectral graph partitioning. In Proceedings of the 20th International Conference on Machine Learning (ICML-03), pp. 290–297, 2003.
+
+Anna Khoreva, Rodrigo Benenson, Jan Hosang, Matthias Hein, and Bernt Schiele. Simple does it: Weakly supervised instance and semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 876–885, 2017.
+
+Durk P Kingma, Shakir Mohamed, Danilo Jimenez Rezende, and Max Welling. Semi-supervised learning with deep generative models. In Advances in neural information processing systems, pp. 3581–3589, 2014.
+
+Alexander Kolesnikov and Christoph H Lampert. Seed, expand and constrain: Three principles for weakly-supervised image segmentation. In European Conference on Computer Vision, pp. 695–711. Springer, 2016.
+
+Philipp Krahenb ¨ uhl and Vladlen Koltun. Efficient inference in fully connected crfs with gaussian ¨ edge potentials. In Advances in neural information processing systems, pp. 109–117, 2011.
+
+Jungbeom Lee, Eunji Kim, Sungmin Lee, Jangho Lee, and Sungroh Yoon. Ficklenet: Weakly and semi-supervised semantic image segmentation using stochastic inference. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5267–5276, 2019.
+
+Kunpeng Li, Ziyan Wu, Kuan-Chuan Peng, Jan Ernst, and Yun Fu. Tell me where to look: Guided attention inference network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9215–9223, 2018.
+
+Di Lin, Jifeng Dai, Jiaya Jia, Kaiming He, and Jian Sun. Scribblesup: Scribble-supervised convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3159–3167, 2016.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Bin Liu, Zhirong Wu, Han Hu, and Stephen Lin. Deep metric transfer for label propagation with limited annotated data. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pp. 0–0, 2019.
+
+Ce Liu, Jenny Yuen, and Antonio Torralba. Nonparametric scene parsing via label transfer. PAMI, 2011.
+
+Takeru Miyato, Shin-ichi Maeda, Masanori Koyama, and Shin Ishii. Virtual adversarial training: a regularization method for supervised and semi-supervised learning. IEEE transactions on pattern analysis and machine intelligence, 41(8):1979–1993, 2018.
+
+Nicholas A Nystrom, Michael J Levine, Ralph Z Roskies, and J Ray Scott. Bridges: a uniquely flexible hpc resource for new communities and data analytics. In Proceedings of the 2015 XSEDE Conference: Scientific Advancements Enabled by Enhanced Cyberinfrastructure, pp. 1–8, 2015.
+
+George Papandreou, Liang-Chieh Chen, Kevin P Murphy, and Alan L Yuille. Weakly-and semisupervised learning of a deep convolutional network for semantic image segmentation. In Proceedings of the IEEE international conference on computer vision, pp. 1742–1750, 2015.
+
+Deepak Pathak, Philipp Krahenbuhl, and Trevor Darrell. Constrained convolutional neural networks for weakly supervised segmentation. In Proceedings of the IEEE international conference on computer vision, pp. 1796–1804, 2015.
+
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Advances in neural information processing systems, pp. 3546–3554, 2015.
+
+Bryan Russell, Alyosha Efros, Josef Sivic, Bill Freeman, and Andrew Zisserman. Segmenting scenes by matching image composites. In NIPS, 2009.
+
+Wataru Shimoda and Keiji Yanai. Self-supervised difference detection for weakly-supervised semantic segmentation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 5208–5217, 2019.
+
+Chunfeng Song, Yan Huang, Wanli Ouyang, and Liang Wang. Box-driven class-wise region masking and filling rate guided loss for weakly supervised semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3136–3145, 2019.
+
+Guolei Sun, Wenguan Wang, Jifeng Dai, and Luc Van Gool. Mining cross-image semantics for weakly supervised semantic segmentation. In ECCV, 2020.
+
+Meng Tang, Abdelaziz Djelouah, Federico Perazzi, Yuri Boykov, and Christopher Schroers. Normalized cut loss for weakly-supervised cnn segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1818–1827, 2018a.
+
+Meng Tang, Federico Perazzi, Abdelaziz Djelouah, Ismail Ben Ayed, Christopher Schroers, and Yuri Boykov. On regularized losses for weakly-supervised cnn segmentation. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 507–522, 2018b.
+
+Antti Tarvainen and Harri Valpola. Mean teachers are better role models: Weight-averaged consistency targets improve semi-supervised deep learning results. In Advances in neural information processing systems, pp. 1195–1204, 2017.
+
+Joseph Tighe and Svetlana Lazebnik. Superparsing: scalable nonparametric image parsing with superpixels. In ECCV, 2010.
+
+John Towns, Timothy Cockerill, Maytal Dahan, Ian Foster, Kelly Gaither, Andrew Grimshaw, Victor Hazlewood, Scott Lathrop, Dave Lifka, Gregory D Peterson, et al. Xsede: accelerating scientific discovery. Computing in science & engineering, 16(5):62–74, 2014.
+
+Bin Wang, Guojun Qi, Sheng Tang, Tianzhu Zhang, Yunchao Wei, Linghui Li, and Yongdong Zhang. Boundary perception guidance: A scribble-supervised semantic segmentation approach. International Joint Conference on Artificial Intelligence, 2019.
+
+Yude Wang, Jie Zhang, Meina Kan, Shiguang Shan, and Xilin Chen. Self-supervised equivariant attention mechanism for weakly supervised semantic segmentation. Proceedings of the IEEE International Conference on Computer Vision, 2020.
+
+Jason Weston, Fred´ eric Ratle, Hossein Mobahi, and Ronan Collobert. Deep learning via semi- ´ supervised embedding. In Neural networks: Tricks of the trade, pp. 639–655. Springer, 2012.
+
+Zhirong Wu, Alexei A Efros, and Stella X Yu. Improving generalization via scalable neighborhood component analysis. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 685–701, 2018a.
+
+Zhirong Wu, Yuanjun Xiong, Stella X Yu, and Dahua Lin. Unsupervised feature learning via nonparametric instance discrimination. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3733–3742, 2018b.
+
+Saining Xie and Zhuowen Tu. Holistically-nested edge detection. In Proceedings of the IEEE international conference on computer vision, pp. 1395–1403, 2015.
+
+Jia Xu, Alexander G Schwing, and Raquel Urtasun. Learning to segment under various forms of weak supervision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3781–3790, 2015.
+
+Qi Yao and Xiaojin Gong. Saliency guided self-attention network for weakly and semi-supervised semantic segmentation. IEEE Access, 8:14413–14423, 2020.
+
+Bingfeng Zhang, Jimin Xiao, Yunchao Wei, Mingjie Sun, and Kaizhu Huang. Reliability does matter: An end-to-end weakly supervised semantic segmentation approach. arXiv preprint arXiv:1911.08039, 2019.
+
+Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2881–2890, 2017.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2921–2929, 2016.
+
+Dengyong Zhou, Olivier Bousquet, Thomas N Lal, Jason Weston, and Bernhard Scholkopf. Learn- ¨ ing with local and global consistency. In Advances in neural information processing systems, pp. 321–328, 2004.
+
+# A APPENDIX
+
+We propose a single pixel-to-segment contrastive learning loss formulation for weakly supervised semantic segmentation. We explore different types of visual relationships to group and separate pixels within and across images. We demonstrate state-of-the-art performance using our proposed method with different types of annotations. Here, we include more details on the following aspects:
+
+• We present the visual results of our method in A.1.   
+• We showcase the semantic cues generated by CAM for image tag and bounding box annotations in A.2.   
+• We illustrate the data pre-processing used for DensePose dataset in A.3.   
+• We describe the details of our experimental settings, hyper-parameters and inference procedure in A.4. We present the ablation study regarding hyper-parameters in A.5.   
+• We present mIoU performance with varying sparsity of scribble annotations on Pascal dataset in A.6.   
+• We present per-category results with Pascal and DensePose dataset in A.7.
+
+# A.1 VISUALIZATION
+
+We present the visual results on VOC (with image tags, bounding boxes and scribbles) and DensePose (with keypoints) dataset in figure 8. We observe that our segmentation results are better aligned with image boundary. When visual evidence is prominent, our weakly-supervised results are even better than the fully-supervised counterpart.
+
+We then demonstrate the efficacy of each visual relationship in figure 9. By adding semantic annotation, low-level image similarity and feature affinity progressively, we observe consistent improvement of our results. The predicted segmentation becomes more coherent and better aligned with image boundary. We lastly showcase that our method implicitly encodes semantic contexts. In figure 10, We observe that retrieved segments appear in the similar semantic context as the query segments. For examples, given a bottle next to a desktop, our model retrieves bottles also next to a desktop; a set of sofas in a living room can be retrieved using one sofa query example; screens of a desktop can also be retrieved likewise.
+
+# A.2 SEMANTIC ANNOTATIONS
+
+Since image tag and bounding box annotations do not provide any of precisely localized semantic information, we adopt CAM (Zhou et al., 2016) to produce localized semantic cues. Without using additional saliency labels, we use the classifier trained by Wang et al. (2020) to generate CAM. Let $\mathcal { M } _ { c }$ be the activation map of class $c$ .
+
+For image tag annotations, we follow Ahn & Kwak (2018) to normalize $\mathcal { M } _ { c }$ of the entire image within the range between 0 and 1, where $\begin{array} { r } { \mathcal { M } _ { c } = \frac { \mathcal { M } _ { c } } { \operatorname* { m a x } _ { c } \mathcal { M } _ { c } } } \end{array}$ . The background confidence $\mathcal { M } _ { b g }$ can then be estimated by $\mathcal { M } _ { b g } = ( 1 - \operatorname* { m a x } _ { c } \mathcal { M } _ { c } ) ^ { \alpha }$ , where $\alpha$ is the hyper-parameter adjusting background confidence. In our experiments, we set $\alpha$ to 6 and confidence threshold to 0.2. The low-confidence pixels are considered as unlabeled regions.
+
+For bounding box annotations, we simply normalize the CAM logits within each bounding box to the range between 0 and 1. We then set confidence threshold to 0.5 for selecting foreground pixels and unlabeled regions. We restrict all the regions outside bounding boxes as “background”. See figure 11 for more visual examples.
+
+# A.3 DATA PRE-PROCESSING FOR DENSEPOSE DATASET
+
+We next illustrate our pre-processing to generate training labels given keypoint annotations in DensePose dataset. As shown in figure 12, we first assume a Gaussian heat map from every keypoint. By thresholding, we derive 3 regions from every Gaussian blob: labelled, unknown and background region. In labelled region, pixels are annotated as each body part. We then propagate labels, including background class, to pixels in the unknown region. The std of Gaussian heat map is estimated from instance size, and we use ground-truth information in our paper.
+
+# A.4 HYPER-PARAMETERS AND EXPERIMENTAL SETUP
+
+Architecture and training. For all the experiments on VOC, we base our architecture as DeepLab (Chen et al., 2017) with ResNet101 (He et al., 2016) as backbone network. For the experiments on DensePose dataset, we adopt PSPNet (Zhao et al., 2017) as backbone network. We only use models pre-trained on ImageNet (Deng et al., 2009) dataset.
+
+![](images/31ff0b10c84c0836105dd5311860c606b1bae4067ce809fae3be1c90c39aa2ad.jpg)  
+Figure 8: Visual comparison of baseline method (c), our SPML (d) and fully-supervised SegSort (e) on VOC and DensePose. On VOC (top 6 rows), our baseline method is based on Lee et al. (2019); Song et al. (2019); Tang et al. (2018b) for image tag, bounding box and scribble annotations, respectively. On DensePose (bottom 2 rows), our baseline is Tang et al. (2018b). The results from our weakly-supervised model is visually very close to its fully-supervised counterpart, or even better when visual cues are prominent.
+
+![](images/4ace0a80edb6b2a964f37d426727f62b7d982e77fff5f57cf9e1b098913b8a3b.jpg)  
+Figure 9: Our segmentation results get better with more types of regularizations. We compare visual results by adding more regularizations. As we introduce more relationships for regularization, we observe significant improvement and our results are visually closer to fully supervised counterparts.
+
+We next describe the hyper-parameters used for each experiment. On Pascal VOC dataset, we set “batchsize” to 12 and 16 for scribble / point and image tag / bounding box annotations. On DensePose dataset, “batchsize” is set to 16. For all the experiments, we train our models with $5 1 2 \times 5 1 2$ “cropsize”. Following Chen et al. (2017), we adopt poly learning rate policy by multiplying base learning rate by 1 − ( itermax iter ) . We set initial learning rate to 0.003, momentum to 0.9. For the hyper-parameters in SegSort framework, we use unit-length normalized embedding of dimension 64 and 32 on VOC and DensePose, respectively. We iterate K-Means clustering for 10 iterations and generate 36 and 144 clusters on VOC and DensePose dataset. We set the concentration parameter $\kappa$ to different values for semantic annotation, low-level image similarity, semantic co-occurrence and feature affinity, respectively. Moreover, $\lambda _ { I } , \lambda _ { O }$ and $\lambda _ { A }$ are set to different values according to different types of annotations and datasets. $\lambda _ { C }$ is set to 1 among all the experiments. The detailed hyper-parameter settings are summarized in table 5. We train for $3 0 k$ and $4 5 k$ iterations on VOC and DensePose dataset for all the experiments. We use additional memory banks to cache up previous 2 batches. For conducting experiments, we take advantage of XSEDE infrastructure (Towns et al., 2014) that includes Bridges resources (Nystrom et al., 2015).
+
+![](images/813e1b11bb499e261206695e7909433d6a5e7e55109dbb2103d64adbb2098ab5.jpg)  
+Figure 10: Visual examples of nearest neighbor segment retrievals. We observe that retrieved segments (right) appear in the similar semantic context as the query segments (left). For examples, given a bottle next to a desktop, our model retrieves bottles also next to a desktop.
+
+![](images/39e3bac3c41bc050d3f62330b600b24a1be213a6931ea2e0ab01605f34258f94.jpg)  
+Figure 11: Visual examples of semantic annotations used on VOC. For image tag and bounding box annotation, we use the classifier trained by Wang et al. (2020) to infer CAM as semantic annotation. These semantic annotations are noisy, which do not precisely localize on the objects.
+
+Inference and testing. We fix the learned pixel-wise embedding and train an additional softmax classifier for inference. Iterative training is adopted to bootstrap the semantic segmentation prediction. Notably, we do not propagate gradients to the segmentation CNN from the softmax classifier.
+
+For scribbles / points $/$ bounding boxes, we first learn an initial softmax classifier $S _ { 1 }$ from the corresponding weak annotations. Following Ahn & Kwak (2018), we apply random walk to refine the semantic logits $\tilde { \mathcal { M } }$ generated by $S _ { 1 }$ . The transition probability matrix $T$ is formulated as follows: $\begin{array} { r } { T _ { i , j } = ( \frac { \exp ( \gamma \pmb { e } _ { i } ^ { \top } \pmb { e } _ { j } ) } { \sum _ { j } \exp ( \gamma \pmb { e } _ { i } ^ { \top } \pmb { e } _ { j } ) } ) ^ { \beta } } \end{array}$ , where $\beta$ and $\gamma$ are 20 and 5, respectively. The label propagation is given by: $\tilde { \mathcal { M } } ^ { \prime } = T ^ { \top } \tilde { \mathcal { M } }$ , where $\tilde { \mathcal { M } } ^ { \prime }$ denotes refined semantic logits. The random walk process is iterated for 6 times. Next, we obtain the corresponding pseudo labels $\mathcal { V } _ { s c } = \arg \operatorname* { m a x } _ { c } \tilde { \mathcal { M } } _ { c } ^ { \prime }$ . The pseudo labels are used to train the final softmax classifier $S _ { 2 }$ for predicting semantic segmentation.
+
+For image tag annotations, we adopt both within-image and across-image label propagation to generate optimal pseudo labels. Starting with CAM logits $\mathcal { M }$ , we conduct within-image label propagation thru random walk and obtain refined pseudo labels $\mathcal { \ V } _ { c a m } ^ { 1 }$ . Across-image label propagation is carried out by nearest neighbor search thru the whole training set. We refer to SegSort (Hwang et al., 2019) for more details. We then obtain refined pseudo labels ${ \mathcal { V } } _ { n n } ^ { 1 }$ and train the initial softmax classifier $S _ { 1 }$ . Similarly, we use $S _ { 1 }$ to predict pseudo labels $\mathcal { V } _ { s c } ^ { 2 }$ from the training images. Followed by nearest neighbor search, we obtain our final pseudo labels $\bar { \mathcal { V } } _ { n n } ^ { 2 }$ and train the final semantic classifier $S _ { 2 }$ .
+
+![](images/79f458b4e1b28ecd81e8e4ec124b7f905b836008eb78bf62e74a5382ed13199f.jpg)  
+Figure 12: Preparing training labels on DensePose dataset. From left to right are input image, our training labels and ground-truth mask. For each keypoint, a Gaussian heat map is applied to determine labelled, unknown and background region. The white region denotes unknown pixels, to which we propagate labels from annotated or background region.
+
+The inference procedures for different annotations are summarized in algorithm 1 and 2, respectively. For image tags, we adopt multi-scale and horizontally flipping as data augmentation for predicting semantic segmentation. For scribbles / points / bounding boxes, we do not employ data augmentation during the final inference.
+
+Table 5: Hyper-parameters for different types of annotations on Pascal and DensePose dataset.   
+
+<table><tr><td>Dataset</td><td>Annotation</td><td></td><td></td><td>K1|Xc</td><td></td><td>Kc|入o</td><td></td><td>KO|入A</td><td></td><td>KA|batchsize</td></tr><tr><td>VOC</td><td>scribbles</td><td>0.1</td><td>16</td><td>1.0</td><td>6</td><td>0.5</td><td>12</td><td>0.0</td><td>1</td><td>12</td></tr><tr><td></td><td>points</td><td>1.0</td><td>16</td><td>1.0</td><td>6</td><td>1.0</td><td>8</td><td>0.0</td><td>1</td><td>12</td></tr><tr><td></td><td>boxes</td><td>0.3</td><td>16</td><td>1.0</td><td>6</td><td>1.0</td><td>8</td><td>0.0</td><td>1</td><td>16</td></tr><tr><td></td><td> image tags</td><td>0.3</td><td>16</td><td>1.0</td><td>6</td><td>1.0</td><td>8</td><td>0.0</td><td>1</td><td>16</td></tr><tr><td>DensePose</td><td>points</td><td>0.1</td><td>16</td><td>1.0</td><td>6</td><td>0.0</td><td>：</td><td>0.5</td><td>12</td><td>16</td></tr></table>
+
+Algorithm 1: Inference procedure for semantic segmentation using scribble / point / bounding box annotations. Input: Fixed pixel-wise embedding e of the input image and weak annotations ${ \mathcal { V } } _ { w e a k }$ . Output: Semantic segmentation prediction $\mathcal { V } _ { p r e d }$ . /\* Train the initial softmax classifier $\star$ / 1 Train the softmax classifier $S _ { 1 }$ using $y _ { w e a k }$ . /\* Train the final softmax classifier $\star /$ 2 Predict semantic logits from initial softmax classifier: $\tilde { \mathcal { M } } = S _ { 1 } ( \pmb { e } )$ . 3 Calculate pixel-wise transition probability matrix $T$ from $^ e$ . 4 Refine semantic logits by random walk propagation: $\tilde { \mathcal { M } } ^ { \prime } = T ^ { \top } \circ \ldots \circ T ^ { \top } \tilde { \mathcal { M } }$ . 5 Derive pseudo labels from refined semantic logits: $\mathcal { V } _ { s c } = \arg \operatorname* { m a x } _ { c } \tilde { \mathcal { M } } _ { c } ^ { \prime }$ . 6 Train the softmax classifier $S _ { 2 }$ using $\mathcal { \scriptsize { D } } _ { s c }$ . 7 Predict final semantic segmentation $\mathcal { V } _ { p r e d }$ from $S _ { 2 }$ .
+
+<table><tr><td>Algorithm 2: Inference procedure for semantic segmentation using image-level tags.</td></tr><tr><td>Input: Fixed pixel-wise embedding e of the input image and CAMlogits M.</td></tr><tr><td>Output: Semantic segmentation prediction Ypred ·</td></tr><tr><td>/* Train the initial softmax ciassifier */</td></tr><tr><td>Calculate pixel-wise transition probability matrix T from e.</td></tr><tr><td>2 Refine CAM by random walk propagation: M&#x27; = TT 。...o TTM.</td></tr><tr><td>3 Derive pseudo labels from refined CAM: Vlam = arg maxc Mc. 4 Predict new pseudo labels Vnn from Vcam l n using nearest neighbor retrievals.</td></tr><tr><td>5 Train the softmax classifier S1 using Dnn·</td></tr><tr><td>/* Train the final softmax classifier */</td></tr><tr><td>6 Predict pseudo labels V² from initial softmax classifier S1. 7 Predict new pseudo labels Dnn from D2e using nearest neighbor retrievals.</td></tr><tr><td></td></tr><tr><td>9 Predict final semantic segmentation Ypred from S2.</td></tr><tr><td></td></tr></table>
+
+# A.5 ABLATION STUDY OF HYPER-PARAMETERS
+
+We conduct ablation study over different regularizations on Pascal VOC dataset. As shown in table 6, we achieve the most optimal performance on Pascal VOC dataset with $\lambda _ { I } = 0 . 1$ and $\lambda _ { O } = 0 . 5$ . We also observe performance drops 0.4 of mIoU by adding feature affinity regularization. We argue that scribble/box/point annotations are not uniformly distributed across object instance and background, and results in noisy label propagation.
+
+<table><tr><td rowspan=1 colspan=3>xr|入omIoU</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>1.0</td><td rowspan=4 colspan=1>74.174.274.172.8</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0</td></tr></table>
+
+Table 6: Ablation study of different weighting parameters for each objective function on Pascal VOC validation dataset.   
+
+<table><tr><td rowspan=1 colspan=3>x|入omIoU</td></tr><tr><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.5</td><td rowspan=4 colspan=1>73.774.273.571.7</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>0.05</td><td rowspan=1 colspan=1>0.5</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.5</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>入1</td><td rowspan=1 colspan=1>入</td><td rowspan=1 colspan=1>入A</td><td rowspan=1 colspan=1>mIoU</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>71.2</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>72.8</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>74.2</td></tr><tr><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>73.8</td></tr></table>
+
+Table 7: mIoU performance on Pascal VOC 2012 validation set on different lengths of scribble.   
+
+<table><tr><td>Method</td><td>Backbone</td><td>CRF</td><td>Full</td><td>100%</td><td>80%</td><td>50%</td><td>30%</td><td>0%</td></tr><tr><td>Lin et al. (2016) Tang et al. (2018b)</td><td>DeepLab-MSc-LargeFOV DeepLab-MSc-LargeFOV</td><td>√ √</td><td>68.5 68.7</td><td>63.1 66.0</td><td>61.8 65.5</td><td>58.5 64.2</td><td>54.3 62.7</td><td>51.6 57.2</td></tr><tr><td>Our SPML</td><td>DeepLab/ResNet101</td><td></td><td>76.1</td><td>74.2</td><td>74.2</td><td>73.3</td><td>73.4</td><td>71.3</td></tr><tr><td>Our SPML</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>DeepLab/ResNet101</td><td>√</td><td>77.3</td><td>76.1</td><td>75.8</td><td>74.8</td><td>75.0</td><td>73.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+<table><tr><td>Backbone</td><td>aero</td><td>bike</td><td>bird</td><td>boat</td><td>bottle</td><td>bus</td><td></td><td>car</td><td>cat</td><td>chair</td><td>Cow</td><td>table</td><td>dog</td><td>horse</td><td>mbike</td><td>person</td><td>plant</td><td>sheep</td><td>sofa</td><td>train</td><td>tv</td><td>mIoU</td></tr><tr><td>Tang et al. (2018b)</td><td>83.2</td><td>35.8</td><td>82.8</td><td>66.8</td><td>75.1</td><td></td><td>90.9</td><td>83.9</td><td>89.2</td><td>35.8</td><td>82.5</td><td>53.7</td><td>83.4</td><td>83.2</td><td>79.5</td><td>82.2</td><td>57.6</td><td>81.9</td><td>41.6</td><td>81.1</td><td>73.5</td><td>73.2</td></tr><tr><td>Our SPML</td><td>85.8</td><td>37.6</td><td>82.8</td><td>69.6</td><td>75.9</td><td>89.3</td><td></td><td>82.8</td><td>89.7</td><td>38.6</td><td>85.7</td><td>56.7</td><td>85.9</td><td>80.1</td><td>78.1</td><td>84.8</td><td>53.9</td><td>83.7</td><td>49.2</td><td>80.9</td><td>74.4</td><td>74.2</td></tr><tr><td>Tang et al. (2018b)</td><td>86.2</td><td>37.3</td><td>85.5</td><td>69.4</td><td>77.8</td><td>91.7</td><td></td><td>85.1</td><td>91.2</td><td>38.8</td><td>85.1</td><td>55.5</td><td>85.6</td><td>85.8</td><td>81.7</td><td>84.1</td><td>61.4</td><td>84.3</td><td>43.1</td><td>81.4</td><td>74.2</td><td>75.2</td></tr><tr><td>Our SPML</td><td>89.0</td><td>38.4</td><td>86.0</td><td>72.6</td><td>77.9</td><td></td><td>90.0</td><td>83.9</td><td>91.0</td><td>40.0</td><td>88.3</td><td>57.7</td><td>87.7</td><td>82.8</td><td>79.1</td><td>86.5</td><td>57.1</td><td>87.4</td><td>50.5</td><td>81.2</td><td>76.9</td><td>76.1</td></tr></table>
+
+# Table 8: Per-class results on Pascal VOC 2012 validation set. White- and gray-colored background denotes using without- and with- CRF post-processing for inference.
+
+<table><tr><td>Annotations</td><td>aero</td><td>bike</td><td>bird</td><td>boat</td><td>bottle</td><td>bus</td><td>car</td><td>cat</td><td>chair</td><td>cow</td><td>table</td><td>dog</td><td>horse</td><td>mbike</td><td></td><td>person</td><td>plant</td><td>sheep</td><td>sofa</td><td>train</td><td>tv</td><td>mloU</td></tr><tr><td>Full mask</td><td>91.5</td><td>43.5</td><td>83.0</td><td>67.9</td><td>81.7</td><td>89.8</td><td>88.7</td><td>94.6</td><td>37.5</td><td>81.6</td><td></td><td>68.7</td><td>88.8</td><td>82.4</td><td>88.6</td><td>87.6</td><td>64.1</td><td>87.6</td><td>52.7</td><td>76.5</td><td>71.4</td><td>77.3</td></tr><tr><td>Scribbles</td><td>87.0</td><td>36.7</td><td>82.3</td><td>65.5</td><td>79.7</td><td>89.5</td><td>84.8</td><td>90.1</td><td>37.6</td><td>86.3</td><td>63.1</td><td>89.1</td><td>87.8</td><td>83.0</td><td>86.0</td><td></td><td>65.8</td><td>85.8</td><td>60.3</td><td>76.9</td><td>73.0</td><td>76.4</td></tr><tr><td>Points</td><td>83.5</td><td>37.0</td><td>78.4</td><td>61.9</td><td>74.8</td><td>86.4</td><td>83.2</td><td>86.9</td><td>37.9</td><td>85.3</td><td>62.4</td><td>87.2</td><td>84.2</td><td>81.1</td><td>83.1</td><td>64.3</td><td></td><td>85.1</td><td>59.1</td><td>74.0</td><td>66.3</td><td>74.0</td></tr><tr><td>Boxes</td><td>84.1</td><td>36.5</td><td>86.7</td><td>57.6</td><td>75.7</td><td>87.7</td><td>84.8</td><td>89.6</td><td>39.4</td><td>86.4</td><td>57.2</td><td>89.2</td><td>88.0</td><td>82.6</td><td>80.3</td><td></td><td>54.7</td><td>88.2</td><td>55.9</td><td>79.7</td><td>71.6</td><td>74.7</td></tr><tr><td>Tags</td><td>82.1</td><td>38.7</td><td>80.0</td><td>56.9</td><td>73.7</td><td>85.7</td><td>81.0</td><td>86.7</td><td>33.9</td><td>87.7</td><td>60.8</td><td>86.8</td><td>84.9</td><td>81.3</td><td>77.7</td><td>53.2</td><td></td><td>86.5</td><td>50.1</td><td>64.8</td><td>58.4</td><td>71.6</td></tr></table>
+
+Table 9: Per-class results on Pascal VOC 2012 testing set. CRF post-processing is used for inference.
+
+# A.6 MEAN IOU PERFORMANCE WITH VARYING SPARSITY OF SCRIBBLES.
+
+We report absolute mIoU performance by varying sparsity of scribbles on Pascal VOC 2012 validation set. The results are summarized in table 7. Our results are much better with sparser annotation.
+
+# A.7 PER-CATEGORY MIOU ON PASCAL VOC AND DENSEPOSE DATASET.
+
+We next present per-category results on Pascal VOC and Denspose dataset. In table 8, we compare with Tang et al. (2018b) on VOC validation set. Without- and with CRF post-processing, our method outperform the baseline method among most categories by large margin. We further conduct experiments on VOC testing set, using DeepLab as backbone network. In table 9, we can retrieve most performance w.r.t full supervision. We also compare per-category results on DensePose dataset in table 10. We train our baseline method using the code released by Tang et al. (2018b). We outperform the baseline method by large margin in every category.
+
+<table><tr><td>Method</td><td>bg.</td><td>torso</td><td>RHand</td><td>LHand</td><td>LFoot</td><td>RFoot</td><td>RThigh</td><td>LThigh</td><td>RLeg</td><td>LLeg</td><td>LArm</td><td>RArm</td><td>LFarm</td><td>RFarm</td><td>Heaad</td><td>mloU</td><td>WvF</td></tr><tr><td>Softmax</td><td>96.2</td><td>73.7</td><td>61.1</td><td>57.2</td><td>37.2</td><td>37.8</td><td>56.8</td><td>54.8</td><td>49.7</td><td>49.5</td><td>62.0</td><td>63.8</td><td>58.3</td><td>61.5</td><td>84.6</td><td>60.3</td><td></td></tr><tr><td>SegSort</td><td>95.8</td><td>71.9</td><td>57.4</td><td>53.0</td><td>33.4</td><td>33.4</td><td>54.0</td><td>51.8</td><td>46.4</td><td>46.9</td><td>59.2</td><td>61.1</td><td>54.4</td><td>57.9</td><td>83.2</td><td>57.3</td><td>：</td></tr><tr><td>Tang et al. (2018b)</td><td>87.2</td><td>28.3</td><td>37.5</td><td>36.0</td><td>18.9</td><td>19.5</td><td>21.2</td><td>20.8</td><td>16.1</td><td>16.6</td><td>33.9</td><td>35.3</td><td>35.6</td><td>37.6</td><td>25.2</td><td>31.3</td><td>51.9</td></tr><tr><td>OurSPML</td><td>93.8</td><td>57.7</td><td>48.1</td><td>43.2</td><td>22.8</td><td>22.2</td><td>36.6</td><td>35.6</td><td>27.1</td><td>27.6</td><td>42.1</td><td>45.3</td><td>42.0</td><td>45.5</td><td>72.6</td><td>44.2</td><td>77.1</td></tr></table>
+
+Table 10: Per-class results on DensePose minival 2014 set with keypoint annotations. White- and gray-colored background indicates using full and point supervision.

parse/train/S1l6ITVKPS/S1l6ITVKPS.md

@@ -0,0 +1,264 @@
+# AN EXPLICITLY RELATIONAL NEURAL NETWORK ARCHITECTURE
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+With a view to bridging the gap between deep learning and symbolic AI, we present a novel end-to-end neural network architecture that learns to form propositional representations with an explicitly relational structure from raw pixel data. In order to evaluate and analyse the architecture, we introduce a family of simple visual relational reasoning tasks of varying complexity. We show that the proposed architecture, when pre-trained on a curriculum of such tasks, learns to generate reusable representations that better facilitate subsequent learning on previously unseen tasks when compared to a number of baseline architectures. The workings of a successfully trained model are visualised to shed some light on how the architecture functions.
+
+# 1 INTRODUCTION
+
+When humans face novel problems, they are able to draw effectively on past experience with other problems that are superficially very different, but that have similarities on a more abstract, structural level. This ability is essential for lifelong, continual learning, and confers on humans a degree of data efficiency, powers of transfer learning, and a capacity for out-of-distribution generalisation that contemporary machine learning has yet to match (Garnelo et al., 2016; Lake et al., 2017; Marcus, 2018; Smith, 2019). A case may be made that all these issues are different facets of the same underlying challenge, namely the challenge of devising systems that learn to construct general-purpose, reusable representations (McCarthy, 1987; Bengio et al., 2013). A representation is general-purpose and reusable to the extent that it contains information whose domain of application exceeds the context within which it was acquired.
+
+Representations that are general-purpose and reusable improve data efficiency because a system that already knows how to build representations relevant to a novel task (despite its novelty) doesn’t have to learn that task from scratch. Ideally, a system that efficiently exploits general-purpose, reusable representations in this way should be the very same system that learned how to construct them in the first place. Moreover, in learning to solve a novel task using such representations, we should expect the system to learn further representations that are themselves general-purpose and reusable. So, with the exception of the very first representations the system learns, all learning in such a system would in effect be transfer learning, and the process of learning would be inherently cumulative, continual, and lifelong.
+
+One approach to building such a system is to take inspiration from the paradigm of classical, symbolic AI (Garnelo & Shanahan, 2019). Building on the mathematical foundations of first-order predicate calculus, a typical symbolic AI system works by applying logic-like rules of inference to language-like propositional representations whose elements are objects and relations. Thanks to their declarative character and compositional structure, these representations lend themselves naturally to generality and reusability. However, in contrast to contemporary deep learning systems, the representations deployed in classical AI are not usually learned from data but hand-crafted (Harnad, 1990). The aim of the present work is to get the best of both worlds with an end-to-end differentiable neural network architecture that builds in propositional, relational priors in much the same way that a convolutional network builds in spatial and locality priors.
+
+The architecture introduced here builds on recent work with non-local network architectures that learn to discover and exploit relational information (Wang et al., 2018), notably relation nets (Santoro et al., 2017; Palm et al., 2018) and architectures based on multi-head attention (Vaswani et al., 2017;
+
+![](images/acbf1ed0a2269cd2c35fb54e2266d14587a8d10a61d982ab809a16e2964290bc.jpg)  
+Figure 1: The PrediNet architecture. $W _ { K }$ and $W _ { S }$ are shared across heads, whereas $W _ { Q 1 }$ and $W _ { Q 2 }$ are local to each head. See main text for more details.
+
+Santoro et al., 2018; Zambaldi et al., 2019). However, these architectures generate representations that lack explicit structure. There is, in general, no straightforward mapping from the parts of a representation to the usual elements of a symbolic medium such as predicate calculus: propositions, relations, and objects. To the extent that these elements are present, they are smeared across the embedding vector, which makes representations hard to interpret and makes it more difficult for downstream processing to take advantage of compositionality.
+
+Here we present an architecture, which we call a PrediNet, that learns representations whose parts map directly onto propositions, relations, and objects. To build a sound, scientific understanding of the proposed architecture, and to facilitate a detailed comparison with other architectures, the present study focuses on simple tasks requiring relatively little data and computation. We develop a family of small, simple visual datasets that can be combined into a variety of multi-task curricula and used to assess the extent to which an architecture learns representations that are general-purpose and reusable. We report the results of a number of experiments using these datasets that demonstrate the potential of an explicitly relational network architecture to improve data efficiency and generalisation, to facilitate transfer, and to learn reusable representations.
+
+The main contribution of the present paper is a novel architecture that learns to discover objects and relations in high-dimensional data, and to represent them in a form that is beneficial for downstream processing. The PrediNet architecture does not itself carry out logical inference, but rather extracts relational structure from raw data that has the potential to be exploited by subsequent processing. Here, for the purpose of evaluation, we graft a simple multi-layer perceptron output module to the PrediNet and train it on a simple set of spatial reasoning problems. The aim is to acquire a sufficient scientific understanding of the architecture and its properties in this minimalist setting before applying it to more complex problems using more sophisticated forms of downstream inference.
+
+# 2 THE PREDINET ARCHITECTURE
+
+The idea that propositions are the building blocks of knowledge dates back to the ancient Greeks, and provides the foundation for symbolic AI, via the $1 9 ^ { \mathrm { t h } }$ century mathematical work of Boole and Frege (Russell & Norvig, 2009). An elementary proposition asserts that a relationship holds between a set of objects. Propositions can be combined using logical connectives (and, or, not, etc), and can participate in inference processes such as deduction. The task of the PrediNet is to (learn to) transform high-dimensional data such as images into propositional representations that are useful for downstream processing. A PrediNet module (Fig. 1) can be thought of as a pipeline comprising three stages: attention, binding, and evaluation. The attention stage selects pairs of objects of interest, the binding stage instantiates the first two arguments of a set of three-place predicates (relations) with selected object pairs, and the evaluation stage computes values for each predicate’s remaining (scalar) argument such that the resulting proposition is true.
+
+More precisely, a PrediNet module comprises $k$ heads, each of which computes $j$ relations between pairs of objects (Fig. 1). The input to the PrediNet is a matrix, $L$ , comprising $n$ rows of feature vectors, where each feature vector has length $m$ . In the present work, $L$ is computed by a convolutional neural network (CNN). The CNN outputs a feature map consisting of $n$ feature vectors that tile the input image. The last two elements of the feature vector are the xy co-ordinates of the associated patch in the image. So the length $m$ of each feature vector corresponds to the number of filters in the final CNN layer plus 2 (for the co-ordinates), and the $i ^ { t h }$ element of a feature vector (for $i < m - 2 )$ is the output of the $i ^ { t h }$ filter. For a given input $L$ , each head $h$ computes the same set of relations (using shared weights $W _ { S }$ ) but selects a different pair of objects, using dot-product attention based on key-query matching (Vaswani et al., 2017). Each head computes a separate pair of queries $Q _ { 1 } ^ { h }$ and $Q _ { 2 } ^ { h }$ (via $\dot { W } _ { Q 1 } ^ { \dot { h } }$ and $W _ { . Q 2 } ^ { \tilde { h } } .$ ). But the key space $K$ (defined by $W _ { K }$ ) is shared, so that the set of entities that are candidates for attention is consistent across heads. The whole (flattened) image is used to generate queries, allowing attention masks to depend on the image’s full (non-local) content.
+
+$$
+Q _ { 1 } ^ { h } = \mathrm { H a t t e n } ( L ) W _ { Q 1 } ^ { h } ~ . Q _ { 2 } ^ { h } = \mathrm { H a t t e n } ( L ) W _ { Q 2 } ^ { h } ~ K = L W _ { K }
+$$
+
+Applying the resulting pair of attention masks directly to $L$ yields a pair of objects $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ , each represented by a weighted sum of feature vectors.
+
+$$
+E _ { 1 } ^ { h } = \mathrm { s o f t m a x } ( Q _ { 1 } ^ { h } K ^ { \top } ) L \qquad E _ { 2 } ^ { h } = \mathrm { s o f t m a x } ( Q _ { 2 } ^ { h } K ^ { \top } ) L
+$$
+
+All $j$ relations between $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ are then evaluated. There are many ways to compute a relationship between a pair of objects represented as feature vectors. We chose to compute the values of relations by taking vector differences, which has been shown to be effective in the context of relationally structured knowledge bases (Bordes et al., 2011; Socher et al., 2013). In the current architecture, $E _ { 1 } ^ { \tilde { h } }$ and $E _ { 2 } ^ { h }$ are subject to a linear mapping (via $W _ { S }$ ) into $j$ 1D spaces, one per relation, and the resulting vector is passed through an element-wise comparator, yielding a vector of differences $D ^ { h }$ .
+
+$$
+D ^ { h } = E _ { 1 } ^ { h } W _ { S } - E _ { 2 } ^ { h } W _ { S }
+$$
+
+The last two elements of $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ (the positions $P _ { 1 } ^ { h }$ and $P _ { 2 } ^ { h }$ , respectively) are concatenated to the vector 1 2 1 of differences to give the head’s output $R ^ { h } = \mathsf { \bar { ( } } D ^ { h } , \mathsf { \bar { P } } _ { 1 } ^ { h } , P _ { 2 } ^ { h } )$ . Finally, the outputs of all $k$ heads are concatenated, yielding the output of the PrediNet module, a vector $R ^ { * }$ of length $k ( j + 4 )$ . In predicate calculus terms, the final output of a PrediNet module with $k$ heads and $j$ relations represents the conjunction of elementary propositions
+
+$$
+\Psi \equiv \bigwedge _ { h = 1 } ^ { k } \bigwedge _ { i = 1 } ^ { j } \psi _ { i } ( d _ { i } ^ { h } , e _ { 1 } ^ { h } , e _ { 2 } ^ { h } )
+$$
+
+where $\psi _ { i } ( d _ { i } ^ { h } , e _ { 1 } ^ { h } , e _ { 2 } ^ { h } )$ asserts that $d _ { i } ^ { h }$ is the distance between objects $e _ { 1 } ^ { h }$ and $e _ { 2 } ^ { h }$ in the 1D space defined by column $i$ of the weight matrix $W _ { S }$ , and the denotations of $e _ { 1 } ^ { h }$ and $e _ { 2 } ^ { h }$ are captured by the vectors $\dot { Q } _ { 1 } ^ { h }$ and $Q _ { 2 } ^ { h }$ respectively, given the key-space defined by $K$ .
+
+Equation 1 supplies a semantics for the PrediNet’s final output vector $R ^ { * }$ that maps each of its elements onto a well-defined logical formula, something that cannot be claimed for other architectures, such as the relation net or multi-head attention net. In the experiments reported here, only $R ^ { * }$ is used for downstream processing, and this vector by itself doesn’t have the logical structure described by Equation 1. However, the PrediNet module can easily be extended to deliver an additional output in explicitly propositional form, with a predicate-argument structure corresponding to the RHS of Equation 1. In the present paper, the pared-down vector form facilitates our experimental investigation, but in its explicitly propositional form, the PrediNet’s output could be piped directly to (say) a Prolog interpreter (Fig.7), to an inductive logic programming system, to a statistical relational learning system, or indeed to another differentiable neural module.
+
+# 3 DATASETS AND TASKS
+
+It would be premature to apply the PrediNet architecture to rich, complex data before we have a basic understanding of its properties and its behaviour. To facilitate in-depth scientific study, we need small, simple datasets that allow the operation of the architecture to be examined in detail and the fundamental premises of its design to be assessed. Our experimental goals in the present paper are 1)
+
+to test the hypothesis that the PrediNet architecture learns representations that are general-purpose and reusable, and 2) insofar as this is true, to investigate why. Existing datasets for relational reasoning tasks, such as CLEVR (Johnson et al. (2017)) and sort-of-CLEVR (Santoro et al. (2017)), were ruled out because they include confounding complexities, such as occlusion and shadows or language input, and/or because they don’t lend themselves to the fine-grained task-level splits we required. Consequently, we devised a new configurable family of simple classification tasks that we collectively call the Relations Game.
+
+A Relations Game task involves the presentation of an image containing a number of objects laid out on a $3 \times 3$ grid, and the aim (in most tasks) is to label the image as True or False according to whether a given relationship holds among the objects in the image. While the elementary propositions learned by the PrediNet only assert simple relationships between pairs of entities, Relations Game tasks generally involve learning compound relations involving multiple relationships among many objects. The objects in question are drawn from either a training set or one of two held-out sets (Fig. 2a). None of the shapes or colours in the training set occurs in either of the held-out sets. The training object set contains 8 uniformly coloured pentominoes and their rotations and reflections (37 shapes in all) with 25 possible colours. The first held-out object set contains 8 uniformly coloured hexominoes and their rotations and reflections (46 shapes in all) with 25 possible colours, and the second held-out object set contains only squares, but with a striped pattern of held-out colours.
+
+Each Relations Game task is tied to a given relation. Even with such a simple setup, the number of definable relations among all possible combinations of objects is astronomical $( 2 ^ { ( n + 1 ) ^ { 9 } }$ for $n$ distinct objects), although only a few of them will make intuitive sense. For the present study, we defined a handful of intuitively meaningful relations and generated corresponding labelled datasets comprising $50 \%$ positive and $50 \%$ negative examples. A selection is shown in Fig. 2c. The ‘between�� relation holds iff the image contains three objects in a line in which the outer two objects have the same shape, orientation, and colour. The ‘occurs’ relation holds iff there is an object in the bottom row of three objects that has the same shape, orientation, and colour as the (single) object in the top row. The ‘same’ relation holds iff the image contains two objects of the same shape, orientation, and colour. In each case, we balanced the set of negative examples to ensure that “tricky” images involving pairs of objects with the same colour but different shape or the same shape but different colour occur just as frequently as those with objects that differ in both colour and shape.
+
+# 4 EXPERIMENTAL SETUP
+
+At the top level, each architecture we consider in this paper comprises 1) a single convolutional input layer (CNN), 2) a central module (which might be a PrediNet or a baseline), and 3) a small output multi-layer perceptron (MLP) (Fig. 3). A pair of xy co-ordinates is appended to each CNN feature vector, denoting its position in convolved image space and, where applicable, a one-hot task identifier is appended to the output of the central module. For most tasks, the final output of the MLP is a one-hot label denoting True or False. The PrediNet was evaluated by comparing it to several baselines: two MLP baselines (MLP1 and MLP2), a relation net baseline (Santoro et al., 2017) (RN), and a multi-head attention baseline (Vaswani et al., 2017; Zambaldi et al., 2019) (MHA).
+
+To facilitate a fair comparison, the top-level schematic is identical for the PrediNet and for all baselines (Fig. 3). All use the same input CNN architecture and the same output MLP architecture, and differ only in the central module. In MLP1, the central module is a single fully-connected layer with ReLu activations, while in MLP2 it has two layers. In RN, the central module computes the set of all possible pairs of feature vectors, each of which is passed through a 2-layer MLP; the resulting vectors are then aggregated by taking their element-wise means to yield the output vector. Finally, MHA comprises multiple heads, each of which generates mappings from the input feature vectors to sets of keys $K$ , queries $Q$ , and values $V$ , and then computes softmax $( Q K ^ { \top } ) V$ . Each head’s output is a weighted sum of the resulting vectors, and the output of the MHA central module is the concatenation of all its heads’ outputs. The PrediNet used here comprises $k = 3 2$ heads and $j = 1 6$ relations (Fig. 1). All reported experiments were carried out using stochastic gradient descent, and all results shown are averages over 10 runs. Further experimental details are given in the Supplementary Material, which also shows results for experiments with different numbers of heads and relations, and with the Adam optimiser, all of which present qualitatively similar results.
+
+![](images/59609ae11a5a459a6bb196384a08bfaf14aedced1451207bee625c15ba01e038.jpg)  
+Figure 2: Relations Game object sets and tasks. (a) Example objects from the training set and held-out test sets. (b) There are five possible row / column patterns. In a multi-task setting, recognising each row pattern is a separate task. (c) Three examples tasks for the single-task setting. (d) An example target task (left) and curriculum (right) for the multi-task setting. The curriculum task ids (right) for each of the three examples (2, 4, and 3) correspond to the respective patterns in (b), and the task in each case is to confirm whether or not the column of objects in the image conform to the designated pattern. The aim of the target task (left) is to test whether the two rows of objects have the same pattern according to (b).
+
+![](images/ffea528f48079ce872fba2a4f868b06f50790719756f06c415acd4ebffcd0851.jpg)  
+Figure 3: The four-stage experimental protocol for multi-task curriculum training. The same input module (CNN) and output module (MLP) are used for the PrediNet and all baseline architectures; only the central module varies. Task identifiers are appended to the central module’s output vector.
+
+Table 1: Data efficiency in a single-task Relations Game setting.   
+
+<table><tr><td rowspan=1 colspan=1>Relation</td><td rowspan=1 colspan=1> Object set</td><td rowspan=1 colspan=1>MLP1</td><td rowspan=1 colspan=1>MLP2</td><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>MHA</td><td rowspan=1 colspan=1>PrediNet</td></tr><tr><td rowspan=2 colspan=1>same</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>96.1±0.007</td><td rowspan=1 colspan=1>96.4±0.006</td><td rowspan=1 colspan=1>73.2±0.05</td><td rowspan=1 colspan=1>94.7±0.1</td><td rowspan=1 colspan=1>100±0.0</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>93.3±0.01</td><td rowspan=1 colspan=1>94.0±0.01</td><td rowspan=1 colspan=1>72.9±0.05</td><td rowspan=1 colspan=1>93.7±0.1</td><td rowspan=1 colspan=1>100±0.0</td></tr><tr><td rowspan=2 colspan=1>between</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>98.7±0.005</td><td rowspan=1 colspan=1>98.8±0.004</td><td rowspan=1 colspan=1>70.8±0.01</td><td rowspan=1 colspan=1>89.2±0.1</td><td rowspan=1 colspan=1>99.2±0.004</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>96.9±0.008</td><td rowspan=1 colspan=1>97.3±0.004</td><td rowspan=1 colspan=1>65.2±0.05</td><td rowspan=1 colspan=1>85.5±0.1</td><td rowspan=1 colspan=1>98.7±0.007</td></tr><tr><td rowspan=2 colspan=1>occurs</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>88.0±0.01</td><td rowspan=1 colspan=1>94.8±0.03</td><td rowspan=1 colspan=1>61.6±0.01</td><td rowspan=1 colspan=1>88.4±0.2</td><td rowspan=1 colspan=1>98.5±0.009</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>73.2±0.03</td><td rowspan=1 colspan=1>87.3±0.07</td><td rowspan=1 colspan=1>62.6±0.02</td><td rowspan=1 colspan=1>80.8±0.1</td><td rowspan=1 colspan=1>96.9±0.01</td></tr><tr><td rowspan=2 colspan=1>xoccurs</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>81.5±0.02</td><td rowspan=1 colspan=1>84.4±0.04</td><td rowspan=1 colspan=1>55.0±0.009</td><td rowspan=1 colspan=1>54.7±0.008</td><td rowspan=1 colspan=1>95.4±0.01</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>78.2±0.03</td><td rowspan=1 colspan=1>80.8±0.05</td><td rowspan=1 colspan=1>54.0±0.01</td><td rowspan=1 colspan=1>53.6±0.007</td><td rowspan=1 colspan=1>95.5±0.01</td></tr><tr><td rowspan=1 colspan=1>colour/shape</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>53.4±0.07</td><td rowspan=1 colspan=1>55.8±0.05</td><td rowspan=1 colspan=1>45.1±0.05</td><td rowspan=1 colspan=1>88.6±0.03</td><td rowspan=1 colspan=1>94.3±0.01</td></tr></table>
+
+To assess the generality and reusability of the representations produced by the PrediNet, we adopted a four-stage experimental protocol wherein 1) the network is pre-trained on a curriculum of one or more tasks, 2) the weights in the input CNN and PrediNet are frozen while the weights in the output MLP are re-initialised with random values, and 3) the network is retrained on a new target task or set of tasks (Fig. 3). In step 3, only the weights in the output MLP change, so the target task can only be learned to the extent that the PrediNet delivers re-usable representations to it, representations the PrediNet has learned to produce without exposure to the target task. To assess this, we can compare the learning curves for the target task with and without pre-training. We expect pre-training to improve data efficiency, so we should see accuracy increasing more quickly with pre-training than without it. For evidence of transfer, and to confirm the hypothesis of reusability, we are also interested in the final performance on the target task after pre-training, given that the weights of the pre-trained input CNN and PrediNet are frozen. This measure indicates how well a network has learned to form useful representations. The more different the target task is from the pre-training curriculum, the more impressed we should be that the network is able to learn the target task.
+
+# 5 RESULTS
+
+As a prelude to investigating the issues of generality and reusabilty, we studied the data efficiency of the PrediNet architecture in a single-task Relations Game setting. Results obtained on a selection of five tasks – ‘same’, ‘between’, ‘occurs’, ‘xoccurs’, and ‘colour / shape’ – are summarised in Table 1. The first three tasks are as described in Fig. 2. The ‘xoccurs’ relation is similar to occurs. It holds iff the object in the top row occurs in the bottom row and the other two objects in the bottom row are different. The ‘colour / shape’ task involves four labels, rather than the usual two: same-shape / same-colour; different-colour / same-shape; same-colour / different shape; different-colour / different shape. In the dataset for this task, each image contains two objects randomly placed, and one of the four labels must be assigned appropriately. Table 1 shows the accuracy obtained by each of the five architectures after 100,000 batches when tested on the two held-out object sets. The PrediNet is the only architecture that achieves over $90 \%$ accuracy on all tasks with both held-out object sets after 100,000 batches. On the ‘xoccurs’ task, the PrediNet out-performs the baselines by more than $10 \%$ , and on the ‘colour / shape’ task (where chance is $2 5 \%$ ), it out-performs all the baselines except MHA by $2 5 \%$ or more.
+
+Next, using the protocol outlined in Fig. 3, we compared the PrediNet’s ability to learn re-usable representations with each of the baselines. We looked at a number of combinations of target tasks and pre-training curriculum tasks. Fig. 4 depicts our findings for one these combinations in detail, specifically three target tasks corresponding to three of the five possible column patterns (ABA, AAB, and ABB (Fig. 2d)), and a pre-training curriculum comprising the single ‘between’ task. The plots present learning curves for each of the five architectures at each of the four stages of the experimental protocol. In all cases, accuracy is shown for the ‘stripes’ held-out object set (not the training set). Of particular interest are the (green) curves corresponding to Stage 3 of the experimental protocol. These show how well each architecture learns the target task(s) after the central module has been pre-trained on the curriculum task(s) and its weights are frozen. The PrediNet learns faster than any of the baselines, and is the only one to achieve an accuracy of $90 \%$ . The rapid reusability of the representations learned by both the MHA baseline and the PrediNet is noteworthy because the ‘between’ relation by itself seems an unpromising curriculum for subsequently learning the AAB and ABB column patterns. As the (red) curve for Stage 4 of the protocol shows, the reusability of the PrediNet’s representations cannot be accounted for by the pre-training of the input CNN alone.
+
+![](images/2860e394458188b798724c270b033684451f5caaf920cc0a6a6e33ddc565e987.jpg)  
+Figure 4: Multi-task curriculum training. The target tasks are three column patterns (AAB, ABA, and ABB) and the sole curriculum task is the ‘between’ relation.
+
+![](images/f5423c49fb9436252568f8442c7594e6212ab5715afe91d508fa2b743ef6177b.jpg)  
+Figure 5: Reusability of representations learned with a variety of target and pre-training tasks.
+
+Fig. 5 shows a larger range of target task / curriculum task combinations, concentrating exclusively on the Stage 3 learning curves. Here a more complete picture emerges. In both Fig. 5a and Fig. 5d the target task is ‘match rows’ (Fig. 2d), but they differ in their pre-training curricula. The curriculum for Fig. 5d is three of the five row patterns (ABA, AAB, and ABB). This is the only case where the PrediNet does not learn representations that are more useful for the target task than those of all the baselines, outperforming only two of the four. However, when the curriculum is the three analogous column patterns rather than row patterns, the performance of all four baselines collapses to chance, while the PrediNet does well, attaining similar performance as for the row-based curriculum (Fig. 5a). This suggests the PrediNet is able to learn representations that are orientation invariant, which aids transfer. This hypothesis is supported by Fig. 5e, where the target tasks are all five row patterns, while the curriculum is all five column patterns. None of the baselines is able to learn reusable representations in this context; all remain at chance, whereas the PrediNet achieves $8 5 \%$ accuracy.
+
+![](images/6a174e4b0e286837ad4ddd2f7eb1246a74bd089edcd7a1df6f13caf5fbbed88f.jpg)  
+Figure 6: (a) Attention heat maps for the first four heads of a trained PrediNet. Left: trained on the ‘same’ task. Right: trained on the ‘occurs’ task. (b) Principal component analysis. Left: PCA on the output of a selected head for a PrediNet trained on the ‘colour / shape’ task for pentominoes images (training set). Centre: The same PrediNet applied to hexominoes (held-out test set). Right: PCA applied to a representative head of the MHA baseline with pentominoes (training set). (c) Ablation study. Accuracy for PrediNet and MHA on the ‘colour / shape’ task when random subsets of the heads are used at test time. PrediNet\* only samples from heads that attend to the two objects.
+
+To better understand the operation of the PrediNet, we carried out a number of visualisations. One way to find out what the PrediNet’s heads learn to attend is to submit images to a trained network and, for each head $h$ , apply the two attention masks softmax $( Q _ { 1 } ^ { h } K ^ { \top } )$ and softmax $( Q _ { 2 } ^ { h } K ^ { \top } )$ to each of the $n$ feature vectors in the convolved image $L$ . The resulting matrix can then be plotted as a heat map to show how attention is distrubuted over the image. We did this for a number of networks trained in the single-task setting. Fig. 6a shows two examples, and the Supplementary Material contains a more extensive selection. As we might expect, most of the attention focuses on the centres of single objects, and many of the heads pick out pairs of distinct objects in various combinations. But some heads attend to halves or corners of objects. Although most attention is focal, whether directed at object centres or object parts, some heads exhibit diffuse attention, which is possible thanks to the soft key-query matching mechanism. So the PrediNet can (but isn’t forced to) treat the background as a single entity, or to treat an identical pair of objects as a single entity.
+
+To gain some insight into how the PrediNet encodes relations, we carried out principal component analysis (PCA) on each head of the central module’s output vectors for a number of trained networks, again in the single-task setting (Fig. 6b). We chose the four-label ‘colour / shape’ task to train on, and mapped 10,000 example images onto the first two principal components, colouring each with their ground-truth label. We found that, for some heads, differences in colour and shape appear to align along separate axes (Fig. 6b). This contrasts with the MHA baseline, whose heads don’t seem to individually cluster the labels in a meaningful way. For the other baselines, which lack the multi-head organisation of the PrediNet and the MHA network, the only option is to carry out PCA on the whole output vector of the central module. Doing this, however, does not produce interpretable results for any of the architectures (Fig.S8). We also identified the heads in the PrediNet that attended to both objects in the image and found that they overlapped almost entirely with those that meaningfully clustered the labels (Fig.S10). Finally, still using the ‘shape / colour task’, we carried out an ablation study, which showed that the PrediNet is significantly more robust than the MHA network to pruning a random subset of heads at test time. Moreover, if pruned to leave only those heads that attended to the two objects, the performance of the full network could be captured with just a handful of heads (Fig. 6c). Taken together, these results are suggestive of something we might term relational disentangling in the PrediNet.
+
+Finally, to flesh out the claim that the PrediNet generates explicitly relational representations according to the semantics of Equation 1, we extended the PrediNet module to generate an additional output in the form of a Prolog program (Fig. 7). This involves assigning symbolic identifiers 1) to each of the
+
+![](images/04ed67fab717de2f37c9700c1e7f0782803b63aa4fa13ad6a31a8d6925e2f7c2.jpg)  
+Figure 7: PrediNet output in propositional form. (a) A small PrediNet (8 heads, 8 relations) trained on the ‘between’ task is given an image. (b) Mean shift clustering is applied to the set of all attention masks computed by the heads. Each of the resulting 6 clusters is assigned a symbolic identifier. (c) Each relation is also given a symbolic identifier, and all 64 propositions computed by the PrediNet are enumerated in Prolog syntax, in accordance with Equation 1. (A subset is shown.) (d) The results can be combined with further hand-written Prolog clauses. (Upper-case letters denote variables, while constants start with lower-case letters.) (e) Prolog queries can then be submitted. Here we are asking which relations $r$ hold with a small value $v$ between ob_2 and any other object $x$ . (f) The query yields four answers.
+
+PrediNet’s $j$ relations, and 2) to every object picked out by its $k$ heads via the attention masks they compute. Then the corresponding $j \times k$ propositions can be enumerated in Prolog syntax. Assigning symbolic identifiers to the relations is trivial. But because attention masks can differ slightly even when they ostensibly pick out the same region of the input image, it’s necessary to cluster them before assigning symbolic identifiers to the corresponding objects. We used mean shift clustering for this. Fig. 7 presents a sample of the PrediNet’s output in Prolog form, along with an example of deductive inference carried out with this program. The example shown is not intended to be especially meaningful; without further analysis, we lack any intuitive understanding of the relations the PrediNet has discovered. But it demonstrates that the representations the PrediNet produces can be understood in predicate calculus terms, and that symbolic deductive inference is one way (though not the only way) in which they might be deployed downstream.
+
+# 6 RELATED WORK
+
+The need for good representations has long been recognised in AI (McCarthy, 1987; Russell & Norvig, 2009), and is fundamental to deep learning (Bengio et al., 2013). The importance of reusability and abstraction, especially in the context of transfer, is emphasised by Bengio, et al. (Bengio et al., 2013), who argue for feature sets that are “invariant to the irrelevant features and disentangle the relevant features”. Our work here shares this motivation. Other work has looked at learning representations that are disentangled at the feature level (Higgins et al., 2017a; 2018). The novelty of the PrediNet is to incorporate architectural priors that favour representations that are disentangled at the relational and propositional levels. Previous work with relation nets and multi-head attention nets has shown how non-local information can be extracted from raw pixel data and used to solve tasks that require relational reasoning. (Santoro et al., 2017; Palm et al., 2018; Santoro et al., 2018; Zambaldi et al., 2019) But unlike the PrediNet, these networks don’t produce representations with an explicitly relational, propositional structure. By addressing the problem of acquiring structured representations, the PrediNet complements another thread of related work, which is concerned with learning how to carry out inference with structured representations, but which assumes the job of acquiring those representations is done elsewhere (Getoor & Taskar, 2007; Battaglia et al., 2016; Rocktäschel & Riedel, 2017; Evans & Grefenstette, 2018; Dong et al., 2019).
+
+In part, the present work is motivated by the conviction that curricula will be essential to lifelong, continual learning in a future generation of RL agents if they are to exhibit more general intelligence, just as they are for human children. Curricular pre-training has a decade-long pedigree in deep learning (Bengio et al., 2009). Closely related to curriculum learning is the topic of transfer (Bengio, 2012), a hallmark of general intelligence and the subject of much recent attention (Higgins et al., 2017b; Kansky et al., 2017; Schwarz et al., 2018). The PrediNet exemplifies a different (though not incompatible) viewpoint on curriculum learning and transfer from that usually found in the neural network literature. Rather than (or as well as) a means to guide the network, step by step, into a favourable portion of weight space, curriculum learning is here viewed in terms of the incremental accumulation of propositional knowledge. This necessitates the development of a different style of architecture, one that supports the acquisition of propositional, relational representations, which also naturally subserve transfer.
+
+Asai, whose paper was published while the present work was in progress, describes an architecture with some similarities to the PrediNet, but also some notable differences (Asai, 2019). For example, Asai’s architecture assumes an input representation in symbolic form where the objects have already been segmented. By contrast, in the present architecture, the input CNN and the PrediNet’s dotproduct attention mechanism together learn what constitutes an object.
+
+# 7 CONCLUSION AND FURTHER WORK
+
+We have presented a neural network architecture capable, in principle, of supporting predicate logic’s powers of abstraction without compromising the ideal of end-to-end learning, where the network itself discovers objects and relations in the raw data and thus avoids the symbol grounding problem entailed by symbolic AI’s practice of hand-crafting representations (Harnad, 1990). Our empirical results support the view that a network architecturally constrained to learn explicitly propositional, relational representations will have beneficial data efficiency, generalisation, and transfer properties. Although, the present experiments don’t use the fully propositional version of the PrediNet output, the concatenated vector form inherits many of its beneficial properties, notably a degree of compositionality. In particular, one important respect in which the PrediNet differs from other network architectures is the extent to which it canalises information flow; at the core of the network, information is organised into small chunks which are processed in parallel channels that limit the ways the chunks can interact. We believe this pressures the network to learn representations where each separate chunk of information (such as a single value in the vector $R *$ ) has independent meaning and utility. (We see evidence of this in the relational disentanglement of Fig. 6.) The result is a representation whose component parts are amenable to recombination, and therefore re-use in a novel task. But the findings reported here are just the first foray into unexplored architectural territory, and much work needs to be done to gauge the architecture’s full potential.
+
+The focus of the present paper is the acquisition of propositional representations rather than their use. But thanks to the structural priors of its architecture, representations generated by a PrediNet module have a natural semantics compatible with predicate calculus (Equation 1), which makes them an ideal medium for logic-like downstream processes such as rule-based deduction, causal or counterfactual reasoning, and inference to the best explanation (abduction). One approach here would be to stack PrediNet modules and / or make them recurrent, enabling them to carry out the sort of iterated, sequential computations required for such processes (Palm et al., 2018; Dehghani et al., 2019). Another worthwhile direction for further research would be to develop reinforcement learning (RL) agents using the PrediNet architecture. One form of inference of particular interest in this context is model-based prediction, which can be used to endow an RL agent with look-ahead and planning abilities (Racanière et al., 2017; Zambaldi et al., 2019). Our expectation is that RL agents in which explicitly propositional, relational representations underpin these capacities will manifest more of the beneficial data efficiency, generalisation, and transfer properties suggested by the present results. As a stepping stone to such RL agents, the Relations Game family of datasets could be extended into the temporal domain, and multi-task curricula developed to encourage the acquisition of temporal, as well as spatial, abstractions.
+
+# REFERENCES
+
+Masataro Asai. Unsupervised grounding of plannable first-order logic representation from images. In International Conference on Automated Planning and Scheduling, 2019.
+
+Peter W. Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, pp. 4502–4510, 2016.
+
+Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In Proc. ICML Workshop on Unsupervised and Transfer Learning, volume 27, pp. 17–37, 2012.
+
+Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proc. 26th International Conference on Machine Learning, pp. 41–48, 2009.
+
+Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013.
+
+Antoine Bordes, Jason Weston, Ronan Collobert, and Yoshua Bengio. Learning structured embeddings of knowledge bases. In Proc. AAAI, pp. 301–306, 2011.
+
+Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In Proc. International Conference on Learning Representations, 2019.
+
+Honghua Dong, Jiayuan Mao, Tian Lin, Chong Wang, Lihong Li, and Denny Zhou. Neural logic machines. In International Conference on Learning Representations, 2019.
+
+Richard Evans and Edward Grefenstette. Learning explanatory rules from noisy data. Journal of Artificial Intelligence Research, 61:1–64, 2018.
+
+Marta Garnelo and Murray Shanahan. Reconciling deep learning with symbolic artificial intelligence: representing objects and relations. Current Opinion in Behavioral Sciences, 29:17–23, 2019.
+
+Marta Garnelo, Kai Arulkumaran, and Murray Shanahan. Towards deep symbolic reinforcement learning. arXiv preprint: 1609.05518, 2016.
+
+Lisa Getoor and Ben Taskar (eds.). Introduction to Statistical Relational Learning. MIT Press, 2007.
+
+Stevan Harnad. The symbol grounding problem. Physica D: Nonlinear Phenomena, 42(1-3):335–346, 1990.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017a.
+
+Irina Higgins, Arka Pal, Andrei Rusu, Loïc Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. DARLA: improving zero-shot transfer in reinforcement learning. In Proc. 34th International Conference on Machine Learning, pp. 1480–1490, 2017b.
+
+Irina Higgins, Nicolas Sonnerat, Loic Matthey, Arka Pal, Christopher P Burgess, Matko Bosnjak, Murray Shanahan, Matthew Botvinick, Demis Hassabis, and Alexander Lerchner. Scan: Learning hierarchical compositional visual concepts. In International Conference on Learning Representations, 2018.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proc. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1988–1997, 2017.
+
+Ken Kansky, Tom Silver, David A. Mély, Mohamed Eldawy, Miguel Lázaro-Gredilla, Xinghua Lou, Nimrod Dorfman, Szymon Sidor, Scott Phoenix, and Dileep George. Schema networks: Zero-shot transfer with a generative causal model of intuitive physics. In Proc. 34th International Conference on Machine Learning, volume 70, pp. 1809–1818, 2017.
+
+Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, 40:e253, 2017.
+
+Gary Marcus. Deep learning: a critical appraisal. arXiv preprint arXiv:1801.00631, 2018.
+
+John McCarthy. Generality in artificial intelligence. Communications of the ACM, 30(12):1030–1035, 1987.
+
+Rasmus Berg Palm, Ulrich Paquet, and Ole Winter. Recurrent relational networks. In Advances in Neural Information Processing Systems, pp. 3368–3378, 2018.
+
+Sébastien Racanière, Théophane Weber, David P. Reichert, Lars Buesing, Arthur Guez, Danilo Rezende, Adria Puigdomènech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, Razvan Pascanu, Peter Battaglia, Demis Hassabis, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. In Advances in Neural Information Processing Systems, pp. 5694–5705, 2017.
+
+Tim Rocktäschel and Sebastian Riedel. End-to-end differentiable proving. In Advances in Neural Information Processing Systems, pp. 3788–3800, 2017.
+
+Stuart Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice Hall Press, 3rd edition, 2009.
+
+Adam Santoro, David Raposo, David G Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Tim Lillicrap. A simple neural network module for relational reasoning. In Advances in Neural Information Processing Systems, pp. 4974–4983, 2017.
+
+Adam Santoro, Ryan Faulkner, David Raposo, Rae Jack, Mike Chrzanowski, Théophane Weber, Oriol Vinyals, Razvan Pascanu, and Tim Lillicrap. Relational recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 7299–7310, 2018.
+
+Jonathan Schwarz, Wojciech Czarnecki, Jelena Luketina, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In Proc. 35th International Conference on Machine Learning, volume 80, pp. 4528–4537, 2018.
+
+Brian Cantwell Smith. The Promise of Artificial Intelligence: Reckoning and Judgment. MIT Press, 2019.
+
+Richard Socher, Danqi Chen, Christopher Manning, and Andrew Ng. Reasoning with neural tensor networks for knowledge base completion. In Advances in Neural Information Processing Systems, pp. 926–934, 2013.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proc. IEEE Conference on Computer Vision and Pattern Recognition, 2018.
+
+Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, Murray Shanahan, Victoria Langston, Razvan Pascanu, Matthew Botvinick, Oriol Vinyals, and Peter Battaglia. Deep reinforcement learning with relational inductive biases. In International Conference on Learning Representations, 2019.
+
+Table S2: Default hyperparameters   
+
+<table><tr><td>Parameter</td><td>Value</td></tr><tr><td>Input images size L size Runs per experiment Optimiser Learning rate</td><td>36×36×3 25×34 10 Gradient descent</td></tr><tr><td>Batch size Input CNN output channels Input CNN filter size Input CNN stride Input CNN activation</td><td>0.01 10 32 12 6 ReLu</td></tr><tr><td>Bias Output MLP hidden layer size Output MLP output size Output MLP activation</td><td>Yes 8 2(4) ReLu</td></tr><tr><td>Bias MLP1 output size MLP1 activation Bias</td><td>Yes (both) k(j+4) ReLu Yes</td></tr><tr><td>MLP2 hidden layer size MLP2 activations MLP2 output size</td><td>1024 ReLu k(j+4)</td></tr><tr><td>Bias RN MLP hidden layer size (pre-aggregation) RN output size RN activation RN aggregation</td><td>Yes (both) 256 k(j+4) ReLu Element-wise mean</td></tr><tr><td>Bias MHA no. of heads MHA key / query size MHA value size MHA output size MHA attention mechanism</td><td>No k 16 j+4 k(j+4)</td></tr><tr><td>Bias PrediNet no. of heads PrediNet key /query size PrediNet relations PrediNet output size Bias</td><td>softmax(QKT)V No k=32 g=16 j=16 k(j+4) n/a</td></tr></table>
+
+# S1 HYPERPARAMETERS
+
+Table S2 shows the default hyperparameters used for the experiments reported in the main text.
+
+# S2 SUPPLEMENTARY ANALYSIS
+
+# S2.1 DIMENSIONALITY REDUCTION ON INTERMEDIATE REPRESENTATIONS
+
+To qualitatively assess the nature of the representations produced by each architecture, we performed a dimensionality reduction analysis on the outputs of the central module of each architecture trained on the ‘colour / shape’ task. After training, a batch of 10,000 images (pentominoes) was passed through the network and principal component analysis (PCA) was performed on the resulting representations, which were then projected onto the two largest principal components for visualisation. The projected representations were then colour-coded by the labels for the corresponding images (i.e. different/same shape, different/same colour).
+
+![](images/36b3ab57bcda64ccb6e16a7440f9f151ad5761bef3f81474d0a0e483fae80456.jpg)  
+Figure S8: Representative central module outputs for networks trained on the ‘colour / shape’ task when projected onto the two largest principal components.
+
+PCA on the full representations (concatenating the head outputs in the case of the PrediNet and MHA models) did not yield any clear clustering of representations according to the labels for any of the models (Figure S8).
+
+For the PrediNet and MHA models, we also ran separate PCAs on the output relations of each head in order to see how distributed / disentangled the representations were. While in the MHA model there was no evidence of clustering by label on any of the heads, reflecting a heavily distributed representation, there were several heads in the PrediNet architecture that individually clustered the different labels (Figure S9). In some heads, colour and shape seemed to be projected along separate axes (e.g. heads 5, 26, and 27), while in others objects with different colours seemed to be organised in a hexagonal grid (e.g. heads 9 and 14).
+
+We noted that the clustering was preserved (though slightly compressed in PC space) when the held-out set of images (hexominoes) was passed through the PrediNet and projected onto the same principal components derived using the training set. (In Section S2.2, we show that the PrediNet heads that seem to cluster the labels also attend to the two objects in the image rather than the background.)
+
+# S2.2 ATTENTION ANALYSIS
+
+To assess the extent to which the various PrediNet heads attend to actual objects as opposed to the background, we produced a lower resolution content mask for each image (with the same resolution as the attention mask) containing 0.0s at locations where there are no objects in the corresponding pixels of the full image, 1.0s where more than $9 0 \%$ of the pixels contain an object, and 0.5s otherwise. By applying the attention mask to the content mask, and summing the resulting elements, we produced a scalar indicating whether the attention mask was selecting a region of the image with an object (value close to 1.0), or the background (value close to 0.0). This was tested over 1000 images from the training set (Fig. S10), but similar results are obtained if the held-out set images are used instead. The top plot in Fig. S10 shows that both attention masks of some heads consistently attend to objects, while others to a combination of object and background. Importantly, the heads for which the PCA meaningfully clusters the labels are also the ones in which both attention masks attend to objects (Fig. S9).
+
+We additionally provide a similar analysis with a position mask, where each pixel in the mask contains a unique location index. The middle plot in Fig. S10 shows that the attention masks in the majority of the heads do not consistently attend to specific locations. Finally, the mean absolute values of the per-head input weights to the output MLP are shown in the bottom plot of the same figure. Interestingly, the heads that consistently attend only to objects have higher weighting than the rest.
+
+![](images/60fcf6158b9120b47d4d6ec35eb75643d6f7b54b3a4cff11e69a401b4640b8c5.jpg)  
+Figure S9: Per-head PCA on the heads of a PrediNet and an MHA trained on the ‘colour / shape’ task. For all networks, PCA was performed using the training data (pentominoes). In (a) and (c), the training data are projected onto the two largest PCs and in (b) the test data (hexominoes) was used.
+
+![](images/b4569f18d7bfab316f74b150c607aad2dc1c6754409abc595880ab63c07791cd.jpg)  
+Figure S10: Top: The extent to which the two attention masks of the different heads attend to objects rather than the background. Middle: The extent to which the two attention masks of the different heads attend to specific locations in the image. Bottom: Mean absolute value of the weights from the different PrediNet heads to the output MLP.
+
+# S3 EXPERIMENTAL VARIATIONS
+
+Further experimental results are provided in this section, including variations in hyper-parameters. Fig. S11 presents test accuracy curves for the ‘stripes’ object set, for which a summary is presented in Table 1 of the main text. Fig. S12 shows the results on the same experiment but using the Adam optimiser instead of SGD, with a learning rate of $1 0 ^ { - 4 }$ . The TensorFlow default values for all other Adam parameters were used. While other learning rate values were also tested, a value of $1 0 ^ { - 4 }$ gave the best overall performance for all architectures. Multi-task experiments were also performed using Adam with the same learning rate (Fig. S14 & S15), yielding an overall similar performance to SGD with a learning rate of $1 0 ^ { - 2 }$ .
+
+To assess the extent to which the number of heads and relations plays a role in the performance, we ran experiments with $k = 6 4$ heads and $j = 1 6$ relations (Fig. S16 & S17), as well as $k = 1 6$ heads and $j = 3 2$ relations (Fig. S18 & S19). The results indicate that having a greater number of heads leads to better performance than having a greater number of relations, because they provide more stability during training and, perhaps, a richer propositional representation.
+
+![](images/e55710561f4221861926a9e18d2d5f78c64350ab15660426ad476788bb600088.jpg)  
+Figure S11: Relations Game learning curves for the different models. SGD with a learning rate of 0.01 was used with a PrediNet of $k = 3 2$ heads and $j = 1 6$ relations. The top and bottom rows show results for the ‘hexominoes’ held-out object set, while the middle row is for the ‘stripes’ held-out object set. The results for the top 10 batches are summarised in Table 1 of the main manuscript.
+
+![](images/351913f8c8b1f54ae80ce7970dbec2c8500ba8f58a45f23777cbdb5d88d9f8d1.jpg)  
+Figure S12: Relations Game learning curves for the different models trained with the Adam optimiser (learning rate: $1 0 ^ { - 4 }$ ). All other experimental parameters are the same as Fig. S11. The top row shows results for the ‘hexominoes’ held-out object set, while the bottom row is for the ‘stripes’ held-out object set
+
+![](images/4b166ce338e6c8c1fb47d4965122c2810e12d1933b5cbc2a4d51ad0cf7f13582.jpg)  
+Figure S13: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used, with $k = 3 2$ and $j = 1 6$ . Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. From left to right, the combinations of target / pre-training tasks are: (‘match rows’, $^ { 6 } 3$ row patterns’), (‘5 column patterns’, ‘between’), (‘3 column patterns’, ‘between’), (‘match rows’, ‘3 column patterns’) and (‘5 row patterns’, ‘5 column patterns’). From top to bottom, the different architectures are: MLP1, MLP2, relation net (RN), multi-head attention (MHA) and PrediNet.
+
+![](images/438677fc2c32f9264113574e9859491717d1af6cd24f9efd4817231792a1e21f.jpg)  
+Figure S14: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures, as in Fig. S13. The Adam optimiser with a learning rate of $1 0 ^ { - 4 }$ was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set.
+
+![](images/3ae73376016f90ba446129a0675ad8251826ac53c58839895314cca843417074.jpg)  
+Figure S15: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All architectures were trained using Adam, with a learning rate of $1 0 ^ { - 4 }$ . The experimental setup is the same as in Fig. S14.
+
+![](images/b3a3f8d5d0f1e66fd8c57d7739e66748a85008026ee7da8ec7e62675a6c6cf0c.jpg)  
+Figure S16: Multi-task curriculum training. The columns correspond to different target/pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. The experimental setup is the same as for Fig. S13, except that $k = 6 4$ and $j = 1 6$ . Increasing the number of heads for the PrediNet increases the stability during training and overall performance.
+
+![](images/fe3733dde7f98be808bb1cff19aa3b855fd08735c1ecbe79f2227548bebd550b.jpg)  
+Figure S17: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All experimental parameters are as in Fig. S16.
+
+![](images/12bbf29c7db9f32ba4885e1dd56886fea9ea2076ae44983130a2c038013eb282.jpg)  
+Figure S18: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. The experimental setup is the same as for Fig. S13, except that $k = 1 6$ and $j = 3 2$ . Having fewer heads leads to a decrease in performance, even if the number of relations is increased to maintain network size.
+
+![](images/e49c46ea61614d246526938d200c4e60e0508fd16db4490b45865d1c0c83e83e.jpg)  
+Figure S19: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All experimental parameters are as in Fig. S18.

parse/train/S1l6ITVKPS/S1l6ITVKPS_content_list.json

@@ -0,0 +1,1431 @@
+[
+    {
+        "type": "text",
+        "text": "AN EXPLICITLY RELATIONAL NEURAL NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            826,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            250
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With a view to bridging the gap between deep learning and symbolic AI, we present a novel end-to-end neural network architecture that learns to form propositional representations with an explicitly relational structure from raw pixel data. In order to evaluate and analyse the architecture, we introduce a family of simple visual relational reasoning tasks of varying complexity. We show that the proposed architecture, when pre-trained on a curriculum of such tasks, learns to generate reusable representations that better facilitate subsequent learning on previously unseen tasks when compared to a number of baseline architectures. The workings of a successfully trained model are visualised to shed some light on how the architecture functions. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            402
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            426,
+            336,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When humans face novel problems, they are able to draw effectively on past experience with other problems that are superficially very different, but that have similarities on a more abstract, structural level. This ability is essential for lifelong, continual learning, and confers on humans a degree of data efficiency, powers of transfer learning, and a capacity for out-of-distribution generalisation that contemporary machine learning has yet to match (Garnelo et al., 2016; Lake et al., 2017; Marcus, 2018; Smith, 2019). A case may be made that all these issues are different facets of the same underlying challenge, namely the challenge of devising systems that learn to construct general-purpose, reusable representations (McCarthy, 1987; Bengio et al., 2013). A representation is general-purpose and reusable to the extent that it contains information whose domain of application exceeds the context within which it was acquired. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Representations that are general-purpose and reusable improve data efficiency because a system that already knows how to build representations relevant to a novel task (despite its novelty) doesn’t have to learn that task from scratch. Ideally, a system that efficiently exploits general-purpose, reusable representations in this way should be the very same system that learned how to construct them in the first place. Moreover, in learning to solve a novel task using such representations, we should expect the system to learn further representations that are themselves general-purpose and reusable. So, with the exception of the very first representations the system learns, all learning in such a system would in effect be transfer learning, and the process of learning would be inherently cumulative, continual, and lifelong. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One approach to building such a system is to take inspiration from the paradigm of classical, symbolic AI (Garnelo & Shanahan, 2019). Building on the mathematical foundations of first-order predicate calculus, a typical symbolic AI system works by applying logic-like rules of inference to language-like propositional representations whose elements are objects and relations. Thanks to their declarative character and compositional structure, these representations lend themselves naturally to generality and reusability. However, in contrast to contemporary deep learning systems, the representations deployed in classical AI are not usually learned from data but hand-crafted (Harnad, 1990). The aim of the present work is to get the best of both worlds with an end-to-end differentiable neural network architecture that builds in propositional, relational priors in much the same way that a convolutional network builds in spatial and locality priors. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The architecture introduced here builds on recent work with non-local network architectures that learn to discover and exploit relational information (Wang et al., 2018), notably relation nets (Santoro et al., 2017; Palm et al., 2018) and architectures based on multi-head attention (Vaswani et al., 2017; ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/acbf1ed0a2269cd2c35fb54e2266d14587a8d10a61d982ab809a16e2964290bc.jpg",
+        "image_caption": [
+            "Figure 1: The PrediNet architecture. $W _ { K }$ and $W _ { S }$ are shared across heads, whereas $W _ { Q 1 }$ and $W _ { Q 2 }$ are local to each head. See main text for more details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            818,
+            301
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Santoro et al., 2018; Zambaldi et al., 2019). However, these architectures generate representations that lack explicit structure. There is, in general, no straightforward mapping from the parts of a representation to the usual elements of a symbolic medium such as predicate calculus: propositions, relations, and objects. To the extent that these elements are present, they are smeared across the embedding vector, which makes representations hard to interpret and makes it more difficult for downstream processing to take advantage of compositionality. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            457
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here we present an architecture, which we call a PrediNet, that learns representations whose parts map directly onto propositions, relations, and objects. To build a sound, scientific understanding of the proposed architecture, and to facilitate a detailed comparison with other architectures, the present study focuses on simple tasks requiring relatively little data and computation. We develop a family of small, simple visual datasets that can be combined into a variety of multi-task curricula and used to assess the extent to which an architecture learns representations that are general-purpose and reusable. We report the results of a number of experiments using these datasets that demonstrate the potential of an explicitly relational network architecture to improve data efficiency and generalisation, to facilitate transfer, and to learn reusable representations. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The main contribution of the present paper is a novel architecture that learns to discover objects and relations in high-dimensional data, and to represent them in a form that is beneficial for downstream processing. The PrediNet architecture does not itself carry out logical inference, but rather extracts relational structure from raw data that has the potential to be exploited by subsequent processing. Here, for the purpose of evaluation, we graft a simple multi-layer perceptron output module to the PrediNet and train it on a simple set of spatial reasoning problems. The aim is to acquire a sufficient scientific understanding of the architecture and its properties in this minimalist setting before applying it to more complex problems using more sophisticated forms of downstream inference. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 THE PREDINET ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            472,
+            751
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The idea that propositions are the building blocks of knowledge dates back to the ancient Greeks, and provides the foundation for symbolic AI, via the $1 9 ^ { \\mathrm { t h } }$ century mathematical work of Boole and Frege (Russell & Norvig, 2009). An elementary proposition asserts that a relationship holds between a set of objects. Propositions can be combined using logical connectives (and, or, not, etc), and can participate in inference processes such as deduction. The task of the PrediNet is to (learn to) transform high-dimensional data such as images into propositional representations that are useful for downstream processing. A PrediNet module (Fig. 1) can be thought of as a pipeline comprising three stages: attention, binding, and evaluation. The attention stage selects pairs of objects of interest, the binding stage instantiates the first two arguments of a set of three-place predicates (relations) with selected object pairs, and the evaluation stage computes values for each predicate’s remaining (scalar) argument such that the resulting proposition is true. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More precisely, a PrediNet module comprises $k$ heads, each of which computes $j$ relations between pairs of objects (Fig. 1). The input to the PrediNet is a matrix, $L$ , comprising $n$ rows of feature vectors, where each feature vector has length $m$ . In the present work, $L$ is computed by a convolutional neural network (CNN). The CNN outputs a feature map consisting of $n$ feature vectors that tile the input image. The last two elements of the feature vector are the xy co-ordinates of the associated patch in the image. So the length $m$ of each feature vector corresponds to the number of filters in the final CNN layer plus 2 (for the co-ordinates), and the $i ^ { t h }$ element of a feature vector (for $i < m - 2 )$ is the output of the $i ^ { t h }$ filter. For a given input $L$ , each head $h$ computes the same set of relations (using shared weights $W _ { S }$ ) but selects a different pair of objects, using dot-product attention based on key-query matching (Vaswani et al., 2017). Each head computes a separate pair of queries $Q _ { 1 } ^ { h }$ and $Q _ { 2 } ^ { h }$ (via $\\dot { W } _ { Q 1 } ^ { \\dot { h } }$ and $W _ { . Q 2 } ^ { \\tilde { h } } .$ ). But the key space $K$ (defined by $W _ { K }$ ) is shared, so that the set of entities that are candidates for attention is consistent across heads. The whole (flattened) image is used to generate queries, allowing attention masks to depend on the image’s full (non-local) content. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56549e8712201c948621c1e56a189893b2a72a87637e1dad60349af6ed890f40.jpg",
+        "text": "$$\nQ _ { 1 } ^ { h } = \\mathrm { H a t t e n } ( L ) W _ { Q 1 } ^ { h } ~ . Q _ { 2 } ^ { h } = \\mathrm { H a t t e n } ( L ) W _ { Q 2 } ^ { h } ~ K = L W _ { K }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            290,
+            754,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Applying the resulting pair of attention masks directly to $L$ yields a pair of objects $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ , each represented by a weighted sum of feature vectors. ",
+        "bbox": [
+            171,
+            318,
+            823,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b96b0a9f7c9887d6ceb15facac9114b94a089079d60f0fb6b0aeac13d7b8ecd3.jpg",
+        "text": "$$\nE _ { 1 } ^ { h } = \\mathrm { s o f t m a x } ( Q _ { 1 } ^ { h } K ^ { \\top } ) L \\qquad E _ { 2 } ^ { h } = \\mathrm { s o f t m a x } ( Q _ { 2 } ^ { h } K ^ { \\top } ) L\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            353,
+            722,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All $j$ relations between $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ are then evaluated. There are many ways to compute a relationship between a pair of objects represented as feature vectors. We chose to compute the values of relations by taking vector differences, which has been shown to be effective in the context of relationally structured knowledge bases (Bordes et al., 2011; Socher et al., 2013). In the current architecture, $E _ { 1 } ^ { \\tilde { h } }$ and $E _ { 2 } ^ { h }$ are subject to a linear mapping (via $W _ { S }$ ) into $j$ 1D spaces, one per relation, and the resulting vector is passed through an element-wise comparator, yielding a vector of differences $D ^ { h }$ . ",
+        "bbox": [
+            174,
+            380,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad7c86d0df5bed2ba764e0bd1b85b71b9fac5be20365091f84b584ed26166904.jpg",
+        "text": "$$\nD ^ { h } = E _ { 1 } ^ { h } W _ { S } - E _ { 2 } ^ { h } W _ { S }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            470,
+            578,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The last two elements of $E _ { 1 } ^ { h }$ and $E _ { 2 } ^ { h }$ (the positions $P _ { 1 } ^ { h }$ and $P _ { 2 } ^ { h }$ , respectively) are concatenated to the vector 1 2 1 of differences to give the head’s output $R ^ { h } = \\mathsf { \\bar { ( } } D ^ { h } , \\mathsf { \\bar { P } } _ { 1 } ^ { h } , P _ { 2 } ^ { h } )$ . Finally, the outputs of all $k$ heads are concatenated, yielding the output of the PrediNet module, a vector $R ^ { * }$ of length $k ( j + 4 )$ . In predicate calculus terms, the final output of a PrediNet module with $k$ heads and $j$ relations represents the conjunction of elementary propositions ",
+        "bbox": [
+            173,
+            497,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/614f465df7fc3162f31f92e9b33442d71efab108df6411584f05151172502ceb.jpg",
+        "text": "$$\n\\Psi \\equiv \\bigwedge _ { h = 1 } ^ { k } \\bigwedge _ { i = 1 } ^ { j } \\psi _ { i } ( d _ { i } ^ { h } , e _ { 1 } ^ { h } , e _ { 2 } ^ { h } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            575,
+            589,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\psi _ { i } ( d _ { i } ^ { h } , e _ { 1 } ^ { h } , e _ { 2 } ^ { h } )$ asserts that $d _ { i } ^ { h }$ is the distance between objects $e _ { 1 } ^ { h }$ and $e _ { 2 } ^ { h }$ in the 1D space defined by column $i$ of the weight matrix $W _ { S }$ , and the denotations of $e _ { 1 } ^ { h }$ and $e _ { 2 } ^ { h }$ are captured by the vectors $\\dot { Q } _ { 1 } ^ { h }$ and $Q _ { 2 } ^ { h }$ respectively, given the key-space defined by $K$ . ",
+        "bbox": [
+            174,
+            625,
+            825,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Equation 1 supplies a semantics for the PrediNet’s final output vector $R ^ { * }$ that maps each of its elements onto a well-defined logical formula, something that cannot be claimed for other architectures, such as the relation net or multi-head attention net. In the experiments reported here, only $R ^ { * }$ is used for downstream processing, and this vector by itself doesn’t have the logical structure described by Equation 1. However, the PrediNet module can easily be extended to deliver an additional output in explicitly propositional form, with a predicate-argument structure corresponding to the RHS of Equation 1. In the present paper, the pared-down vector form facilitates our experimental investigation, but in its explicitly propositional form, the PrediNet’s output could be piped directly to (say) a Prolog interpreter (Fig.7), to an inductive logic programming system, to a statistical relational learning system, or indeed to another differentiable neural module. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DATASETS AND TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            393,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It would be premature to apply the PrediNet architecture to rich, complex data before we have a basic understanding of its properties and its behaviour. To facilitate in-depth scientific study, we need small, simple datasets that allow the operation of the architecture to be examined in detail and the fundamental premises of its design to be assessed. Our experimental goals in the present paper are 1) ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "to test the hypothesis that the PrediNet architecture learns representations that are general-purpose and reusable, and 2) insofar as this is true, to investigate why. Existing datasets for relational reasoning tasks, such as CLEVR (Johnson et al. (2017)) and sort-of-CLEVR (Santoro et al. (2017)), were ruled out because they include confounding complexities, such as occlusion and shadows or language input, and/or because they don’t lend themselves to the fine-grained task-level splits we required. Consequently, we devised a new configurable family of simple classification tasks that we collectively call the Relations Game. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A Relations Game task involves the presentation of an image containing a number of objects laid out on a $3 \\times 3$ grid, and the aim (in most tasks) is to label the image as True or False according to whether a given relationship holds among the objects in the image. While the elementary propositions learned by the PrediNet only assert simple relationships between pairs of entities, Relations Game tasks generally involve learning compound relations involving multiple relationships among many objects. The objects in question are drawn from either a training set or one of two held-out sets (Fig. 2a). None of the shapes or colours in the training set occurs in either of the held-out sets. The training object set contains 8 uniformly coloured pentominoes and their rotations and reflections (37 shapes in all) with 25 possible colours. The first held-out object set contains 8 uniformly coloured hexominoes and their rotations and reflections (46 shapes in all) with 25 possible colours, and the second held-out object set contains only squares, but with a striped pattern of held-out colours. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            361
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each Relations Game task is tied to a given relation. Even with such a simple setup, the number of definable relations among all possible combinations of objects is astronomical $( 2 ^ { ( n + 1 ) ^ { 9 } }$ for $n$ distinct objects), although only a few of them will make intuitive sense. For the present study, we defined a handful of intuitively meaningful relations and generated corresponding labelled datasets comprising $50 \\%$ positive and $50 \\%$ negative examples. A selection is shown in Fig. 2c. The ‘between’ relation holds iff the image contains three objects in a line in which the outer two objects have the same shape, orientation, and colour. The ‘occurs’ relation holds iff there is an object in the bottom row of three objects that has the same shape, orientation, and colour as the (single) object in the top row. The ‘same’ relation holds iff the image contains two objects of the same shape, orientation, and colour. In each case, we balanced the set of negative examples to ensure that “tricky” images involving pairs of objects with the same colour but different shape or the same shape but different colour occur just as frequently as those with objects that differ in both colour and shape. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            395,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At the top level, each architecture we consider in this paper comprises 1) a single convolutional input layer (CNN), 2) a central module (which might be a PrediNet or a baseline), and 3) a small output multi-layer perceptron (MLP) (Fig. 3). A pair of xy co-ordinates is appended to each CNN feature vector, denoting its position in convolved image space and, where applicable, a one-hot task identifier is appended to the output of the central module. For most tasks, the final output of the MLP is a one-hot label denoting True or False. The PrediNet was evaluated by comparing it to several baselines: two MLP baselines (MLP1 and MLP2), a relation net baseline (Santoro et al., 2017) (RN), and a multi-head attention baseline (Vaswani et al., 2017; Zambaldi et al., 2019) (MHA). ",
+        "bbox": [
+            174,
+            611,
+            825,
+            723
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To facilitate a fair comparison, the top-level schematic is identical for the PrediNet and for all baselines (Fig. 3). All use the same input CNN architecture and the same output MLP architecture, and differ only in the central module. In MLP1, the central module is a single fully-connected layer with ReLu activations, while in MLP2 it has two layers. In RN, the central module computes the set of all possible pairs of feature vectors, each of which is passed through a 2-layer MLP; the resulting vectors are then aggregated by taking their element-wise means to yield the output vector. Finally, MHA comprises multiple heads, each of which generates mappings from the input feature vectors to sets of keys $K$ , queries $Q$ , and values $V$ , and then computes softmax $( Q K ^ { \\top } ) V$ . Each head’s output is a weighted sum of the resulting vectors, and the output of the MHA central module is the concatenation of all its heads’ outputs. The PrediNet used here comprises $k = 3 2$ heads and $j = 1 6$ relations (Fig. 1). All reported experiments were carried out using stochastic gradient descent, and all results shown are averages over 10 runs. Further experimental details are given in the Supplementary Material, which also shows results for experiments with different numbers of heads and relations, and with the Adam optimiser, all of which present qualitatively similar results. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/59609ae11a5a459a6bb196384a08bfaf14aedced1451207bee625c15ba01e038.jpg",
+        "image_caption": [
+            "Figure 2: Relations Game object sets and tasks. (a) Example objects from the training set and held-out test sets. (b) There are five possible row / column patterns. In a multi-task setting, recognising each row pattern is a separate task. (c) Three examples tasks for the single-task setting. (d) An example target task (left) and curriculum (right) for the multi-task setting. The curriculum task ids (right) for each of the three examples (2, 4, and 3) correspond to the respective patterns in (b), and the task in each case is to confirm whether or not the column of objects in the image conform to the designated pattern. The aim of the target task (left) is to test whether the two rows of objects have the same pattern according to (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            136,
+            807,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ffea528f48079ce872fba2a4f868b06f50790719756f06c415acd4ebffcd0851.jpg",
+        "image_caption": [
+            "Figure 3: The four-stage experimental protocol for multi-task curriculum training. The same input module (CNN) and output module (MLP) are used for the PrediNet and all baseline architectures; only the central module varies. Task identifiers are appended to the central module’s output vector. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            643,
+            815,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/cfa576edac8ed0dfeac7ea374936968738b7eed5488d82de7dbc02d2bec605cc.jpg",
+        "table_caption": [
+            "Table 1: Data efficiency in a single-task Relations Game setting. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Relation</td><td rowspan=1 colspan=1> Object set</td><td rowspan=1 colspan=1>MLP1</td><td rowspan=1 colspan=1>MLP2</td><td rowspan=1 colspan=1>RN</td><td rowspan=1 colspan=1>MHA</td><td rowspan=1 colspan=1>PrediNet</td></tr><tr><td rowspan=2 colspan=1>same</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>96.1±0.007</td><td rowspan=1 colspan=1>96.4±0.006</td><td rowspan=1 colspan=1>73.2±0.05</td><td rowspan=1 colspan=1>94.7±0.1</td><td rowspan=1 colspan=1>100±0.0</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>93.3±0.01</td><td rowspan=1 colspan=1>94.0±0.01</td><td rowspan=1 colspan=1>72.9±0.05</td><td rowspan=1 colspan=1>93.7±0.1</td><td rowspan=1 colspan=1>100±0.0</td></tr><tr><td rowspan=2 colspan=1>between</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>98.7±0.005</td><td rowspan=1 colspan=1>98.8±0.004</td><td rowspan=1 colspan=1>70.8±0.01</td><td rowspan=1 colspan=1>89.2±0.1</td><td rowspan=1 colspan=1>99.2±0.004</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>96.9±0.008</td><td rowspan=1 colspan=1>97.3±0.004</td><td rowspan=1 colspan=1>65.2±0.05</td><td rowspan=1 colspan=1>85.5±0.1</td><td rowspan=1 colspan=1>98.7±0.007</td></tr><tr><td rowspan=2 colspan=1>occurs</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>88.0±0.01</td><td rowspan=1 colspan=1>94.8±0.03</td><td rowspan=1 colspan=1>61.6±0.01</td><td rowspan=1 colspan=1>88.4±0.2</td><td rowspan=1 colspan=1>98.5±0.009</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>73.2±0.03</td><td rowspan=1 colspan=1>87.3±0.07</td><td rowspan=1 colspan=1>62.6±0.02</td><td rowspan=1 colspan=1>80.8±0.1</td><td rowspan=1 colspan=1>96.9±0.01</td></tr><tr><td rowspan=2 colspan=1>xoccurs</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>81.5±0.02</td><td rowspan=1 colspan=1>84.4±0.04</td><td rowspan=1 colspan=1>55.0±0.009</td><td rowspan=1 colspan=1>54.7±0.008</td><td rowspan=1 colspan=1>95.4±0.01</td></tr><tr><td rowspan=1 colspan=1>Stripes</td><td rowspan=1 colspan=1>78.2±0.03</td><td rowspan=1 colspan=1>80.8±0.05</td><td rowspan=1 colspan=1>54.0±0.01</td><td rowspan=1 colspan=1>53.6±0.007</td><td rowspan=1 colspan=1>95.5±0.01</td></tr><tr><td rowspan=1 colspan=1>colour/shape</td><td rowspan=1 colspan=1>Hexominoes</td><td rowspan=1 colspan=1>53.4±0.07</td><td rowspan=1 colspan=1>55.8±0.05</td><td rowspan=1 colspan=1>45.1±0.05</td><td rowspan=1 colspan=1>88.6±0.03</td><td rowspan=1 colspan=1>94.3±0.01</td></tr></table>",
+        "bbox": [
+            240,
+            130,
+            756,
+            324
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To assess the generality and reusability of the representations produced by the PrediNet, we adopted a four-stage experimental protocol wherein 1) the network is pre-trained on a curriculum of one or more tasks, 2) the weights in the input CNN and PrediNet are frozen while the weights in the output MLP are re-initialised with random values, and 3) the network is retrained on a new target task or set of tasks (Fig. 3). In step 3, only the weights in the output MLP change, so the target task can only be learned to the extent that the PrediNet delivers re-usable representations to it, representations the PrediNet has learned to produce without exposure to the target task. To assess this, we can compare the learning curves for the target task with and without pre-training. We expect pre-training to improve data efficiency, so we should see accuracy increasing more quickly with pre-training than without it. For evidence of transfer, and to confirm the hypothesis of reusability, we are also interested in the final performance on the target task after pre-training, given that the weights of the pre-trained input CNN and PrediNet are frozen. This measure indicates how well a network has learned to form useful representations. The more different the target task is from the pre-training curriculum, the more impressed we should be that the network is able to learn the target task. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            565,
+            281,
+            582
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a prelude to investigating the issues of generality and reusabilty, we studied the data efficiency of the PrediNet architecture in a single-task Relations Game setting. Results obtained on a selection of five tasks – ‘same’, ‘between’, ‘occurs’, ‘xoccurs’, and ‘colour / shape’ – are summarised in Table 1. The first three tasks are as described in Fig. 2. The ‘xoccurs’ relation is similar to occurs. It holds iff the object in the top row occurs in the bottom row and the other two objects in the bottom row are different. The ‘colour / shape’ task involves four labels, rather than the usual two: same-shape / same-colour; different-colour / same-shape; same-colour / different shape; different-colour / different shape. In the dataset for this task, each image contains two objects randomly placed, and one of the four labels must be assigned appropriately. Table 1 shows the accuracy obtained by each of the five architectures after 100,000 batches when tested on the two held-out object sets. The PrediNet is the only architecture that achieves over $90 \\%$ accuracy on all tasks with both held-out object sets after 100,000 batches. On the ‘xoccurs’ task, the PrediNet out-performs the baselines by more than $10 \\%$ , and on the ‘colour / shape’ task (where chance is $2 5 \\%$ ), it out-performs all the baselines except MHA by $2 5 \\%$ or more. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, using the protocol outlined in Fig. 3, we compared the PrediNet’s ability to learn re-usable representations with each of the baselines. We looked at a number of combinations of target tasks and pre-training curriculum tasks. Fig. 4 depicts our findings for one these combinations in detail, specifically three target tasks corresponding to three of the five possible column patterns (ABA, AAB, and ABB (Fig. 2d)), and a pre-training curriculum comprising the single ‘between’ task. The plots present learning curves for each of the five architectures at each of the four stages of the experimental protocol. In all cases, accuracy is shown for the ‘stripes’ held-out object set (not the training set). Of particular interest are the (green) curves corresponding to Stage 3 of the experimental protocol. These show how well each architecture learns the target task(s) after the central module has been pre-trained on the curriculum task(s) and its weights are frozen. The PrediNet learns faster than any of the baselines, and is the only one to achieve an accuracy of $90 \\%$ . The rapid reusability of the representations learned by both the MHA baseline and the PrediNet is noteworthy because the ‘between’ relation by itself seems an unpromising curriculum for subsequently learning the AAB and ABB column patterns. As the (red) curve for Stage 4 of the protocol shows, the reusability of the PrediNet’s representations cannot be accounted for by the pre-training of the input CNN alone. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2860e394458188b798724c270b033684451f5caaf920cc0a6a6e33ddc565e987.jpg",
+        "image_caption": [
+            "Figure 4: Multi-task curriculum training. The target tasks are three column patterns (AAB, ABA, and ABB) and the sole curriculum task is the ‘between’ relation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            101,
+            790,
+            324
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f5423c49fb9436252568f8442c7594e6212ab5715afe91d508fa2b743ef6177b.jpg",
+        "image_caption": [
+            "Figure 5: Reusability of representations learned with a variety of target and pre-training tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            383,
+            790,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            666,
+            825,
+            750
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5 shows a larger range of target task / curriculum task combinations, concentrating exclusively on the Stage 3 learning curves. Here a more complete picture emerges. In both Fig. 5a and Fig. 5d the target task is ‘match rows’ (Fig. 2d), but they differ in their pre-training curricula. The curriculum for Fig. 5d is three of the five row patterns (ABA, AAB, and ABB). This is the only case where the PrediNet does not learn representations that are more useful for the target task than those of all the baselines, outperforming only two of the four. However, when the curriculum is the three analogous column patterns rather than row patterns, the performance of all four baselines collapses to chance, while the PrediNet does well, attaining similar performance as for the row-based curriculum (Fig. 5a). This suggests the PrediNet is able to learn representations that are orientation invariant, which aids transfer. This hypothesis is supported by Fig. 5e, where the target tasks are all five row patterns, while the curriculum is all five column patterns. None of the baselines is able to learn reusable representations in this context; all remain at chance, whereas the PrediNet achieves $8 5 \\%$ accuracy. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a174e4b0e286837ad4ddd2f7eb1246a74bd089edcd7a1df6f13caf5fbbed88f.jpg",
+        "image_caption": [
+            "Figure 6: (a) Attention heat maps for the first four heads of a trained PrediNet. Left: trained on the ‘same’ task. Right: trained on the ‘occurs’ task. (b) Principal component analysis. Left: PCA on the output of a selected head for a PrediNet trained on the ‘colour / shape’ task for pentominoes images (training set). Centre: The same PrediNet applied to hexominoes (held-out test set). Right: PCA applied to a representative head of the MHA baseline with pentominoes (training set). (c) Ablation study. Accuracy for PrediNet and MHA on the ‘colour / shape’ task when random subsets of the heads are used at test time. PrediNet\\* only samples from heads that attend to the two objects. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            820,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To better understand the operation of the PrediNet, we carried out a number of visualisations. One way to find out what the PrediNet’s heads learn to attend is to submit images to a trained network and, for each head $h$ , apply the two attention masks softmax $( Q _ { 1 } ^ { h } K ^ { \\top } )$ and softmax $( Q _ { 2 } ^ { h } K ^ { \\top } )$ to each of the $n$ feature vectors in the convolved image $L$ . The resulting matrix can then be plotted as a heat map to show how attention is distrubuted over the image. We did this for a number of networks trained in the single-task setting. Fig. 6a shows two examples, and the Supplementary Material contains a more extensive selection. As we might expect, most of the attention focuses on the centres of single objects, and many of the heads pick out pairs of distinct objects in various combinations. But some heads attend to halves or corners of objects. Although most attention is focal, whether directed at object centres or object parts, some heads exhibit diffuse attention, which is possible thanks to the soft key-query matching mechanism. So the PrediNet can (but isn’t forced to) treat the background as a single entity, or to treat an identical pair of objects as a single entity. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            632
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To gain some insight into how the PrediNet encodes relations, we carried out principal component analysis (PCA) on each head of the central module’s output vectors for a number of trained networks, again in the single-task setting (Fig. 6b). We chose the four-label ‘colour / shape’ task to train on, and mapped 10,000 example images onto the first two principal components, colouring each with their ground-truth label. We found that, for some heads, differences in colour and shape appear to align along separate axes (Fig. 6b). This contrasts with the MHA baseline, whose heads don’t seem to individually cluster the labels in a meaningful way. For the other baselines, which lack the multi-head organisation of the PrediNet and the MHA network, the only option is to carry out PCA on the whole output vector of the central module. Doing this, however, does not produce interpretable results for any of the architectures (Fig.S8). We also identified the heads in the PrediNet that attended to both objects in the image and found that they overlapped almost entirely with those that meaningfully clustered the labels (Fig.S10). Finally, still using the ‘shape / colour task’, we carried out an ablation study, which showed that the PrediNet is significantly more robust than the MHA network to pruning a random subset of heads at test time. Moreover, if pruned to leave only those heads that attended to the two objects, the performance of the full network could be captured with just a handful of heads (Fig. 6c). Taken together, these results are suggestive of something we might term relational disentangling in the PrediNet. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, to flesh out the claim that the PrediNet generates explicitly relational representations according to the semantics of Equation 1, we extended the PrediNet module to generate an additional output in the form of a Prolog program (Fig. 7). This involves assigning symbolic identifiers 1) to each of the ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/04ed67fab717de2f37c9700c1e7f0782803b63aa4fa13ad6a31a8d6925e2f7c2.jpg",
+        "image_caption": [
+            "Figure 7: PrediNet output in propositional form. (a) A small PrediNet (8 heads, 8 relations) trained on the ‘between’ task is given an image. (b) Mean shift clustering is applied to the set of all attention masks computed by the heads. Each of the resulting 6 clusters is assigned a symbolic identifier. (c) Each relation is also given a symbolic identifier, and all 64 propositions computed by the PrediNet are enumerated in Prolog syntax, in accordance with Equation 1. (A subset is shown.) (d) The results can be combined with further hand-written Prolog clauses. (Upper-case letters denote variables, while constants start with lower-case letters.) (e) Prolog queries can then be submitted. Here we are asking which relations $r$ hold with a small value $v$ between ob_2 and any other object $x$ . (f) The query yields four answers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            99,
+            820,
+            366
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "PrediNet’s $j$ relations, and 2) to every object picked out by its $k$ heads via the attention masks they compute. Then the corresponding $j \\times k$ propositions can be enumerated in Prolog syntax. Assigning symbolic identifiers to the relations is trivial. But because attention masks can differ slightly even when they ostensibly pick out the same region of the input image, it’s necessary to cluster them before assigning symbolic identifiers to the corresponding objects. We used mean shift clustering for this. Fig. 7 presents a sample of the PrediNet’s output in Prolog form, along with an example of deductive inference carried out with this program. The example shown is not intended to be especially meaningful; without further analysis, we lack any intuitive understanding of the relations the PrediNet has discovered. But it demonstrates that the representations the PrediNet produces can be understood in predicate calculus terms, and that symbolic deductive inference is one way (though not the only way) in which they might be deployed downstream. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            344,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The need for good representations has long been recognised in AI (McCarthy, 1987; Russell & Norvig, 2009), and is fundamental to deep learning (Bengio et al., 2013). The importance of reusability and abstraction, especially in the context of transfer, is emphasised by Bengio, et al. (Bengio et al., 2013), who argue for feature sets that are “invariant to the irrelevant features and disentangle the relevant features”. Our work here shares this motivation. Other work has looked at learning representations that are disentangled at the feature level (Higgins et al., 2017a; 2018). The novelty of the PrediNet is to incorporate architectural priors that favour representations that are disentangled at the relational and propositional levels. Previous work with relation nets and multi-head attention nets has shown how non-local information can be extracted from raw pixel data and used to solve tasks that require relational reasoning. (Santoro et al., 2017; Palm et al., 2018; Santoro et al., 2018; Zambaldi et al., 2019) But unlike the PrediNet, these networks don’t produce representations with an explicitly relational, propositional structure. By addressing the problem of acquiring structured representations, the PrediNet complements another thread of related work, which is concerned with learning how to carry out inference with structured representations, but which assumes the job of acquiring those representations is done elsewhere (Getoor & Taskar, 2007; Battaglia et al., 2016; Rocktäschel & Riedel, 2017; Evans & Grefenstette, 2018; Dong et al., 2019). ",
+        "bbox": [
+            174,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In part, the present work is motivated by the conviction that curricula will be essential to lifelong, continual learning in a future generation of RL agents if they are to exhibit more general intelligence, just as they are for human children. Curricular pre-training has a decade-long pedigree in deep learning (Bengio et al., 2009). Closely related to curriculum learning is the topic of transfer (Bengio, 2012), a hallmark of general intelligence and the subject of much recent attention (Higgins et al., 2017b; Kansky et al., 2017; Schwarz et al., 2018). The PrediNet exemplifies a different (though not incompatible) viewpoint on curriculum learning and transfer from that usually found in the neural network literature. Rather than (or as well as) a means to guide the network, step by step, into a favourable portion of weight space, curriculum learning is here viewed in terms of the incremental accumulation of propositional knowledge. This necessitates the development of a different style of architecture, one that supports the acquisition of propositional, relational representations, which also naturally subserve transfer. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Asai, whose paper was published while the present work was in progress, describes an architecture with some similarities to the PrediNet, but also some notable differences (Asai, 2019). For example, Asai’s architecture assumes an input representation in symbolic form where the objects have already been segmented. By contrast, in the present architecture, the input CNN and the PrediNet’s dotproduct attention mechanism together learn what constitutes an object. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            396
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND FURTHER WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            424,
+            504,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented a neural network architecture capable, in principle, of supporting predicate logic’s powers of abstraction without compromising the ideal of end-to-end learning, where the network itself discovers objects and relations in the raw data and thus avoids the symbol grounding problem entailed by symbolic AI’s practice of hand-crafting representations (Harnad, 1990). Our empirical results support the view that a network architecturally constrained to learn explicitly propositional, relational representations will have beneficial data efficiency, generalisation, and transfer properties. Although, the present experiments don’t use the fully propositional version of the PrediNet output, the concatenated vector form inherits many of its beneficial properties, notably a degree of compositionality. In particular, one important respect in which the PrediNet differs from other network architectures is the extent to which it canalises information flow; at the core of the network, information is organised into small chunks which are processed in parallel channels that limit the ways the chunks can interact. We believe this pressures the network to learn representations where each separate chunk of information (such as a single value in the vector $R *$ ) has independent meaning and utility. (We see evidence of this in the relational disentanglement of Fig. 6.) The result is a representation whose component parts are amenable to recombination, and therefore re-use in a novel task. But the findings reported here are just the first foray into unexplored architectural territory, and much work needs to be done to gauge the architecture’s full potential. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The focus of the present paper is the acquisition of propositional representations rather than their use. But thanks to the structural priors of its architecture, representations generated by a PrediNet module have a natural semantics compatible with predicate calculus (Equation 1), which makes them an ideal medium for logic-like downstream processes such as rule-based deduction, causal or counterfactual reasoning, and inference to the best explanation (abduction). One approach here would be to stack PrediNet modules and / or make them recurrent, enabling them to carry out the sort of iterated, sequential computations required for such processes (Palm et al., 2018; Dehghani et al., 2019). Another worthwhile direction for further research would be to develop reinforcement learning (RL) agents using the PrediNet architecture. One form of inference of particular interest in this context is model-based prediction, which can be used to endow an RL agent with look-ahead and planning abilities (Racanière et al., 2017; Zambaldi et al., 2019). Our expectation is that RL agents in which explicitly propositional, relational representations underpin these capacities will manifest more of the beneficial data efficiency, generalisation, and transfer properties suggested by the present results. As a stepping stone to such RL agents, the Relations Game family of datasets could be extended into the temporal domain, and multi-task curricula developed to encourage the acquisition of temporal, as well as spatial, abstractions. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Masataro Asai. Unsupervised grounding of plannable first-order logic representation from images. In International Conference on Automated Planning and Scheduling, 2019. ",
+        "bbox": [
+            171,
+            126,
+            823,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter W. Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, and Koray Kavukcuoglu. Interaction networks for learning about objects, relations and physics. In Advances in Neural Information Processing Systems, pp. 4502–4510, 2016. ",
+        "bbox": [
+            173,
+            166,
+            823,
+            209
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In Proc. ICML Workshop on Unsupervised and Transfer Learning, volume 27, pp. 17–37, 2012. ",
+        "bbox": [
+            173,
+            220,
+            825,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Jérôme Louradour, Ronan Collobert, and Jason Weston. Curriculum learning. In Proc. 26th International Conference on Machine Learning, pp. 41–48, 2009. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            291
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Aaron Courville, and Pascal Vincent. Representation learning: A review and new perspectives. IEEE transactions on pattern analysis and machine intelligence, 35(8):1798–1828, 2013. ",
+        "bbox": [
+            176,
+            301,
+            823,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes, Jason Weston, Ronan Collobert, and Yoshua Bengio. Learning structured embeddings of knowledge bases. In Proc. AAAI, pp. 301–306, 2011. ",
+        "bbox": [
+            171,
+            356,
+            825,
+            385
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mostafa Dehghani, Stephan Gouws, Oriol Vinyals, Jakob Uszkoreit, and Lukasz Kaiser. Universal transformers. In Proc. International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Honghua Dong, Jiayuan Mao, Tian Lin, Chong Wang, Lihong Li, and Denny Zhou. Neural logic machines. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Evans and Edward Grefenstette. Learning explanatory rules from noisy data. Journal of Artificial Intelligence Research, 61:1–64, 2018. ",
+        "bbox": [
+            169,
+            476,
+            826,
+            506
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marta Garnelo and Murray Shanahan. Reconciling deep learning with symbolic artificial intelligence: representing objects and relations. Current Opinion in Behavioral Sciences, 29:17–23, 2019. ",
+        "bbox": [
+            171,
+            516,
+            826,
+            545
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marta Garnelo, Kai Arulkumaran, and Murray Shanahan. Towards deep symbolic reinforcement learning. arXiv preprint: 1609.05518, 2016. ",
+        "bbox": [
+            174,
+            556,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lisa Getoor and Ben Taskar (eds.). Introduction to Statistical Relational Learning. MIT Press, 2007. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            612
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stevan Harnad. The symbol grounding problem. Physica D: Nonlinear Phenomena, 42(1-3):335–346, 1990. ",
+        "bbox": [
+            173,
+            622,
+            826,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017a. ",
+        "bbox": [
+            174,
+            662,
+            826,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Arka Pal, Andrei Rusu, Loïc Matthey, Christopher Burgess, Alexander Pritzel, Matthew Botvinick, Charles Blundell, and Alexander Lerchner. DARLA: improving zero-shot transfer in reinforcement learning. In Proc. 34th International Conference on Machine Learning, pp. 1480–1490, 2017b. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irina Higgins, Nicolas Sonnerat, Loic Matthey, Arka Pal, Christopher P Burgess, Matko Bosnjak, Murray Shanahan, Matthew Botvinick, Demis Hassabis, and Alexander Lerchner. Scan: Learning hierarchical compositional visual concepts. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            799,
+            826,
+            856
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. Clevr: A diagnostic dataset for compositional language and elementary visual reasoning. In Proc. IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 1988–1997, 2017. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ken Kansky, Tom Silver, David A. Mély, Mohamed Eldawy, Miguel Lázaro-Gredilla, Xinghua Lou, Nimrod Dorfman, Szymon Sidor, Scott Phoenix, and Dileep George. Schema networks: Zero-shot transfer with a generative causal model of intuitive physics. In Proc. 34th International Conference on Machine Learning, volume 70, pp. 1809–1818, 2017. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Tomer D Ullman, Joshua B Tenenbaum, and Samuel J Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, 40:e253, 2017. ",
+        "bbox": [
+            169,
+            169,
+            825,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gary Marcus. Deep learning: a critical appraisal. arXiv preprint arXiv:1801.00631, 2018. ",
+        "bbox": [
+            173,
+            207,
+            764,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John McCarthy. Generality in artificial intelligence. Communications of the ACM, 30(12):1030–1035, 1987. ",
+        "bbox": [
+            173,
+            231,
+            825,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rasmus Berg Palm, Ulrich Paquet, and Ole Winter. Recurrent relational networks. In Advances in Neural Information Processing Systems, pp. 3368–3378, 2018. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            296
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sébastien Racanière, Théophane Weber, David P. Reichert, Lars Buesing, Arthur Guez, Danilo Rezende, Adria Puigdomènech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, Razvan Pascanu, Peter Battaglia, Demis Hassabis, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. In Advances in Neural Information Processing Systems, pp. 5694–5705, 2017. ",
+        "bbox": [
+            174,
+            306,
+            826,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Rocktäschel and Sebastian Riedel. End-to-end differentiable proving. In Advances in Neural Information Processing Systems, pp. 3788–3800, 2017. ",
+        "bbox": [
+            174,
+            385,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stuart Russell and Peter Norvig. Artificial Intelligence: A Modern Approach. Prentice Hall Press, 3rd edition, 2009. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Tim Lillicrap. A simple neural network module for relational reasoning. In Advances in Neural Information Processing Systems, pp. 4974–4983, 2017. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, Ryan Faulkner, David Raposo, Rae Jack, Mike Chrzanowski, Théophane Weber, Oriol Vinyals, Razvan Pascanu, and Tim Lillicrap. Relational recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 7299–7310, 2018. ",
+        "bbox": [
+            176,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Schwarz, Wojciech Czarnecki, Jelena Luketina, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In Proc. 35th International Conference on Machine Learning, volume 80, pp. 4528–4537, 2018. ",
+        "bbox": [
+            174,
+            563,
+            826,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian Cantwell Smith. The Promise of Artificial Intelligence: Reckoning and Judgment. MIT Press, 2019. ",
+        "bbox": [
+            171,
+            628,
+            825,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Danqi Chen, Christopher Manning, and Andrew Ng. Reasoning with neural tensor networks for knowledge base completion. In Advances in Neural Information Processing Systems, pp. 926–934, 2013. ",
+        "bbox": [
+            171,
+            666,
+            825,
+            709
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            761
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Ross Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In Proc. IEEE Conference on Computer Vision and Pattern Recognition, 2018. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vinicius Zambaldi, David Raposo, Adam Santoro, Victor Bapst, Yujia Li, Igor Babuschkin, Karl Tuyls, David Reichert, Timothy Lillicrap, Edward Lockhart, Murray Shanahan, Victoria Langston, Razvan Pascanu, Matthew Botvinick, Oriol Vinyals, and Peter Battaglia. Deep reinforcement learning with relational inductive biases. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            176,
+            808,
+            825,
+            877
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/89535ddb8059ff6c8b5bf8fc4f4f63b9d652027f787189ecb55ac10b05e16671.jpg",
+        "table_caption": [
+            "Table S2: Default hyperparameters "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Parameter</td><td>Value</td></tr><tr><td>Input images size L size Runs per experiment Optimiser Learning rate</td><td>36×36×3 25×34 10 Gradient descent</td></tr><tr><td>Batch size Input CNN output channels Input CNN filter size Input CNN stride Input CNN activation</td><td>0.01 10 32 12 6 ReLu</td></tr><tr><td>Bias Output MLP hidden layer size Output MLP output size Output MLP activation</td><td>Yes 8 2(4) ReLu</td></tr><tr><td>Bias MLP1 output size MLP1 activation Bias</td><td>Yes (both) k(j+4) ReLu Yes</td></tr><tr><td>MLP2 hidden layer size MLP2 activations MLP2 output size</td><td>1024 ReLu k(j+4)</td></tr><tr><td>Bias RN MLP hidden layer size (pre-aggregation) RN output size RN activation RN aggregation</td><td>Yes (both) 256 k(j+4) ReLu Element-wise mean</td></tr><tr><td>Bias MHA no. of heads MHA key / query size MHA value size MHA output size MHA attention mechanism</td><td>No k 16 j+4 k(j+4)</td></tr><tr><td>Bias PrediNet no. of heads PrediNet key /query size PrediNet relations PrediNet output size Bias</td><td>softmax(QKT)V No k=32 g=16 j=16 k(j+4) n/a</td></tr></table>",
+        "bbox": [
+            266,
+            121,
+            730,
+            731
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S1 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            752,
+            390,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table S2 shows the default hyperparameters used for the experiments reported in the main text. ",
+        "bbox": [
+            171,
+            785,
+            794,
+            800
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S2 SUPPLEMENTARY ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            455,
+            838
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "S2.1 DIMENSIONALITY REDUCTION ON INTERMEDIATE REPRESENTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            705,
+            869
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "To qualitatively assess the nature of the representations produced by each architecture, we performed a dimensionality reduction analysis on the outputs of the central module of each architecture trained on the ‘colour / shape’ task. After training, a batch of 10,000 images (pentominoes) was passed through the network and principal component analysis (PCA) was performed on the resulting representations, which were then projected onto the two largest principal components for visualisation. The projected representations were then colour-coded by the labels for the corresponding images (i.e. different/same shape, different/same colour). ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/36b3ab57bcda64ccb6e16a7440f9f151ad5761bef3f81474d0a0e483fae80456.jpg",
+        "image_caption": [
+            "Figure S8: Representative central module outputs for networks trained on the ‘colour / shape’ task when projected onto the two largest principal components. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            823,
+            210
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            306,
+            825,
+            362
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "PCA on the full representations (concatenating the head outputs in the case of the PrediNet and MHA models) did not yield any clear clustering of representations according to the labels for any of the models (Figure S8). ",
+        "bbox": [
+            174,
+            369,
+            825,
+            411
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the PrediNet and MHA models, we also ran separate PCAs on the output relations of each head in order to see how distributed / disentangled the representations were. While in the MHA model there was no evidence of clustering by label on any of the heads, reflecting a heavily distributed representation, there were several heads in the PrediNet architecture that individually clustered the different labels (Figure S9). In some heads, colour and shape seemed to be projected along separate axes (e.g. heads 5, 26, and 27), while in others objects with different colours seemed to be organised in a hexagonal grid (e.g. heads 9 and 14). ",
+        "bbox": [
+            174,
+            417,
+            825,
+            516
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We noted that the clustering was preserved (though slightly compressed in PC space) when the held-out set of images (hexominoes) was passed through the PrediNet and projected onto the same principal components derived using the training set. (In Section S2.2, we show that the PrediNet heads that seem to cluster the labels also attend to the two objects in the image rather than the background.) ",
+        "bbox": [
+            174,
+            522,
+            825,
+            593
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "S2.2 ATTENTION ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            379,
+            655
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To assess the extent to which the various PrediNet heads attend to actual objects as opposed to the background, we produced a lower resolution content mask for each image (with the same resolution as the attention mask) containing 0.0s at locations where there are no objects in the corresponding pixels of the full image, 1.0s where more than $9 0 \\%$ of the pixels contain an object, and 0.5s otherwise. By applying the attention mask to the content mask, and summing the resulting elements, we produced a scalar indicating whether the attention mask was selecting a region of the image with an object (value close to 1.0), or the background (value close to 0.0). This was tested over 1000 images from the training set (Fig. S10), but similar results are obtained if the held-out set images are used instead. The top plot in Fig. S10 shows that both attention masks of some heads consistently attend to objects, while others to a combination of object and background. Importantly, the heads for which the PCA meaningfully clusters the labels are also the ones in which both attention masks attend to objects (Fig. S9). ",
+        "bbox": [
+            173,
+            680,
+            825,
+            847
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We additionally provide a similar analysis with a position mask, where each pixel in the mask contains a unique location index. The middle plot in Fig. S10 shows that the attention masks in the majority of the heads do not consistently attend to specific locations. Finally, the mean absolute values of the per-head input weights to the output MLP are shown in the bottom plot of the same figure. Interestingly, the heads that consistently attend only to objects have higher weighting than the rest. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/60fcf6158b9120b47d4d6ec35eb75643d6f7b54b3a4cff11e69a401b4640b8c5.jpg",
+        "image_caption": [
+            "Figure S9: Per-head PCA on the heads of a PrediNet and an MHA trained on the ‘colour / shape’ task. For all networks, PCA was performed using the training data (pentominoes). In (a) and (c), the training data are projected onto the two largest PCs and in (b) the test data (hexominoes) was used. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            11,
+            792,
+            873
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4569f18d7bfab316f74b150c607aad2dc1c6754409abc595880ab63c07791cd.jpg",
+        "image_caption": [
+            "Figure S10: Top: The extent to which the two attention masks of the different heads attend to objects rather than the background. Middle: The extent to which the two attention masks of the different heads attend to specific locations in the image. Bottom: Mean absolute value of the weights from the different PrediNet heads to the output MLP. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            94,
+            823,
+            324
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "S3 EXPERIMENTAL VARIATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            459,
+            433
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Further experimental results are provided in this section, including variations in hyper-parameters. Fig. S11 presents test accuracy curves for the ‘stripes’ object set, for which a summary is presented in Table 1 of the main text. Fig. S12 shows the results on the same experiment but using the Adam optimiser instead of SGD, with a learning rate of $1 0 ^ { - 4 }$ . The TensorFlow default values for all other Adam parameters were used. While other learning rate values were also tested, a value of $1 0 ^ { - 4 }$ gave the best overall performance for all architectures. Multi-task experiments were also performed using Adam with the same learning rate (Fig. S14 & S15), yielding an overall similar performance to SGD with a learning rate of $1 0 ^ { - 2 }$ . ",
+        "bbox": [
+            173,
+            446,
+            825,
+            559
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "To assess the extent to which the number of heads and relations plays a role in the performance, we ran experiments with $k = 6 4$ heads and $j = 1 6$ relations (Fig. S16 & S17), as well as $k = 1 6$ heads and $j = 3 2$ relations (Fig. S18 & S19). The results indicate that having a greater number of heads leads to better performance than having a greater number of relations, because they provide more stability during training and, perhaps, a richer propositional representation. ",
+        "bbox": [
+            174,
+            566,
+            825,
+            637
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/e55710561f4221861926a9e18d2d5f78c64350ab15660426ad476788bb600088.jpg",
+        "image_caption": [
+            "Figure S11: Relations Game learning curves for the different models. SGD with a learning rate of 0.01 was used with a PrediNet of $k = 3 2$ heads and $j = 1 6$ relations. The top and bottom rows show results for the ‘hexominoes’ held-out object set, while the middle row is for the ‘stripes’ held-out object set. The results for the top 10 batches are summarised in Table 1 of the main manuscript. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            133,
+            823,
+            455
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/351913f8c8b1f54ae80ce7970dbec2c8500ba8f58a45f23777cbdb5d88d9f8d1.jpg",
+        "image_caption": [
+            "Figure S12: Relations Game learning curves for the different models trained with the Adam optimiser (learning rate: $1 0 ^ { - 4 }$ ). All other experimental parameters are the same as Fig. S11. The top row shows results for the ‘hexominoes’ held-out object set, while the bottom row is for the ‘stripes’ held-out object set "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            603,
+            823,
+            818
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b166ce338e6c8c1fb47d4965122c2810e12d1933b5cbc2a4d51ad0cf7f13582.jpg",
+        "image_caption": [
+            "Figure S13: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used, with $k = 3 2$ and $j = 1 6$ . Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. From left to right, the combinations of target / pre-training tasks are: (‘match rows’, $^ { 6 } 3$ row patterns’), (‘5 column patterns’, ‘between’), (‘3 column patterns’, ‘between’), (‘match rows’, ‘3 column patterns’) and (‘5 row patterns’, ‘5 column patterns’). From top to bottom, the different architectures are: MLP1, MLP2, relation net (RN), multi-head attention (MHA) and PrediNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            188,
+            816,
+            707
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/438677fc2c32f9264113574e9859491717d1af6cd24f9efd4817231792a1e21f.jpg",
+        "image_caption": [
+            "Figure S14: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures, as in Fig. S13. The Adam optimiser with a learning rate of $1 0 ^ { - 4 }$ was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            217,
+            816,
+            734
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ae73376016f90ba446129a0675ad8251826ac53c58839895314cca843417074.jpg",
+        "image_caption": [
+            "Figure S15: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All architectures were trained using Adam, with a learning rate of $1 0 ^ { - 4 }$ . The experimental setup is the same as in Fig. S14. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            377,
+            820,
+            587
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/b3a3f8d5d0f1e66fd8c57d7739e66748a85008026ee7da8ec7e62675a6c6cf0c.jpg",
+        "image_caption": [
+            "Figure S16: Multi-task curriculum training. The columns correspond to different target/pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. The experimental setup is the same as for Fig. S13, except that $k = 6 4$ and $j = 1 6$ . Increasing the number of heads for the PrediNet increases the stability during training and overall performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            203,
+            816,
+            719
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/fe3733dde7f98be808bb1cff19aa3b855fd08735c1ecbe79f2227548bebd550b.jpg",
+        "image_caption": [
+            "Figure S17: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All experimental parameters are as in Fig. S16. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            385,
+            820,
+            593
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/12bbf29c7db9f32ba4885e1dd56886fea9ea2076ae44983130a2c038013eb282.jpg",
+        "image_caption": [
+            "Figure S18: Multi-task curriculum training. The columns correspond to different target / pre-training task combinations, while the rows correspond to the different architectures. SGD with a learning rate of 0.01 was used. Training was performed using the pentominoes object set and testing using the ‘stripes’ object set. The experimental setup is the same as for Fig. S13, except that $k = 1 6$ and $j = 3 2$ . Having fewer heads leads to a decrease in performance, even if the number of relations is increased to maintain network size. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            203,
+            816,
+            719
+        ],
+        "page_idx": 22
+    },
+    {
+        "type": "image",
+        "img_path": "images/e49c46ea61614d246526938d200c4e60e0508fd16db4490b45865d1c0c83e83e.jpg",
+        "image_caption": [
+            "Figure S19: Reusability of representations learned with a variety of target and pre-training tasks, using the ‘stripes’ object set. All experimental parameters are as in Fig. S18. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            385,
+            820,
+            593
+        ],
+        "page_idx": 23
+    }
+]

parse/train/SJJQVZW0b/SJJQVZW0b.md

@@ -0,0 +1,357 @@
+# HIERARCHICAL AND INTERPRETABLE SKILL ACQUISITION IN MULTI-TASK REINFORCEMENT LEARNING
+
+Tianmin Shu∗ University of California, Los Angeles tianmin.shu@ucla.edu
+
+Caiming Xiong†& Richard Socher Salesforce Research {cxiong, rsocher}@salesforce.com
+
+# ABSTRACT
+
+Learning policies for complex tasks that require multiple different skills is a major challenge in reinforcement learning (RL). It is also a requirement for its deployment in real-world scenarios. This paper proposes a novel framework for efficient multi-task reinforcement learning. Our framework trains agents to employ hierarchical policies that decide when to use a previously learned policy and when to learn a new skill. This enables agents to continually acquire new skills during different stages of training. Each learned task corresponds to a human language description. Because agents can only access previously learned skills through these descriptions, the agent can always provide a human-interpretable description of its choices. In order to help the agent learn the complex temporal dependencies necessary for the hierarchical policy, we provide it with a stochastic temporal grammar that modulates when to rely on previously learned skills and when to execute new skills. We validate our approach on Minecraft games designed to explicitly test the ability to reuse previously learned skills while simultaneously learning new skills.
+
+# 1 INTRODUCTION
+
+Deep reinforcement learning has demonstrated success in policy search for tasks in domains like game playing (Mnih et al., 2015; Silver et al., 2016; 2017; Kempka et al., 2016; Mirowski et al., 2017) and robotic control (Levine et al., 2016a;b; Pinto & Gupta, 2016). However, it is very difficult to accumulate multiple skills using just one policy network Teh et al. (2017). Knowledge transfer techniques like distillation (Bengio, 2012; Rusu et al., 2016; Parisotto et al., 2016; Teh et al., 2017) have been applied to train a policy network both to learn new skills while preserving previously learned skill as well as to combine single-task policies into a multi-task policy. Existing approaches usually treat all tasks independently. This often prevents full exploration of the underlying relations between different tasks. They also typically assume that all policies share the same state space and action space. This precludes transfer of previously learned simple skills to a new policy defined over a space with differing states or actions.
+
+When humans learn new skills, we often take advantage of our existing skills and build new capacities by composing or combining simpler ones. For instance, learning multi-digit multiplication relies on the knowledge of single-digit multiplication; learning how to properly prepare individual ingredients facilitates cooking dishes based on complex recipes.
+
+Inspired by this observation, we propose a hierarchical policy network which can reuse previously learned skills alongside and as subcomponents of new skills. It achieves this by discovering the underlying relations between skills.
+
+To represent the skills and their relations in an interpretable way, we also encode all tasks using human instructions such as “put down.” This allows the agent to communicate its policy and generate plans using human language. Figure 1 illustrates an example: given the instruction “Stack blue,” our hierarchical policy learns to compose instructions and take multiple actions through a multi-level hierarchy in order to stack two blue blocks together. Steps from the top-level policy $\pi _ { 3 }$ (i.e., the red branches) outline a learned high-level plan – “Get blue Find blue Put blue.” In addition, from lower level policies, we may also clearly see composed plans for other tasks. Based on policy $\pi _ { 2 }$ , for instance, the task “Get blue” has two steps – “Find blue action: turn left,” whereas “Put blue” can be executed by a single action “put down” according to $\pi _ { 3 }$ . Through this hierarchical model, we may i) accumulate tasks progressively from a terminal policy to a top-level policy and ii) unfold the global policy from top-level to basic actions.
+
+![](images/4413927ac73dea13f3fbeb9963537490bbf5769bcca990701fd8974a57a20a6b.jpg)  
+Figure 1: Example of our multi-level hierarchical policy for a given task – stacking two blue blocks. Each arrow represents one step generated by a certain policy and the colors of arrows indicate the source policies. Note that at each step, a policy either utters an instruction for the lower-level policy or directly takes an action.
+
+In order to better track temporal relationships between tasks, we train a stochastic temporal grammar (STG) model on the sequence of policy selections (previously learned skill or new skill) for positive episodes. The STG focuses on modeling priorities of tasks: for example, it is necessary to obtain an object before putting it down. Integrating the STG into the hierarchical policy boosts efficiency and accuracy by explicitly modeling such commonsense world knowledge.
+
+We validated our approach by testing it on object manipulation tasks implemented in a Minecraft world. Our experimental results demonstrate that this framework can (i) efficiently learn hierarchical policies and representations for multi-task RL; (ii) learn to utter human instructions to deploy pretrained policies, improve their explainability and reuse skills; and (iii) learn a stochastic temporal grammar via self-supervision to predict future actions.
+
+# 2 RELATED WORK
+
+Multi-task Reinforcement Learning. Previous work on multi-task reinforcement learning mainly falls into two families: knowledge transfer through distillation (Rusu et al., 2016; Parisotto et al., 2016; Teh et al., 2017; Tessler et al., 2017) or modular policy design through 2-layer hierarchical policy (Andreas et al., 2017). Our multi-level policy is more similar to the latter approach. The main differences between our model and the one in Andreas et al. (2017) are two-fold: i) we do not assume that a global task can be executed by only performing predefined sub-tasks; ii) in our multi-level policy, global tasks at a lower-level layer may also be used as sub-tasks by global tasks carried out at higher-levels.
+
+Hierarchical Reinforcement Learning. Complex policies often require the modeling of longer temporal dependencies than what standard Markov decision processes (MDPs) can capture. To combat this, hierarchical reinforcement learning was introduced to extend MDPs to semi-MDPs (Sutton et al., 1999), where options (or macro actions) are introduced on top of primitive actions to decompose the goal of a task into multiple subgoals. In hierarchical RL, two sets of policies are trained: local policies that map states to primitive actions for achieving subgoals, and a global policy that initiates suitable subgoals in a sequence to achieve the final goal of a task (Bacon & Precup, 2015; Kulkarni et al., 2016; Vezhnevets et al., 2016; Tessler et al., 2017; Andreas et al.,
+
+2017). This two-layer hierarchical policy design significantly improves the ability of discovering complex policies which can not be learned by flat policies. However, it also often makes some strict assumptions that limit its flexibility: i) a task’s global policy cannot use a simpler task’s policy as part of its base policies; ii) a global policy is assumed to be executable by only using local policies over specific options, e.g., (Kulkarni et al., 2016; Andreas et al., 2017). In this work, we aim to learn a multi-level global policy which does not have these two assumptions. In addition, previous work usually uses a latent variable to represent a task. In our work, we encode a task by a human instruction to learn a task-oriented language grounding as well as to improve the interpretability of plans composed by our hierarchical policies.
+
+Language grounding via reinforcement learning. Recently, there has been work on grounding human language in 3D game environments (Hermann et al., 2017; Chaplot et al., 2017) or in text-based games (Narasimhan et al., 2015) via reinforcement learning. In these games agents are instructed to pick up an item described by a sentence. Besides visual grounding, Andreas et al. (2017) grounded instructions (not necessarily using human language) to local policies in hierarchical reinforcement learning. Our approach not only learns the language grounding for both visual knowledge and policies, but is also trained to utter human instructions as an explicit explanation of its decisions to humans. To our knowledge, this is the first model that learns to compose plans for complex tasks based on simpler ones which have human descriptions.
+
+# 3 MODEL
+
+In this section, we discuss our multi-task RL setting, hierarchical policy, stochastic temporal grammar, and how interaction of these components can achieve plan composition.
+
+# 3.1 MULTITASK RL SETTING
+
+Let $\mathcal { G }$ be a task set, where each task $g$ is uniquely described by a human instruction. For simplicity, we assume a two-word tuple template consisting of a skill and an item for such a phrase, i.e., $\langle u _ { \mathrm { s k i l l } } , u _ { \mathrm { i t e m } } \rangle$ . Each tuple describes an object manipulation task. In this paper, we define $g = \langle u _ { \mathrm { s k i l l } } , u _ { \mathrm { i t e m } } \rangle$ by default, thus tasks and instructions are treated as interchangeable concepts.
+
+For each task, we define a Markov decision process (MDP) represented by states $s \in S$ and primitive actions $a \in { \mathcal { A } }$ . Rewards are specified for goals of different tasks, thus we use a function $R ( s , g )$ to signal the reward when performing any given task $g$ .
+
+We assume that as a starting point, we have a terminal policy $\pi _ { 0 }$ (as shown in Figure 2a) trained for a set of basic tasks (i.e., a terminal task set $\mathcal { G } _ { 0 }$ ). The task set is then progressively increased as the agent is instructed to do more tasks by humans at multiple stages, such that ${ \mathcal { G } } _ { 0 } \subset { \mathcal { G } } _ { 1 } \subset \cdots \subset { \mathcal { G } } _ { K }$ , which results in life-long learning of polices from $\pi _ { 0 }$ for $\mathcal { G } _ { 0 }$ to $\pi _ { K }$ for $\mathcal { G } _ { K }$ as illustrated by the “task accumulation” direction in Figure 1. At stage $k > 0$ , $\mathcal { G } _ { k - 1 }$ is defined as the base task set of $\mathcal { G } _ { k }$ . The tasks in $\mathcal { G } _ { k - 1 }$ are named as base tasks at this stage and $\pi _ { k - 1 }$ becomes the base policy of $\pi _ { k }$ . Here, we utilize weak supervision from humans to define what tasks shall be augmented to the previous task set at each new stage.
+
+# 3.2 HIERARCHICAL POLICY
+
+One of our key ideas is that a new task in current task set $\mathcal { G } _ { k }$ may be decomposed into several simpler subtasks, some of which can be base tasks in $\mathcal { G } _ { k - 1 }$ executable by base policy $\pi _ { k - 1 }$ . Therefore, instead of using a flat policy (Figure 2a) as $\pi _ { 0 }$ that directly maps state and human instruction to a primitive action, we propose a hierarchical design (Figure 2b) with the ability to reuse the base policy (i.e., $\pi _ { k - 1 }$ ) for performing base tasks as subtasks. Namely, at stage $k$ , the global policy $\pi _ { k }$ is defined by a hierarchical policy. This hierarchy consists of four sub-policies: a base policy for executing previously learned tasks, an instruction policy that manages communication between the global policy and the base policy, an augmented flat policy which allows the global policy to directly execute actions, and a switch policy that decides whether the global policy will primarily rely on the base policy or the augmented flat policy.
+
+The base policy is defined to be the global policy at the previous stage $k - 1$ . The instruction policy maps state $s$ and task $g \in { \mathcal { G } } _ { k }$ to a base task $g ^ { \prime } \in \mathcal { G } _ { k - 1 }$ . The purpose of this policy is to inform base policy $\pi _ { k - 1 }$ which base tasks it needs to execute. Since an instruction is represented by two words, −we define the instruction policy using two conditionally independent distributions, i.e., $\pi _ { k } ^ { \mathrm { i n s t } } ( g ^ { \prime } =$ $\langle u _ { \mathrm { s k i l l } } , u _ { \mathrm { i t e m } } \rangle | s , g ) = p _ { k } ^ { \mathrm { s k i l l } } ( u _ { \mathrm { s k i l l } } | s , g ) p _ { k } ^ { \mathrm { i t e m } } ( u _ { \mathrm { i t e m } } | s , g )$ . An augmented flat policy, $\pi _ { k } ^ { \mathrm { a u g } } ( a | s , \tilde { g } )$ , maps state $s$ and task $g$ to a primitive action $a$ for ensuring that the global policy is able to perform novel tasks in $\mathcal { G } _ { k }$ that can not be achieved by only reusing the base policy. To determine whether to perform a base task or directly perform a primitive action at each step, the global policy further includes a switch policy, $\pi _ { k } ^ { \mathrm { s w } } ( e | \bar { s } , \bar { g } )$ , where $e$ is a binary variable indicating the selection of the branches, $\pi _ { k } ^ { \mathrm { i n s t } }$ $e = 0$ ) or $\pi _ { k } ^ { \mathrm { a u g } }$ $( e = 1 )$ ).
+
+![](images/2a893964c5f174ad83afb2c3b4400b746dba3bee5f8ec8a7d2533674a304ac37.jpg)  
+Figure 2: Flat and hierarchical policy architectures. $V ( s , g )$ and $V ^ { \mathrm { S W } } ( s , e , g )$ are value functions defined in Section 4.1.
+
+Note that the above description of the hierarchical policy does not account for an STG. The instruction policy and switch policy introduced here are simplified from the ones in the full model (see Section 3.3).
+
+At each time step, we first sample $e _ { t }$ from our switch policy $\pi _ { k } ^ { \mathrm { s w } }$ to decide whether the global policy $\pi _ { k }$ will rely on the base policy $\pi _ { k - 1 }$ or the augmented flat policy $\pi _ { k } ^ { \mathrm { a u g } }$ . We also sample a new instruction $g _ { t } ^ { \prime }$ from our instruction policy $\pi _ { k } ^ { \mathrm { i n s t } }$ in order to sample actions from the base policy. This can be summarized as:
+
+$$
+\begin{array} { r } { e _ { t } \sim \pi _ { k } ^ { \mathrm { s w } } ( e _ { t } | s _ { t } , g ) , } \end{array}
+$$
+
+$$
+g _ { t } ^ { \prime } \sim \pi _ { k } ^ { \mathrm { i n s t } } ( g _ { t } ^ { \prime } | s _ { t } , g ) ,
+$$
+
+and finally
+
+$$
+a _ { t } \sim \pi _ { k } ( a _ { t } | s _ { t } , g ) = \pi _ { k - 1 } ( a _ { t } | s _ { t } , g _ { t } ^ { \prime } ) ^ { ( 1 - e _ { t } ) } \pi _ { k } ^ { \mathrm { a u g } } ( a _ { t } | s _ { t } , g ) ^ { e _ { t } } ,
+$$
+
+where $\pi _ { k }$ and $\pi _ { k - 1 }$ are the global policies at stage $k$ and $k - 1$ respectively. After each step, we will also obtain a reward $r _ { t } = R ( s _ { t } , g )$ .
+
+# 3.3 STOCHASTIC TEMPORAL GRAMMAR
+
+Different tasks may have temporal relations. For instance, to move an object, one needs to first find and pick up that object. There has been previous research (Si et al., 2011; Pirsiavash & Ramanan, 2014) using stochastic grammar models to capture such temporal relations. Inspired by this, we summarize temporal transitions between various tasks with a stochastic temporal grammar (STG). In our full model, the STG interacts with the hierarchical policy described above through the modified switch policy and instruction policy by using the STG as a prior. This amounts to treating the past history of switches and instructions in positive episodes as a guidance on whether the hierarchical policy should defer to the base policy to execute a specific base task or employ its own augmented flat policy to take a primitive action.
+
+In an episode, the temporal sequence of $e _ { t }$ and $g _ { t } ^ { \prime }$ , i.e., $\{ \langle e _ { t } , g _ { t } ^ { \prime } \rangle ; t \geq 0 \}$ , can be seen as a finite state Markov chain (Baum & Petrie, 1966). Note that the state here is referred to the tuple $\langle e _ { t } , g _ { t } ^ { \prime } \rangle$ , which is not the state of the game $s _ { t } \in S$ defined in Section 3.1. Consequently, at each level $k > 0$ , we may define an STG of a task $g$ by i) transition probabilities, $\rho _ { k } ( e _ { t } , \bar { g } _ { t } ^ { \prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \prime } , g )$ , and ii) the distribution of $\left. { e _ { 0 } , g _ { 0 } ^ { \prime } } \right.$ , $q _ { k } ( e _ { 0 } , g _ { 0 } ^ { \prime } | g )$ , all of which follow categorical distributions.
+
+With the estimated probabilities, we sample $e _ { t }$ and $g _ { t } ^ { \prime }$ in an episode at level $k > 0$ w.r.t. to reshaped policies $\pi _ { k } ^ { s w ^ { \prime } }$ and $\pi _ { k } ^ { \mathrm { i n s t } ^ { \prime } }$ respectively:
+
+• If $t = 0$ ,
+
+$$
+e _ { 0 } \sim \pi _ { k } ^ { \mathrm { s w \it / } } ( e _ { 0 } | s _ { t } , g ) \propto \pi _ { k } ^ { \mathrm { s w } } \big ( e _ { 0 } | s _ { t } , g \big ) \sum _ { g ^ { \prime } \in \mathcal { G } _ { k - 1 } } q _ { k } \big ( e _ { 0 } , g ^ { \prime } | g \big ) ,
+$$
+
+$$
+g _ { 0 } ^ { \prime } \sim \pi _ { k } ^ { \mathrm { i n s t } ^ { \prime } } ( g _ { 0 } ^ { \prime } | s _ { t } , g ) \propto \pi _ { k } ^ { \mathrm { i n s t } } ( g _ { 0 } ^ { \prime } | s _ { t } , g ) q _ { k } ( e _ { 0 } = 0 , g _ { 0 } ^ { \prime } | g ) ;
+$$
+
+• Otherwise,
+
+$$
+e _ { t } \sim \pi _ { k } ^ { \mathrm { s w \prime } } ( e _ { t } | e _ { t - 1 } , g _ { t - 1 } ^ { \prime } , s _ { t } , g ) \propto \pi _ { k } ^ { \mathrm { s w } } \big ( e _ { t } | s _ { t } , g \big ) \sum _ { g ^ { \prime } \in \mathcal { G } _ { k - 1 } } \rho _ { k } ( e _ { t } , g ^ { \prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \prime } , g ) ,
+$$
+
+$$
+g _ { t } ^ { \prime } \sim \pi _ { k } ^ { \mathrm { i n s t ^ { \prime } } } ( g _ { t } ^ { \prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \prime } , s _ { t } , g ) \propto \pi _ { k } ^ { \mathrm { i n s t } } ( g _ { t } ^ { \prime } | s _ { t } , g ) \rho _ { k } ( e _ { t } = 0 , g _ { t } ^ { \prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \prime } , g ) .
+$$
+
+Note that primitive action sampling is not affected by the STG.
+
+# 3.4 PLAN COMPOSITION
+
+Combined with our hierarchical policy and STG defined above, we are able to run an episode to compose a plan for a task specified by a human instruction. Algorithm 1 in Appendix A summarized this procedure with respect to the policy and STG at level $k$ . Note that to fully utilize the base policy, we assume that once triggered, a base policy will play to the end before the global policy considers the next move.
+
+# 4 LEARNING
+
+The learning algorithm is outlined in Algorithm 2 in Appendix A. We learn our final hierarchical policy through $k$ stages of skill acquisition. Each of these stages is broken down into a base skill acquisition phase and a novel skill acquisition phase in a 2-phase curriculum learning.
+
+In the base skill acquisition phase, we only sample tasks from the base task set $\mathcal { G } _ { k - 1 }$ . This ensures that the global policy learns how to use previously learned skills by issuing instructions to the base policy. In other words, this phase teaches the agent how to connect its instruction policy to its base policy. Once the average reward for all base tasks exceeds a certain threshold, we proceed to the next phase.
+
+In the novel skill acquisition phase, we sample tasks from the full task set, $\mathcal { G } _ { k }$ , for the $k \mathrm { . }$ -th stage of skill acquisition. It is in this phase that the agent can learn when to rely on the base policy and when to rely on the augmented flat policy for executing novel tasks.
+
+In each of these phases, all policies are trained with advantage actor-critic (A2C) (Section 4.1) and distributions in the STG are estimated based on accumulated positive episodes (Section 4.2).
+
+# 4.1 POLICY OPTIMIZATION BY ADVANTAGE ACTOR-CRITIC
+
+We use advantage actor-critic (A2C) for policy optimization with off-policy learning (Su et al., 2017). Here, we only consider the gradient for global policies (i.e., $k > 0 ,$ ) as we assume the terminal policy has been trained as initial condition. Let $V _ { k } ( s _ { t } , g )$ be a value function indicating the expected return given state $s _ { t }$ and task $g$ . To reflect the nature of the branch switching in our model, we introduce another value function $V _ { k } ^ { \operatorname { s w } } ( s _ { t } , e _ { t } , g )$ to represent the expected return given state $s _ { t }$ , task $g$ and current branch selection $e _ { t }$ .
+
+Thus, given a trajectory $\Gamma ~ = ~ \{ \langle s _ { t } , e _ { t } , g _ { t } ^ { \prime } , a _ { t } , r _ { t } , \mu _ { k } ^ { \mathrm { s w } } ( \cdot | s _ { t } ) , \mu _ { k } ^ { \mathrm { i n s t } } ( \cdot | s _ { t } , g ) , \mu _ { k } ^ { \mathrm { a u g } } ( \cdot | s _ { t } , g ) , g \rangle ~ : ~ t ~ =$ $0 , 1 , \cdots , T \}$ generated by old policies $\mu _ { k } ^ { \mathrm { s w } } ( \cdot | s _ { t } ) , \mu _ { k } ^ { \mathrm { i n s t } } ( \cdot | s _ { t } , g )$ , and $\mu _ { k } ^ { \mathrm { a u g } } ( \cdot | s _ { t } , g )$ , the policy gradient reweighted by importance sampling can be formulated as
+
+$$
+\begin{array} { r l } & { \underbrace { \omega _ { t } ^ { \mathrm { s w } } \nabla _ { \theta ^ { \mathrm { s w } } } \log \pi _ { k } ^ { \mathrm { s w } } ( e _ { t } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } ) } _ { \mathrm { 1 s t ~ t e r m : ~ s w i t c h ~ p o l i c y ~ g r a d i e n t } } } \\ { + } & { \underbrace { ( 1 - e _ { t } ) \omega _ { t } ^ { \mathrm { i n s t } } \nabla _ { \theta ^ { \mathrm { i n s t } } } \log \pi _ { k } ^ { \mathrm { i n s t } } ( g _ { t } ^ { \prime } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } , g _ { t } ^ { \prime } ) } _ { \mathrm { 2 n d ~ t e r m : ~ i n s t r u c t i o n ~ p o l i c y ~ g r a d i e n t } } } \\ { + } & { \underbrace { e _ { t } \omega _ { t } ^ { \mathrm { a u g } } \nabla _ { \theta ^ { \mathrm { a u g } } } \log \pi _ { k } ^ { \mathrm { a u g } } ( a _ { t } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } , a _ { t } ) } _ { \mathrm { . } } , } \end{array}
+$$
+
+where $\begin{array} { r } { \omega _ { t } ^ { \mathrm { s w } } = \frac { \pi _ { k } ^ { \mathrm { s w } } ( e _ { t } | s _ { t } , g ) } { \mu _ { k } ^ { \mathrm { s w } } ( e _ { t } | s _ { t } , g ) } } \end{array}$ , $\begin{array} { r } { \omega _ { t } ^ { \mathrm { i n s t } } ~ = ~ \frac { \pi _ { k } ^ { \mathrm { i n s t } } ( g _ { t } ^ { \prime } | s _ { t } , g ) } { \mu _ { k } ^ { \mathrm { i n s t } } ( g _ { t } ^ { \prime } | s _ { t } , g ) } } \end{array}$ , and $\begin{array} { r } { \omega _ { t } ^ { \mathrm { a u g } } = \frac { \pi _ { k } ^ { \mathrm { a u g } } ( a _ { t } | s _ { t } , g ) } { \mu _ { k } ^ { \mathrm { a u g } } ( a _ { t } | s _ { t } , g ) } } \end{array}$ are importance sampling weights for the three terms respectively; $A ( s _ { t } , g , e _ { t } )$ , $A ( s _ { t } , g , e _ { t } , g _ { t } ^ { \prime } )$ , and $A ( s _ { t } , g , e _ { t } , a _ { t } )$ are estimates of advantage functions, which have multiple possible definitions. In this paper, we define e, $A ( s _ { t } , g , e _ { t } ) =$ ${ \sum } _ { \tau = 0 } ^ { \infty } \overset { \cdot } { \gamma } { \tilde { F } } ( s _ { t + \tau } , g ) \ - \ V _ { k } ( s _ { t } , g )$ $\begin{array} { r c l } { { \hat { A ( \boldsymbol { s } _ { t } , \boldsymbol { g } , \boldsymbol { e } _ { t } , \boldsymbol { g } _ { t } ^ { \prime } ) } ~ = ~ { \cal A ( \boldsymbol { s } _ { t } , \boldsymbol { g } , \boldsymbol { e } _ { t } , \boldsymbol { a } _ { t } ) } ~ = ~ \sum _ { \tau = 0 } ^ { \infty } \gamma ^ { \tau } \hat { R } ( \boldsymbol { s } _ { t + \tau } , \boldsymbol { g } ) ~ - } } \end{array}$ $V _ { k } ^ { \mathrm { s w } } ( s _ { t } , g , e _ { t } )$ , where $\gamma$ tis the discounted coefficient.
+
+Finally, the value functions can be updated using the following gradient:
+
+$$
+\nabla _ { \theta _ { v } } \frac { 1 } { 2 } \left[ \sum _ { \tau = 0 } ^ { \infty } \gamma ^ { \tau } R ( s _ { t + \tau } , g ) - V _ { k } ( s _ { t } , g ) \right] ^ { 2 } + \nabla _ { \theta _ { v } ^ { \mathrm { s w } } } \frac { 1 } { 2 } \left[ \sum _ { \tau = 0 } ^ { \infty } \gamma ^ { \tau } R ( s _ { t + \tau } , g ) - V _ { k } ^ { \mathrm { s w } } ( s _ { t } , e _ { t } , g ) \right] ^ { 2 } .
+$$
+
+To increase the episode efficiency, after running an episode, we conduct $n$ mini-batch updates where $n$ is sampled from a Poisson distribution with $\lambda = 4$ , similar to Wang et al. (2017). Note that one can also apply other common policy optimization methods, e.g., A3C (Mnih et al., 2016), to our model. We leave this as future work to evaluate the efficiency of different methods when using our model.
+
+Optimizing all three sub-policies together leads to unstable learning. To avoid this, we apply a simple alternating update procedure. For each set of $M$ iterations, we keep two of the sub-policies fixed and train only the single policy that remains. When we reach $M$ iterations, we switch the policy that is trained. For all experiments in this paper, we use $M = 5 0 0$ . This alternating update procedure is used within both phases of curriculum learning.
+
+# 4.2 LEARNING AN STG
+
+If at any point in the aforementioned training process the agent receives a positive reward after an episode, we update the stochastic temporal grammar. $\rho _ { k }$ and $q _ { k }$ of the STG are both initialized to be uniform distributions. Since the STG is a finite state Markov chain over tuples $\left. { e _ { t } , g _ { t } ^ { \prime } } \right.$ , we use maximum likelihood estimation (MLE) to update the distributions (Baum & Petrie, 1966). As the training progresses, the STG starts to guide the exploration.
+
+To avoid falling into local minima in the early stages of training, it is important to encourage random exploration in early episodes. Based on our experiments, we find that using $\epsilon$ -greedy suffices.
+
+# 5 EXPERIMENTS
+
+# 5.1 GAME ENVIRONMENT AND TASK SPECIFICATIONS
+
+Figure 3 (left) shows the two room environment in Minecraft that we created using the Malmo platform (Johnson et al., 2016). In each episode, an arbitrary number of blocks with different colors (totaling 6 colors in our experiments) are randomly placed in one of the two rooms. The agent is initially placed in the same room with the items. We consider five sets of tasks: i) ${ \mathcal { G } } ^ { ( 0 ) } = \{ { } ^ {  { } } \mathrm { F i n d } \mathrm { x } ^ {  } \}$ , walking to the front of a block with color $\mathbf { X }$ , ii) $\mathcal { G } ^ { ( 1 ) } = \{ { \bf \ddot { \Phi } } { \bf G e t x } ^ { , * } \}$ , picking up a block with color $\mathbf { X }$ , iii) $\mathcal { G } ^ { ( 2 ) } = \{ { ^ {  } \mathrm { P u t } } \mathrm { x } ^ { , , * } \}$ , putting down a block with color $\mathbf { X }$ , iv) $\mathcal { G } ^ { ( 3 ) } = \{ ^ { \cdots } \mathrm { S t a c k } \mathrm { x } ^ { \cdots } \}$ , stacking two blocks with color $\mathbf { X }$ together, and v) $\mathcal { G } ^ { ( 4 ) } = \{ { ^ { \mathrm { ? P u t ~ x ~ o n ~ y } } } \}$ , putting a block with color $\mathbf { X }$ on top of a block with a different color y. In total, there are 54 tasks. An agent can perform the following actions: “move forward,” “move backward,” “move left,” “move right,” “turn left,” “turn right,” “pick up,” “put down.”
+
+![](images/cf57cf2f333bf44708a29c1875358f75f741052352aafc00f4400f2bb462ec1a.jpg)  
+Figure 3: Room layout. Left: training environment; right: unseen rooms for testing.
+
+Without loss of generality, we assume the following skill acquisition order: $\mathcal { G } _ { k } = \cup _ { \kappa = 1 } ^ { k } \mathcal { G } ^ { ( \kappa ) }$ , $\forall k =$ $0 , 1 , 2 , 3 , 4$ , which is a natural way to increase skill sets. One may also alter the order, and the main conclusions shall still hold. This results in policies $\{ \pi _ { k } : k = \dot { 0 , } 1 , 2 , 3 , 4 \}$ for these four task sets. For the last task set, we hold out 6 tasks out of all 30 tasks (i.e., 3 pairs of colors out of 15 color combinations) for testing and the agent will not be trained on these 6 tasks.
+
+We adopt a sparse reward function: when reaching the goal of a task, the agent gets a $+ 1$ reward; when generating an instruction $g ^ { \prime }$ that is not executable in current game (e.g., trying to find an object that does not exist in the environment), we give a $- 0 . 5$ reward; otherwise, no reward will be given. Whenever a non-zero reward is given, the game terminates. Note that the negative reward is only given during training.
+
+# 5.2 IMPLEMENTATION DETAILS
+
+We specify the architecture of the modules in our model in Appendix B, where the visual and instruction encoding modules have the same architectures as the ones in Hermann et al. (2017). We train the network with RMSProp (Tieleman & Hinton, 2012) with a learning rate of 0.0001. We set the batch size to be 36 and clip the gradient to a unit norm. For all tasks, the discounted coefficient is $\gamma = 0 . 9 5$ . For the 2-phase curriculum learning, we set the average reward threshold to be 0.9 (average rewards are estimated from the most recent 200 episodes of each task).
+
+To encourage random exploration, we apply $\epsilon$ -greedy to the decision sampling for the global policy (i.e., only at the top level $k$ at each stage $k > 0$ ), where $\epsilon$ gradually decreases from 0.1 to 0.
+
+![](images/175631828543a6110950c7ec8016ac45f5e9a471c97beadfd6ead1193e4ee11a.jpg)  
+Figure 4: Comparison of learning efficiency on two task sets: (a) $\mathcal { G } _ { 1 }$ for global policy $\pi _ { 1 }$ and (b) $\mathcal { G } _ { 3 }$ for global policy $\pi _ { 3 }$ respectively.
+
+# 5.3 LEARNING EFFICIENCY
+
+To evaluate the learning efficiency, we compare our full model with 1) a flat policy (Figure 2a) as in Hermann et al. (2017) fine-tuned on the terminal policy $\pi _ { 0 }$ , 2) H-DRLN (Tessler et al., 2017) and variants of our approach: 3) ours without STG, 4) ours without alternating policy optimization, and 5) ours without $V _ { k } ^ { \mathrm { s w } } ( s , e , g )$ (replaced by $V _ { k } ( s , g )$ instead). Note that all the rewards have been converted to the same range, i.e., $[ 0 , 1 ]$ for the sake of fair comparison.
+
+![](images/395abc0c2629ae8cf2f89ef88a8c0ffcb82e634d6590d88ddd19764c2ea9b7a3.jpg)  
+Figure 5: Effects of different training protocols.
+
+Table 1: Success rates in different game settings including scenarios seen during training, new environments and new tasks. All policies are trained in the same environment in seen scenarios.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="5">Seen scenarios</td><td colspan="4">Unseen environments</td><td>Unseen tasks</td></tr><tr><td>Find x</td><td>Get x</td><td>Put x</td><td>Stack x</td><td>Put x on y</td><td>Find x</td><td>Get x</td><td>Put x</td><td>Stack x</td><td>Put x on y</td></tr><tr><td>Full model</td><td>0.995</td><td>0.970</td><td>1.00</td><td>0.955</td><td>0.873</td><td>0.723</td><td>0.648</td><td>1.00</td><td>0.613</td><td>0.792</td></tr><tr><td>Flat policy</td><td>0.980</td><td>0.965</td><td>1.00</td><td>0</td><td>0</td><td>0.515</td><td>0.450</td><td>1.00</td><td>0</td><td>0</td></tr></table>
+
+In Figure 4a, we use various methods to train policy $\pi _ { 1 }$ for the task set $\mathcal { G } _ { 1 }$ based on the same base policy $\pi _ { 0 }$ . The large dip in the reward indicates that the curriculum learning switches from phase 1 to phase 2. From Figure 4a, we may clearly see that our full model and variants can all converge within 22,000 episodes, whereas the average reward of the flat policy is still below 0.8 given the same amount of episodes. In addition, our full model finishes phase 1 significantly faster than other methods and its curve of average reward maintains notably higher than the remaining ones.
+
+To further examine the learning efficiency during phase 2 when new tasks are added into the training process, we first pretrain $\pi _ { 3 }$ using our full model following our definition of phase 1 in the curriculum learning. We then proceed to learning phase 2 using different approaches all based on this pretrained policy. As shown in Figure 4b, our full model has the fastest convergence and the highest average reward upon convergence. By comparing Figure 4a and Figure 4b, we further show that our full model has a bigger advantage when learning more complex tasks.
+
+Since we have a large number of previously learned tasks, H-DRLN is clearly not able to learn a descent policy according the results. Note that an H-DRLN can only learn one task at a time, each of its curves in Figure 4 is for a single task (i.e., “Get white” and “Stack white” respectively).
+
+To demonstrate the effects of our 2-phase curriculum learning and the $- 0 . 5$ penalty on the training efficiency, we visualize the learning curves of our model trained without the curriculum learning or without the penalty along with the one trained with the full protocol in Figure 5. According to the results, the curriculum learning indeed helps accelerate the convergence, which empirically proves the importance of encouraging a global policy to reuse relevant skills learned by its base policy. It also appears that adding the penalty is an insignificant factor on learning efficiency except that it helps shorten the episode lengths as an episode ends whenever a penalty is given.
+
+# 5.4 POLICY GENERALIZATION
+
+Finally, we evaluate how the hierarchical design and encoding tasks by human instructions benefit the generalization of learned policies in the following three ways.
+
+First, we train $\pi _ { 1 }$ in a simpler setting where in each episode, only one item (i.e, the target item of the given task) is present. We then test the policy $\pi _ { 1 }$ for “Get $\mathbf { X } ^ { \prime \prime }$ tasks in a room where there will be multiple items serving as distraction and the agent must interact with the correct one. Both the flat policy and the hierarchical policy can achieve near perfect testing success rate in the simple setting. However, in the more complex setting, flat policy can not differentiate the target item from other items that are also placed in the room (the success rate drops to $2 9 \%$ ), whereas our hierarchical policy still maintains a high success rate $( 9 4 \% )$ . This finding suggests that the hierarchical policy not only picks up the concept of “find” and “get” skills as the flat policy does, but also inherits the concept of items from the base policy by learning to utter correct instructions to deploy “find” skill in the base policy.
+
+Second, we reconfigure the room layout in Figure 3 (left) and test the flat policy and our full model in the new rooms shown in Figure 3 (right) for various tasks. Both policies are trained in the same environment. There are multiple items in a room for both training and testing cases. The success rates are summarized in Table 1. Using the flat policy results in a much bigger drop in the testing success rate compared to using out full model. This is mainly because that our global policy will repeatedly call its base policy to execute the same task until the agent finally achieves the goal even though the trained agent is unable to reach the goal by just one shot due to the simplicity of the training environment.
+
+Third, we evaluate the learned policy on the 6 unseen tasks for the “Put x on y” tasks as a zeroshort evaluation. The success rate reported in Table 1 suggests that our model is able to learn the decomposition of human instructions and generate correct hierarchical plans to perform unseen tasks.
+
+# 5.5 POLICY INTERPRETABILITY
+
+We visualize typical hierarchical plans of several tasks generated by global policies learned by our full model in Appendix C (Figure 6 and Figure 7)1. It can been seen from the examples that our global policies adjust the composed plans in different scenarios. For instance, in the second plan on the first row, $\pi _ { 1 }$ did not deploy base policy $\pi _ { 0 }$ as the agent was already in front of the target item at the beginning of the episode, whereas in the plan on the second row, $\pi _ { 1 }$ deployed $\pi _ { 0 }$ for the “Find $\mathbf { X } ^ { \prime \prime }$ base task twice consecutively, as it did not finish the base task in the first call.
+
+# 6 CONCLUSION
+
+In this work, we have proposed a hierarchal policy modulated by a stochastic temporal grammar as a novel framework for efficient multi-task reinforcement learning through multiple training stages. Each task in our settings is described by a human instruction. The resulting global policy is able to reuse previously learned skills for new tasks by generating corresponding human instructions to inform base policies to execute relevant base tasks. We evaluate this framework in Minecraft games and have shown that our full model i) has a significantly higher learning efficiency than a flat policy does, ii) generalizes well in unseen environments, and iii) is capable of composing hierarchical plans in an interpretable manner.
+
+Currently, we rely on weak supervision from humans to define what skills to be learned in each training stage. In the future, we plan to automatically discover the optimal training procedures to increase the task set.
+
+# REFERENCES
+
+Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with policy sketches. In International Conference on Machine Learning (ICML), 2017.
+
+Pierre-Luc Bacon and Doina Precup. The option-critic architecture. In NIPS Deep Reinforcement Learning Workshop, 2015.
+
+Leonard E. Baum and Ted Petrie. Statistical inference for probabilistic functions of finite state markov chains. The Annals of Mathematical Statistics, 37(6):1554–1563, 1966.
+
+Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In JMLR: Workshop on Unsupervised and Transfer Learning, 2012.
+
+Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.0723, 2017.
+
+Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, Marcus Wainwright, Chris Apps, Demis Hassabis, and Phil Blunsom. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017.
+
+Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The malmo platform for artificial intelligence experimentation. In International Joint Conference on Artificial Intelligence (IJCAI), 2016.
+
+Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Tocze, and Wojciech Jaskowski. Viz- ´ doom: A doom-based ai research platform for visual reinforcement learning. In IEEE Conference on Computational Intelligence and Games (CIG), 2016.
+
+Tejas D. Kulkarni, Karthik Narasimhan, Ardavan Saeedi, , and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016a.
+
+Sergey Levine, Peter Pastor, Alex Krizhevsky, Julian Ibarz, , and Deirdre Quillen. Learning handeye coordination for robotic grasping with deep learning and large-scale data collection. In ” International Symposium on Experimental Robotics (ISER), 2016b.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andy Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to navigate in complex environments. In International Conference on Learning Representations (ICLR), 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning (ICML), 2016.
+
+Karthik Narasimhan, Tejas Kulkarni, and Regina Barzilay. Language understanding for text-based games using deep reinforcement learning. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2015.
+
+Emilio Parisotto, Jimmy Lei Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In International Conference on Learning Representations (ICLR), 2016.
+
+Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In IEEE Conference on Robotics and Automation (ICRA), 2016.
+
+Hamed Pirsiavash and Deva Ramanan. Parsing videos of actions with segmental grammars. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2014.
+
+Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. In International Conference on Learning Representations (ICLR), 2016.
+
+Zhangzhang Si, Mingtao Pei, Benjamin Yao, and Song-Chun Zhu. Unsupervised learning of event and-or grammar and semantics from video. In IEEE International Conference on Computer Vision (ICCV), 2011.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, and Julian Schrittwieser et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George Van Den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017.
+
+Pei-Hao Su, Pawel Budzianowski, Stefan Ultes, Milica Gasic, and Steve Young. Sample-efficient actor-critic reinforcement learning with supervised data for dialogue management. In The 18th Annual SIGdial Meeting on Discourse and Dialogue (SIGDIAL), 2017.
+
+Richard S. Sutton, Doina Precup, and Satinder Singh. Between mdps anad semi-mdps: A framework fro temporal abstraction in reinforcement learning. Artificial Intelligence, 112:181–211, 1999.
+
+Yee Whye Teh, Victor Bapst, Wojciech Marian Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In International Conference on Learning Representations (ICLR), 2017.
+
+Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierarchical approach to lifelong learning in Minecraft. In AAAI Conference on Artificial Intelligence (AAAI), 2017.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Alexander (Sasha) Vezhnevets, Volodymyr Mnih, John Agapiou, Simon Osindero, Alex Graves, Orial Vinyals, and Koray Kavukcuoglu. Strategic attentive writer for learning macro-actions. In Advances in Neural Information Processing Systems (NIPS), 2016.
+
+Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. In International Conference on Learning Representations (ICLR), 2017.
+
+# A PSEUDO CODE OF OUR ALGORITHMS
+
+# Algorithm $1 \mathrm { R U N } ( k , g )$
+
+Input: Policy level $k$ , task $g \in { \mathcal { G } } _ { k }$   
+Output: Episode trajectory $\Gamma$ at the top level policy   
+1: $t \gets 0$   
+2: $\Gamma = \emptyset$   
+3: Get initial state $s _ { 0 }$   
+4: repeat   
+5: if ${ \bf k } = = 1$ then   
+6: Sample $a _ { t } \sim \pi _ { k } ( \cdot | s _ { t } , g )$ and execute $a _ { t }$   
+7: Get current state st+1   
+8: $r _ { t } \gets R ( s _ { t + 1 } , g )$   
+9: Add $\langle s _ { t } , a _ { t } , r _ { t } , \pi _ { k } ( \cdot | s _ { t } , g ) , g \rangle$ to $\Gamma$   
+10: else   
+11: Sample $e _ { t }$ and $g _ { t } ^ { \prime }$ as in Section 3.3 for using STG as guidance   
+12: Sample at ∼ πauk $a _ { t } \sim \pi _ { k } ^ { \mathrm { a u g } } ( \cdot | s _ { t } , g )$   
+13: if $e _ { t } = 0$ then   
+14: // Execute base policy $\pi _ { k - 1 }$ by giving instruction $g _ { t } ^ { \prime }$   
+15: $\mathrm { R U N } ( k - 1 , g _ { t } ^ { \prime } )$ 5   
+16: else   
+17: Execute $a _ { t }$   
+18: end if   
+19: Get current state st+1   
+20: $r _ { t } \gets R ( s _ { t + 1 } , g )$   
+21: Add $\langle s _ { t } , e _ { t } , g _ { t } ^ { \prime } , a _ { t } , r _ { t } , \pi _ { k } ^ { \mathrm { s w } } \big ( \cdot | s _ { t } \big ) , \pi _ { k } ^ { \mathrm { i n s t } } \big ( \cdot | s _ { t } , g \big ) , \pi _ { k } ^ { \mathrm { a u g } } \big ( \cdot | s _ { t } , g \big ) , g \rangle$ to Γ   
+22: end if   
+23: t ← t + 1   
+24: until t > T or $\boldsymbol r _ { t } \neq 0$
+
+# Algorithm 2 Learning global policy and STG at stage $k > 0$
+
+1: Specify $\lambda$ , maximum training iterations $N$ , alternating update rotation frequency $M$ , and reward threshold   
+$R _ { \mathrm { m i n } }$   
+2: Initialize total replay memory $D \gets \emptyset$ and its subset for positive episodes $D _ { + }  \emptyset$   
+3: Initialize current iteration id $i \gets 0$ and set current updating term to be $\tau \gets 1$   
+4: Initialize parameters of policies and value functions $\mathrm { { \dot { \Theta } } } = \langle \theta ^ { \mathrm { s w } } , \theta ^ { \mathrm { i n s t } } , \theta ^ { \mathrm { a u g } } , \theta _ { v } , \theta _ { v } ^ { \mathrm { s w } } \rangle$   
+5: Initialize distributions of the STG as uniform distributions   
+6: repeat   
+7: Determine current learning phase by comparing average rewards of tasks in $\mathcal { G } _ { k - 1 }$ with $R _ { \mathrm { m i n } }$   
+8: if in curriculum learning phase 1 then   
+9: Sample a task $g$ from base task set $\mathcal { G } _ { k - 1 }$   
+10: else   
+11: Sample a task $g$ from global task set $\mathcal { G } _ { k }$   
+12: end if   
+13: //Run an episode   
+15: 14: $\Gamma  \operatorname { R U N } ( k , g )$   
+16: if the maximum reward in $\Gamma$ is $+ 1$ then   
+17: $D _ { + } \gets D _ { + } \cup \Gamma$   
+18: Re-estimate the distributions of the STG based on updated $D _ { + }$ by MLE   
+19: end if   
+20: Sample $n \sim \mathrm { P o s s i o n } ( \lambda )$   
+21: for $\bar { j } \in \{ 1 , \cdots , n \}$ do   
+22: Sample a mini-batch $S$ from $D$   
+23: Update $\Theta$ based on (9) and the $\tau$ -th term in (8)   
+24: $i \stackrel { - } {  } i + 1$   
+25: if $i \% M = 0$ then   
+26: $\tau  \tau \% 3 + 1$   
+27: end if   
+28: end for   
+29: until $i \geq N$
+
+# B ARCHITECTURES OF MODULES
+
+The architecture designs of all modules in our model shown in Figure 2 are as follows:
+
+Visual Encoder extracts feature maps from an input RGB frame with the size of $8 4 \times 8 4$ through three convolutional layers: i) the first layer has 32 filters with kernel size of $8 \times 8$ and stride of 4; ii) the second layer has 64 filters with kernel size of $4 \times 4$ and stride of 2; iii) the last layer includes 64 filters with kernel size of $3 \times 3$ and stride of 1. The feature maps are flatten into a 3136-dim vector. We reduce the dimension of this vector to 256 by a fully connected (FC) layer resulting a 256-dim visual feature as the final output of this module.
+
+Instruction Encoder first embeds each word into a 128-dim vector and combines them into a single vector by bag-of-words (BOW). Thus the output of this module is a 128-dim vector. For more complex instructions such as “Put $\mathbf { X }$ on y”, we replace BOW by a GRU with 128 hidden units.
+
+Fusion layer simply concatenates the encoded visual and language representations together and outputs 384-dim fused representation. We then feed this 384-dim vector into an LSTM with 256 hidden units. The hidden layer output of the LSTM is served as the input of all policy modules and value function modules.
+
+Switch Policy module has a FC layer with output dimension of 2 and a softmax activation to get $\pi _ { k } ^ { \mathrm { s w } } ( e | s , g )$ . Instruction Policy module has two separate FC layers, both of which are activated by softmax to output the distribution of skill, $p _ { k } ^ { \mathrm { s k i l l } } ( u _ { \mathrm { s k i l l } } | s , g )$ , and the distribution of item, $p _ { k } ^ { \mathrm { i t e m } } ( u _ { \mathrm { i t e m } } | s , g )$ , respectively. Augmented Policy module outputs $\pi _ { \mathrm { a u g } } ( a | s , g )$ also through a FC layer and softmax activation. The two Value Function modules, $V ( s , \bar { g } )$ and $\dot { V } ^ { \mathrm { s w } } ( s , e , g )$ , all have a scalar output through a FC layer.
+
+Finally, the Selector module selects the action sampled from Augmented Policy module or Base Policy module based on the switching decision sampled from the Switch Policy module.
+
+# C COMPOSED HIERARCHICAL PLANS
+
+Figure 6 and Figure 7 show several plans for different tasks composed by executing our hierarchical policies.
+
+![](images/befdfbb5ae792734629bcca3d43768eaf0b510d8afdd69983060b44d6a65c07d.jpg)  
+Figure 6: Samples of typical hierarchical plans for different tasks composed by our global policies. Note that all tasks must start from the top-level policy. The branches are ordered from left to right in time indicating consecutive steps carried out by a policy. We also show the egocentric view and the item in hands at critical moments for a real episode example.
+
+![](images/b6448093b4a41c6d19f74c7174a7e08647dad5d2a95334aaf5cfe1fb5320b506.jpg)  
+Figure 7: Hierarchical plans for “Put x on y” tasks. Top: an example of performing trained tasks; bottom: an example of generalizing the plan composition to unseen tasks.

parse/train/SJJQVZW0b/SJJQVZW0b_content_list.json

@@ -0,0 +1,1651 @@
+[
+    {
+        "type": "text",
+        "text": "HIERARCHICAL AND INTERPRETABLE SKILL ACQUISITION IN MULTI-TASK REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianmin Shu∗ University of California, Los Angeles tianmin.shu@ucla.edu ",
+        "bbox": [
+            184,
+            170,
+            431,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong†& Richard Socher Salesforce Research {cxiong, rsocher}@salesforce.com ",
+        "bbox": [
+            475,
+            170,
+            787,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning policies for complex tasks that require multiple different skills is a major challenge in reinforcement learning (RL). It is also a requirement for its deployment in real-world scenarios. This paper proposes a novel framework for efficient multi-task reinforcement learning. Our framework trains agents to employ hierarchical policies that decide when to use a previously learned policy and when to learn a new skill. This enables agents to continually acquire new skills during different stages of training. Each learned task corresponds to a human language description. Because agents can only access previously learned skills through these descriptions, the agent can always provide a human-interpretable description of its choices. In order to help the agent learn the complex temporal dependencies necessary for the hierarchical policy, we provide it with a stochastic temporal grammar that modulates when to rely on previously learned skills and when to execute new skills. We validate our approach on Minecraft games designed to explicitly test the ability to reuse previously learned skills while simultaneously learning new skills. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            336,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning has demonstrated success in policy search for tasks in domains like game playing (Mnih et al., 2015; Silver et al., 2016; 2017; Kempka et al., 2016; Mirowski et al., 2017) and robotic control (Levine et al., 2016a;b; Pinto & Gupta, 2016). However, it is very difficult to accumulate multiple skills using just one policy network Teh et al. (2017). Knowledge transfer techniques like distillation (Bengio, 2012; Rusu et al., 2016; Parisotto et al., 2016; Teh et al., 2017) have been applied to train a policy network both to learn new skills while preserving previously learned skill as well as to combine single-task policies into a multi-task policy. Existing approaches usually treat all tasks independently. This often prevents full exploration of the underlying relations between different tasks. They also typically assume that all policies share the same state space and action space. This precludes transfer of previously learned simple skills to a new policy defined over a space with differing states or actions. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            699
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When humans learn new skills, we often take advantage of our existing skills and build new capacities by composing or combining simpler ones. For instance, learning multi-digit multiplication relies on the knowledge of single-digit multiplication; learning how to properly prepare individual ingredients facilitates cooking dishes based on complex recipes. ",
+        "bbox": [
+            174,
+            705,
+            823,
+            762
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Inspired by this observation, we propose a hierarchical policy network which can reuse previously learned skills alongside and as subcomponents of new skills. It achieves this by discovering the underlying relations between skills. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            810
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To represent the skills and their relations in an interpretable way, we also encode all tasks using human instructions such as “put down.” This allows the agent to communicate its policy and generate plans using human language. Figure 1 illustrates an example: given the instruction “Stack blue,” our hierarchical policy learns to compose instructions and take multiple actions through a multi-level hierarchy in order to stack two blue blocks together. Steps from the top-level policy $\\pi _ { 3 }$ (i.e., the red branches) outline a learned high-level plan – “Get blue Find blue Put blue.” In addition, from lower level policies, we may also clearly see composed plans for other tasks. Based on policy $\\pi _ { 2 }$ , for instance, the task “Get blue” has two steps – “Find blue action: turn left,” whereas “Put blue” can be executed by a single action “put down” according to $\\pi _ { 3 }$ . Through this hierarchical model, we may i) accumulate tasks progressively from a terminal policy to a top-level policy and ii) unfold the global policy from top-level to basic actions. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4413927ac73dea13f3fbeb9963537490bbf5769bcca990701fd8974a57a20a6b.jpg",
+        "image_caption": [
+            "Figure 1: Example of our multi-level hierarchical policy for a given task – stacking two blue blocks. Each arrow represents one step generated by a certain policy and the colors of arrows indicate the source policies. Note that at each step, a policy either utters an instruction for the lower-level policy or directly takes an action. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            102,
+            776,
+            308
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            402,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to better track temporal relationships between tasks, we train a stochastic temporal grammar (STG) model on the sequence of policy selections (previously learned skill or new skill) for positive episodes. The STG focuses on modeling priorities of tasks: for example, it is necessary to obtain an object before putting it down. Integrating the STG into the hierarchical policy boosts efficiency and accuracy by explicitly modeling such commonsense world knowledge. ",
+        "bbox": [
+            174,
+            493,
+            823,
+            563
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We validated our approach by testing it on object manipulation tasks implemented in a Minecraft world. Our experimental results demonstrate that this framework can (i) efficiently learn hierarchical policies and representations for multi-task RL; (ii) learn to utter human instructions to deploy pretrained policies, improve their explainability and reuse skills; and (iii) learn a stochastic temporal grammar via self-supervision to predict future actions. ",
+        "bbox": [
+            174,
+            570,
+            823,
+            640
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            343,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-task Reinforcement Learning. Previous work on multi-task reinforcement learning mainly falls into two families: knowledge transfer through distillation (Rusu et al., 2016; Parisotto et al., 2016; Teh et al., 2017; Tessler et al., 2017) or modular policy design through 2-layer hierarchical policy (Andreas et al., 2017). Our multi-level policy is more similar to the latter approach. The main differences between our model and the one in Andreas et al. (2017) are two-fold: i) we do not assume that a global task can be executed by only performing predefined sub-tasks; ii) in our multi-level policy, global tasks at a lower-level layer may also be used as sub-tasks by global tasks carried out at higher-levels. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hierarchical Reinforcement Learning. Complex policies often require the modeling of longer temporal dependencies than what standard Markov decision processes (MDPs) can capture. To combat this, hierarchical reinforcement learning was introduced to extend MDPs to semi-MDPs (Sutton et al., 1999), where options (or macro actions) are introduced on top of primitive actions to decompose the goal of a task into multiple subgoals. In hierarchical RL, two sets of policies are trained: local policies that map states to primitive actions for achieving subgoals, and a global policy that initiates suitable subgoals in a sequence to achieve the final goal of a task (Bacon & Precup, 2015; Kulkarni et al., 2016; Vezhnevets et al., 2016; Tessler et al., 2017; Andreas et al., ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2017). This two-layer hierarchical policy design significantly improves the ability of discovering complex policies which can not be learned by flat policies. However, it also often makes some strict assumptions that limit its flexibility: i) a task’s global policy cannot use a simpler task’s policy as part of its base policies; ii) a global policy is assumed to be executable by only using local policies over specific options, e.g., (Kulkarni et al., 2016; Andreas et al., 2017). In this work, we aim to learn a multi-level global policy which does not have these two assumptions. In addition, previous work usually uses a latent variable to represent a task. In our work, we encode a task by a human instruction to learn a task-oriented language grounding as well as to improve the interpretability of plans composed by our hierarchical policies. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Language grounding via reinforcement learning. Recently, there has been work on grounding human language in 3D game environments (Hermann et al., 2017; Chaplot et al., 2017) or in text-based games (Narasimhan et al., 2015) via reinforcement learning. In these games agents are instructed to pick up an item described by a sentence. Besides visual grounding, Andreas et al. (2017) grounded instructions (not necessarily using human language) to local policies in hierarchical reinforcement learning. Our approach not only learns the language grounding for both visual knowledge and policies, but is also trained to utter human instructions as an explicit explanation of its decisions to humans. To our knowledge, this is the first model that learns to compose plans for complex tasks based on simpler ones which have human descriptions. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            267,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss our multi-task RL setting, hierarchical policy, stochastic temporal grammar, and how interaction of these components can achieve plan composition. ",
+        "bbox": [
+            174,
+            412,
+            823,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MULTITASK RL SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            390,
+            472
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { G }$ be a task set, where each task $g$ is uniquely described by a human instruction. For simplicity, we assume a two-word tuple template consisting of a skill and an item for such a phrase, i.e., $\\langle u _ { \\mathrm { s k i l l } } , u _ { \\mathrm { i t e m } } \\rangle$ . Each tuple describes an object manipulation task. In this paper, we define $g = \\langle u _ { \\mathrm { s k i l l } } , u _ { \\mathrm { i t e m } } \\rangle$ by default, thus tasks and instructions are treated as interchangeable concepts. ",
+        "bbox": [
+            174,
+            483,
+            823,
+            540
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For each task, we define a Markov decision process (MDP) represented by states $s \\in S$ and primitive actions $a \\in { \\mathcal { A } }$ . Rewards are specified for goals of different tasks, thus we use a function $R ( s , g )$ to signal the reward when performing any given task $g$ . ",
+        "bbox": [
+            174,
+            546,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We assume that as a starting point, we have a terminal policy $\\pi _ { 0 }$ (as shown in Figure 2a) trained for a set of basic tasks (i.e., a terminal task set $\\mathcal { G } _ { 0 }$ ). The task set is then progressively increased as the agent is instructed to do more tasks by humans at multiple stages, such that ${ \\mathcal { G } } _ { 0 } \\subset { \\mathcal { G } } _ { 1 } \\subset \\cdots \\subset { \\mathcal { G } } _ { K }$ , which results in life-long learning of polices from $\\pi _ { 0 }$ for $\\mathcal { G } _ { 0 }$ to $\\pi _ { K }$ for $\\mathcal { G } _ { K }$ as illustrated by the “task accumulation” direction in Figure 1. At stage $k > 0$ , $\\mathcal { G } _ { k - 1 }$ is defined as the base task set of $\\mathcal { G } _ { k }$ . The tasks in $\\mathcal { G } _ { k - 1 }$ are named as base tasks at this stage and $\\pi _ { k - 1 }$ becomes the base policy of $\\pi _ { k }$ . Here, we utilize weak supervision from humans to define what tasks shall be augmented to the previous task set at each new stage. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 HIERARCHICAL POLICY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            382,
+            738
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One of our key ideas is that a new task in current task set $\\mathcal { G } _ { k }$ may be decomposed into several simpler subtasks, some of which can be base tasks in $\\mathcal { G } _ { k - 1 }$ executable by base policy $\\pi _ { k - 1 }$ . Therefore, instead of using a flat policy (Figure 2a) as $\\pi _ { 0 }$ that directly maps state and human instruction to a primitive action, we propose a hierarchical design (Figure 2b) with the ability to reuse the base policy (i.e., $\\pi _ { k - 1 }$ ) for performing base tasks as subtasks. Namely, at stage $k$ , the global policy $\\pi _ { k }$ is defined by a hierarchical policy. This hierarchy consists of four sub-policies: a base policy for executing previously learned tasks, an instruction policy that manages communication between the global policy and the base policy, an augmented flat policy which allows the global policy to directly execute actions, and a switch policy that decides whether the global policy will primarily rely on the base policy or the augmented flat policy. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The base policy is defined to be the global policy at the previous stage $k - 1$ . The instruction policy maps state $s$ and task $g \\in { \\mathcal { G } } _ { k }$ to a base task $g ^ { \\prime } \\in \\mathcal { G } _ { k - 1 }$ . The purpose of this policy is to inform base policy $\\pi _ { k - 1 }$ which base tasks it needs to execute. Since an instruction is represented by two words, −we define the instruction policy using two conditionally independent distributions, i.e., $\\pi _ { k } ^ { \\mathrm { i n s t } } ( g ^ { \\prime } =$ $\\langle u _ { \\mathrm { s k i l l } } , u _ { \\mathrm { i t e m } } \\rangle | s , g ) = p _ { k } ^ { \\mathrm { s k i l l } } ( u _ { \\mathrm { s k i l l } } | s , g ) p _ { k } ^ { \\mathrm { i t e m } } ( u _ { \\mathrm { i t e m } } | s , g )$ . An augmented flat policy, $\\pi _ { k } ^ { \\mathrm { a u g } } ( a | s , \\tilde { g } )$ , maps state $s$ and task $g$ to a primitive action $a$ for ensuring that the global policy is able to perform novel tasks in $\\mathcal { G } _ { k }$ that can not be achieved by only reusing the base policy. To determine whether to perform a base task or directly perform a primitive action at each step, the global policy further includes a switch policy, $\\pi _ { k } ^ { \\mathrm { s w } } ( e | \\bar { s } , \\bar { g } )$ , where $e$ is a binary variable indicating the selection of the branches, $\\pi _ { k } ^ { \\mathrm { i n s t } }$ $e = 0$ ) or $\\pi _ { k } ^ { \\mathrm { a u g } }$ $( e = 1 )$ ). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a893964c5f174ad83afb2c3b4400b746dba3bee5f8ec8a7d2533674a304ac37.jpg",
+        "image_caption": [
+            "Figure 2: Flat and hierarchical policy architectures. $V ( s , g )$ and $V ^ { \\mathrm { S W } } ( s , e , g )$ are value functions defined in Section 4.1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            264,
+            98,
+            797,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            415,
+            825,
+            531
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the above description of the hierarchical policy does not account for an STG. The instruction policy and switch policy introduced here are simplified from the ones in the full model (see Section 3.3). ",
+        "bbox": [
+            174,
+            536,
+            825,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "At each time step, we first sample $e _ { t }$ from our switch policy $\\pi _ { k } ^ { \\mathrm { s w } }$ to decide whether the global policy $\\pi _ { k }$ will rely on the base policy $\\pi _ { k - 1 }$ or the augmented flat policy $\\pi _ { k } ^ { \\mathrm { a u g } }$ . We also sample a new instruction $g _ { t } ^ { \\prime }$ from our instruction policy $\\pi _ { k } ^ { \\mathrm { i n s t } }$ in order to sample actions from the base policy. This can be summarized as: ",
+        "bbox": [
+            174,
+            585,
+            823,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0e5e66ffddd59eedeb9ac2a755af2199358a65b085a59389220a5b3f626df5ab.jpg",
+        "text": "$$\n\\begin{array} { r } { e _ { t } \\sim \\pi _ { k } ^ { \\mathrm { s w } } ( e _ { t } | s _ { t } , g ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            642,
+            560,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7594395664ee7092527a8b4342ece637c4d6e3dae15b625843fc30d20165fa40.jpg",
+        "text": "$$\ng _ { t } ^ { \\prime } \\sim \\pi _ { k } ^ { \\mathrm { i n s t } } ( g _ { t } ^ { \\prime } | s _ { t } , g ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            674,
+            563,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and finally ",
+        "bbox": [
+            174,
+            694,
+            245,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c5763204452be61ebdb77d7a4f67a10ebb6969e725678608fb4d674007428060.jpg",
+        "text": "$$\na _ { t } \\sim \\pi _ { k } ( a _ { t } | s _ { t } , g ) = \\pi _ { k - 1 } ( a _ { t } | s _ { t } , g _ { t } ^ { \\prime } ) ^ { ( 1 - e _ { t } ) } \\pi _ { k } ^ { \\mathrm { a u g } } ( a _ { t } | s _ { t } , g ) ^ { e _ { t } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            707,
+            689,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pi _ { k }$ and $\\pi _ { k - 1 }$ are the global policies at stage $k$ and $k - 1$ respectively. After each step, we will also obtain a reward $r _ { t } = R ( s _ { t } , g )$ . ",
+        "bbox": [
+            176,
+            728,
+            820,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 STOCHASTIC TEMPORAL GRAMMAR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            467,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Different tasks may have temporal relations. For instance, to move an object, one needs to first find and pick up that object. There has been previous research (Si et al., 2011; Pirsiavash & Ramanan, 2014) using stochastic grammar models to capture such temporal relations. Inspired by this, we summarize temporal transitions between various tasks with a stochastic temporal grammar (STG). In our full model, the STG interacts with the hierarchical policy described above through the modified switch policy and instruction policy by using the STG as a prior. This amounts to treating the past history of switches and instructions in positive episodes as a guidance on whether the hierarchical policy should defer to the base policy to execute a specific base task or employ its own augmented flat policy to take a primitive action. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In an episode, the temporal sequence of $e _ { t }$ and $g _ { t } ^ { \\prime }$ , i.e., $\\{ \\langle e _ { t } , g _ { t } ^ { \\prime } \\rangle ; t \\geq 0 \\}$ , can be seen as a finite state Markov chain (Baum & Petrie, 1966). Note that the state here is referred to the tuple $\\langle e _ { t } , g _ { t } ^ { \\prime } \\rangle$ , which is not the state of the game $s _ { t } \\in S$ defined in Section 3.1. Consequently, at each level $k > 0$ , we may define an STG of a task $g$ by i) transition probabilities, $\\rho _ { k } ( e _ { t } , \\bar { g } _ { t } ^ { \\prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \\prime } , g )$ , and ii) the distribution of $\\left. { e _ { 0 } , g _ { 0 } ^ { \\prime } } \\right.$ , $q _ { k } ( e _ { 0 } , g _ { 0 } ^ { \\prime } | g )$ , all of which follow categorical distributions. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            175
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the estimated probabilities, we sample $e _ { t }$ and $g _ { t } ^ { \\prime }$ in an episode at level $k > 0$ w.r.t. to reshaped policies $\\pi _ { k } ^ { s w ^ { \\prime } }$ and $\\pi _ { k } ^ { \\mathrm { i n s t } ^ { \\prime } }$ respectively: ",
+        "bbox": [
+            173,
+            180,
+            823,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• If $t = 0$ , ",
+        "bbox": [
+            215,
+            223,
+            290,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d49892b65e094a5a19ae3a738e837580d7f612d2058a2f42a99ea5aa76ff64c.jpg",
+        "text": "$$\ne _ { 0 } \\sim \\pi _ { k } ^ { \\mathrm { s w \\it / } } ( e _ { 0 } | s _ { t } , g ) \\propto \\pi _ { k } ^ { \\mathrm { s w } } \\big ( e _ { 0 } | s _ { t } , g \\big ) \\sum _ { g ^ { \\prime } \\in \\mathcal { G } _ { k - 1 } } q _ { k } \\big ( e _ { 0 } , g ^ { \\prime } | g \\big ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            237,
+            712,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e60d53b37c28d96b7f65a692ede18c95ca9a6fc406930fff2b36e18d402eac46.jpg",
+        "text": "$$\ng _ { 0 } ^ { \\prime } \\sim \\pi _ { k } ^ { \\mathrm { i n s t } ^ { \\prime } } ( g _ { 0 } ^ { \\prime } | s _ { t } , g ) \\propto \\pi _ { k } ^ { \\mathrm { i n s t } } ( g _ { 0 } ^ { \\prime } | s _ { t } , g ) q _ { k } ( e _ { 0 } = 0 , g _ { 0 } ^ { \\prime } | g ) ;\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            279,
+            707,
+            301
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Otherwise, ",
+        "bbox": [
+            217,
+            308,
+            305,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/896543d46a2b9aa610bc26f927df966e0f3db01bc815b75e5ec5e7fa3a771324.jpg",
+        "text": "$$\ne _ { t } \\sim \\pi _ { k } ^ { \\mathrm { s w \\prime } } ( e _ { t } | e _ { t - 1 } , g _ { t - 1 } ^ { \\prime } , s _ { t } , g ) \\propto \\pi _ { k } ^ { \\mathrm { s w } } \\big ( e _ { t } | s _ { t } , g \\big ) \\sum _ { g ^ { \\prime } \\in \\mathcal { G } _ { k - 1 } } \\rho _ { k } ( e _ { t } , g ^ { \\prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \\prime } , g ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            329,
+            784,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fda08b0473cca6c6a907d017715d6b883a5bb2d373a3fee94c746f645201b6ab.jpg",
+        "text": "$$\ng _ { t } ^ { \\prime } \\sim \\pi _ { k } ^ { \\mathrm { i n s t ^ { \\prime } } } ( g _ { t } ^ { \\prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \\prime } , s _ { t } , g ) \\propto \\pi _ { k } ^ { \\mathrm { i n s t } } ( g _ { t } ^ { \\prime } | s _ { t } , g ) \\rho _ { k } ( e _ { t } = 0 , g _ { t } ^ { \\prime } | e _ { t - 1 } , g _ { t - 1 } ^ { \\prime } , g ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            375,
+            777,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that primitive action sampling is not affected by the STG. ",
+        "bbox": [
+            174,
+            409,
+            586,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 PLAN COMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            441,
+            357,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Combined with our hierarchical policy and STG defined above, we are able to run an episode to compose a plan for a task specified by a human instruction. Algorithm 1 in Appendix A summarized this procedure with respect to the policy and STG at level $k$ . Note that to fully utilize the base policy, we assume that once triggered, a base policy will play to the end before the global policy considers the next move. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            295,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learning algorithm is outlined in Algorithm 2 in Appendix A. We learn our final hierarchical policy through $k$ stages of skill acquisition. Each of these stages is broken down into a base skill acquisition phase and a novel skill acquisition phase in a 2-phase curriculum learning. ",
+        "bbox": [
+            176,
+            592,
+            823,
+            633
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the base skill acquisition phase, we only sample tasks from the base task set $\\mathcal { G } _ { k - 1 }$ . This ensures that the global policy learns how to use previously learned skills by issuing instructions to the base policy. In other words, this phase teaches the agent how to connect its instruction policy to its base policy. Once the average reward for all base tasks exceeds a certain threshold, we proceed to the next phase. ",
+        "bbox": [
+            173,
+            641,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the novel skill acquisition phase, we sample tasks from the full task set, $\\mathcal { G } _ { k }$ , for the $k \\mathrm { . }$ -th stage of skill acquisition. It is in this phase that the agent can learn when to rely on the base policy and when to rely on the augmented flat policy for executing novel tasks. ",
+        "bbox": [
+            174,
+            717,
+            823,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In each of these phases, all policies are trained with advantage actor-critic (A2C) (Section 4.1) and distributions in the STG are estimated based on accumulated positive episodes (Section 4.2). ",
+        "bbox": [
+            171,
+            766,
+            823,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 POLICY OPTIMIZATION BY ADVANTAGE ACTOR-CRITIC ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            813,
+            602,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use advantage actor-critic (A2C) for policy optimization with off-policy learning (Su et al., 2017). Here, we only consider the gradient for global policies (i.e., $k > 0 ,$ ) as we assume the terminal policy has been trained as initial condition. Let $V _ { k } ( s _ { t } , g )$ be a value function indicating the expected return given state $s _ { t }$ and task $g$ . To reflect the nature of the branch switching in our model, we introduce another value function $V _ { k } ^ { \\operatorname { s w } } ( s _ { t } , e _ { t } , g )$ to represent the expected return given state $s _ { t }$ , task $g$ and current branch selection $e _ { t }$ . ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, given a trajectory $\\Gamma ~ = ~ \\{ \\langle s _ { t } , e _ { t } , g _ { t } ^ { \\prime } , a _ { t } , r _ { t } , \\mu _ { k } ^ { \\mathrm { s w } } ( \\cdot | s _ { t } ) , \\mu _ { k } ^ { \\mathrm { i n s t } } ( \\cdot | s _ { t } , g ) , \\mu _ { k } ^ { \\mathrm { a u g } } ( \\cdot | s _ { t } , g ) , g \\rangle ~ : ~ t ~ =$ $0 , 1 , \\cdots , T \\}$ generated by old policies $\\mu _ { k } ^ { \\mathrm { s w } } ( \\cdot | s _ { t } ) , \\mu _ { k } ^ { \\mathrm { i n s t } } ( \\cdot | s _ { t } , g )$ , and $\\mu _ { k } ^ { \\mathrm { a u g } } ( \\cdot | s _ { t } , g )$ , the policy gradient reweighted by importance sampling can be formulated as ",
+        "bbox": [
+            174,
+            102,
+            823,
+            147
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9c89bfe5436972d58b038ee5f7bcb7745c22e3f98f19cf05349d5ae52bd7b7a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underbrace { \\omega _ { t } ^ { \\mathrm { s w } } \\nabla _ { \\theta ^ { \\mathrm { s w } } } \\log \\pi _ { k } ^ { \\mathrm { s w } } ( e _ { t } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } ) } _ { \\mathrm { 1 s t ~ t e r m : ~ s w i t c h ~ p o l i c y ~ g r a d i e n t } } } \\\\ { + } & { \\underbrace { ( 1 - e _ { t } ) \\omega _ { t } ^ { \\mathrm { i n s t } } \\nabla _ { \\theta ^ { \\mathrm { i n s t } } } \\log \\pi _ { k } ^ { \\mathrm { i n s t } } ( g _ { t } ^ { \\prime } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } , g _ { t } ^ { \\prime } ) } _ { \\mathrm { 2 n d ~ t e r m : ~ i n s t r u c t i o n ~ p o l i c y ~ g r a d i e n t } } } \\\\ { + } & { \\underbrace { e _ { t } \\omega _ { t } ^ { \\mathrm { a u g } } \\nabla _ { \\theta ^ { \\mathrm { a u g } } } \\log \\pi _ { k } ^ { \\mathrm { a u g } } ( a _ { t } | s _ { t } , g ) A ( s _ { t } , g , e _ { t } , a _ { t } ) } _ { \\mathrm { . } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            154,
+            679,
+            248
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\omega _ { t } ^ { \\mathrm { s w } } = \\frac { \\pi _ { k } ^ { \\mathrm { s w } } ( e _ { t } | s _ { t } , g ) } { \\mu _ { k } ^ { \\mathrm { s w } } ( e _ { t } | s _ { t } , g ) } } \\end{array}$ , $\\begin{array} { r } { \\omega _ { t } ^ { \\mathrm { i n s t } } ~ = ~ \\frac { \\pi _ { k } ^ { \\mathrm { i n s t } } ( g _ { t } ^ { \\prime } | s _ { t } , g ) } { \\mu _ { k } ^ { \\mathrm { i n s t } } ( g _ { t } ^ { \\prime } | s _ { t } , g ) } } \\end{array}$ , and $\\begin{array} { r } { \\omega _ { t } ^ { \\mathrm { a u g } } = \\frac { \\pi _ { k } ^ { \\mathrm { a u g } } ( a _ { t } | s _ { t } , g ) } { \\mu _ { k } ^ { \\mathrm { a u g } } ( a _ { t } | s _ { t } , g ) } } \\end{array}$ are importance sampling weights for the three terms respectively; $A ( s _ { t } , g , e _ { t } )$ , $A ( s _ { t } , g , e _ { t } , g _ { t } ^ { \\prime } )$ , and $A ( s _ { t } , g , e _ { t } , a _ { t } )$ are estimates of advantage functions, which have multiple possible definitions. In this paper, we define e, $A ( s _ { t } , g , e _ { t } ) =$ ${ \\sum } _ { \\tau = 0 } ^ { \\infty } \\overset { \\cdot } { \\gamma } { \\tilde { F } } ( s _ { t + \\tau } , g ) \\ - \\ V _ { k } ( s _ { t } , g )$ $\\begin{array} { r c l } { { \\hat { A ( \\boldsymbol { s } _ { t } , \\boldsymbol { g } , \\boldsymbol { e } _ { t } , \\boldsymbol { g } _ { t } ^ { \\prime } ) } ~ = ~ { \\cal A ( \\boldsymbol { s } _ { t } , \\boldsymbol { g } , \\boldsymbol { e } _ { t } , \\boldsymbol { a } _ { t } ) } ~ = ~ \\sum _ { \\tau = 0 } ^ { \\infty } \\gamma ^ { \\tau } \\hat { R } ( \\boldsymbol { s } _ { t + \\tau } , \\boldsymbol { g } ) ~ - } } \\end{array}$ $V _ { k } ^ { \\mathrm { s w } } ( s _ { t } , g , e _ { t } )$ , where $\\gamma$ tis the discounted coefficient. ",
+        "bbox": [
+            174,
+            265,
+            826,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, the value functions can be updated using the following gradient: ",
+        "bbox": [
+            174,
+            366,
+            647,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af389ea56bc8853d3f1325594040632d368f19f905720d6db9b79974dff1190c.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { v } } \\frac { 1 } { 2 } \\left[ \\sum _ { \\tau = 0 } ^ { \\infty } \\gamma ^ { \\tau } R ( s _ { t + \\tau } , g ) - V _ { k } ( s _ { t } , g ) \\right] ^ { 2 } + \\nabla _ { \\theta _ { v } ^ { \\mathrm { s w } } } \\frac { 1 } { 2 } \\left[ \\sum _ { \\tau = 0 } ^ { \\infty } \\gamma ^ { \\tau } R ( s _ { t + \\tau } , g ) - V _ { k } ^ { \\mathrm { s w } } ( s _ { t } , e _ { t } , g ) \\right] ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            192,
+            387,
+            784,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To increase the episode efficiency, after running an episode, we conduct $n$ mini-batch updates where $n$ is sampled from a Poisson distribution with $\\lambda = 4$ , similar to Wang et al. (2017). Note that one can also apply other common policy optimization methods, e.g., A3C (Mnih et al., 2016), to our model. We leave this as future work to evaluate the efficiency of different methods when using our model. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            516
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Optimizing all three sub-policies together leads to unstable learning. To avoid this, we apply a simple alternating update procedure. For each set of $M$ iterations, we keep two of the sub-policies fixed and train only the single policy that remains. When we reach $M$ iterations, we switch the policy that is trained. For all experiments in this paper, we use $M = 5 0 0$ . This alternating update procedure is used within both phases of curriculum learning. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 LEARNING AN STG ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            351,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If at any point in the aforementioned training process the agent receives a positive reward after an episode, we update the stochastic temporal grammar. $\\rho _ { k }$ and $q _ { k }$ of the STG are both initialized to be uniform distributions. Since the STG is a finite state Markov chain over tuples $\\left. { e _ { t } , g _ { t } ^ { \\prime } } \\right.$ , we use maximum likelihood estimation (MLE) to update the distributions (Baum & Petrie, 1966). As the training progresses, the STG starts to guide the exploration. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            707
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To avoid falling into local minima in the early stages of training, it is important to encourage random exploration in early episodes. Based on our experiments, we find that using $\\epsilon$ -greedy suffices. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            326,
+            777
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 GAME ENVIRONMENT AND TASK SPECIFICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            563,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 (left) shows the two room environment in Minecraft that we created using the Malmo platform (Johnson et al., 2016). In each episode, an arbitrary number of blocks with different colors (totaling 6 colors in our experiments) are randomly placed in one of the two rooms. The agent is initially placed in the same room with the items. We consider five sets of tasks: i) ${ \\mathcal { G } } ^ { ( 0 ) } = \\{ { } ^ {  { } } \\mathrm { F i n d } \\mathrm { x } ^ {  } \\}$ , walking to the front of a block with color $\\mathbf { X }$ , ii) $\\mathcal { G } ^ { ( 1 ) } = \\{ { \\bf \\ddot { \\Phi } } { \\bf G e t x } ^ { , * } \\}$ , picking up a block with color $\\mathbf { X }$ , iii) $\\mathcal { G } ^ { ( 2 ) } = \\{ { ^ {  } \\mathrm { P u t } } \\mathrm { x } ^ { , , * } \\}$ , putting down a block with color $\\mathbf { X }$ , iv) $\\mathcal { G } ^ { ( 3 ) } = \\{ ^ { \\cdots } \\mathrm { S t a c k } \\mathrm { x } ^ { \\cdots } \\}$ , stacking two blocks with color $\\mathbf { X }$ together, and v) $\\mathcal { G } ^ { ( 4 ) } = \\{ { ^ { \\mathrm { ? P u t ~ x ~ o n ~ y } } } \\}$ , putting a block with color $\\mathbf { X }$ on top of a block with a different color y. In total, there are 54 tasks. An agent can perform the following actions: “move forward,” “move backward,” “move left,” “move right,” “turn left,” “turn right,” “pick up,” “put down.” ",
+        "bbox": [
+            173,
+            819,
+            825,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf57cf2f333bf44708a29c1875358f75f741052352aafc00f4400f2bb462ec1a.jpg",
+        "image_caption": [
+            "Figure 3: Room layout. Left: training environment; right: unseen rooms for testing. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            400,
+            101,
+            596,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            205,
+            825,
+            247
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Without loss of generality, we assume the following skill acquisition order: $\\mathcal { G } _ { k } = \\cup _ { \\kappa = 1 } ^ { k } \\mathcal { G } ^ { ( \\kappa ) }$ , $\\forall k =$ $0 , 1 , 2 , 3 , 4$ , which is a natural way to increase skill sets. One may also alter the order, and the main conclusions shall still hold. This results in policies $\\{ \\pi _ { k } : k = \\dot { 0 , } 1 , 2 , 3 , 4 \\}$ for these four task sets. For the last task set, we hold out 6 tasks out of all 30 tasks (i.e., 3 pairs of colors out of 15 color combinations) for testing and the agent will not be trained on these 6 tasks. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We adopt a sparse reward function: when reaching the goal of a task, the agent gets a $+ 1$ reward; when generating an instruction $g ^ { \\prime }$ that is not executable in current game (e.g., trying to find an object that does not exist in the environment), we give a $- 0 . 5$ reward; otherwise, no reward will be given. Whenever a non-zero reward is given, the game terminates. Note that the negative reward is only given during training. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            406,
+            438
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We specify the architecture of the modules in our model in Appendix B, where the visual and instruction encoding modules have the same architectures as the ones in Hermann et al. (2017). We train the network with RMSProp (Tieleman & Hinton, 2012) with a learning rate of 0.0001. We set the batch size to be 36 and clip the gradient to a unit norm. For all tasks, the discounted coefficient is $\\gamma = 0 . 9 5$ . For the 2-phase curriculum learning, we set the average reward threshold to be 0.9 (average rewards are estimated from the most recent 200 episodes of each task). ",
+        "bbox": [
+            173,
+            452,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To encourage random exploration, we apply $\\epsilon$ -greedy to the decision sampling for the global policy (i.e., only at the top level $k$ at each stage $k > 0$ ), where $\\epsilon$ gradually decreases from 0.1 to 0. ",
+        "bbox": [
+            173,
+            542,
+            821,
+            571
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/175631828543a6110950c7ec8016ac45f5e9a471c97beadfd6ead1193e4ee11a.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of learning efficiency on two task sets: (a) $\\mathcal { G } _ { 1 }$ for global policy $\\pi _ { 1 }$ and (b) $\\mathcal { G } _ { 3 }$ for global policy $\\pi _ { 3 }$ respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            279,
+            599,
+            725,
+            752
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 LEARNING EFFICIENCY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            377,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the learning efficiency, we compare our full model with 1) a flat policy (Figure 2a) as in Hermann et al. (2017) fine-tuned on the terminal policy $\\pi _ { 0 }$ , 2) H-DRLN (Tessler et al., 2017) and variants of our approach: 3) ours without STG, 4) ours without alternating policy optimization, and 5) ours without $V _ { k } ^ { \\mathrm { s w } } ( s , e , g )$ (replaced by $V _ { k } ( s , g )$ instead). Note that all the rewards have been converted to the same range, i.e., $[ 0 , 1 ]$ for the sake of fair comparison. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/395abc0c2629ae8cf2f89ef88a8c0ffcb82e634d6590d88ddd19764c2ea9b7a3.jpg",
+        "image_caption": [
+            "Figure 5: Effects of different training protocols. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            271,
+            112,
+            727,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b135e086c30816ce88006a0b085672256a40d1c89cfc1ee81b51bd1fe89cf59.jpg",
+        "table_caption": [
+            "Table 1: Success rates in different game settings including scenarios seen during training, new environments and new tasks. All policies are trained in the same environment in seen scenarios. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"5\">Seen scenarios</td><td colspan=\"4\">Unseen environments</td><td>Unseen tasks</td></tr><tr><td>Find x</td><td>Get x</td><td>Put x</td><td>Stack x</td><td>Put x on y</td><td>Find x</td><td>Get x</td><td>Put x</td><td>Stack x</td><td>Put x on y</td></tr><tr><td>Full model</td><td>0.995</td><td>0.970</td><td>1.00</td><td>0.955</td><td>0.873</td><td>0.723</td><td>0.648</td><td>1.00</td><td>0.613</td><td>0.792</td></tr><tr><td>Flat policy</td><td>0.980</td><td>0.965</td><td>1.00</td><td>0</td><td>0</td><td>0.515</td><td>0.450</td><td>1.00</td><td>0</td><td>0</td></tr></table>",
+        "bbox": [
+            199,
+            354,
+            810,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4a, we use various methods to train policy $\\pi _ { 1 }$ for the task set $\\mathcal { G } _ { 1 }$ based on the same base policy $\\pi _ { 0 }$ . The large dip in the reward indicates that the curriculum learning switches from phase 1 to phase 2. From Figure 4a, we may clearly see that our full model and variants can all converge within 22,000 episodes, whereas the average reward of the flat policy is still below 0.8 given the same amount of episodes. In addition, our full model finishes phase 1 significantly faster than other methods and its curve of average reward maintains notably higher than the remaining ones. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To further examine the learning efficiency during phase 2 when new tasks are added into the training process, we first pretrain $\\pi _ { 3 }$ using our full model following our definition of phase 1 in the curriculum learning. We then proceed to learning phase 2 using different approaches all based on this pretrained policy. As shown in Figure 4b, our full model has the fastest convergence and the highest average reward upon convergence. By comparing Figure 4a and Figure 4b, we further show that our full model has a bigger advantage when learning more complex tasks. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since we have a large number of previously learned tasks, H-DRLN is clearly not able to learn a descent policy according the results. Note that an H-DRLN can only learn one task at a time, each of its curves in Figure 4 is for a single task (i.e., “Get white” and “Stack white” respectively). ",
+        "bbox": [
+            174,
+            625,
+            825,
+            666
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effects of our 2-phase curriculum learning and the $- 0 . 5$ penalty on the training efficiency, we visualize the learning curves of our model trained without the curriculum learning or without the penalty along with the one trained with the full protocol in Figure 5. According to the results, the curriculum learning indeed helps accelerate the convergence, which empirically proves the importance of encouraging a global policy to reuse relevant skills learned by its base policy. It also appears that adding the penalty is an insignificant factor on learning efficiency except that it helps shorten the episode lengths as an episode ends whenever a penalty is given. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            771
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 POLICY GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            398,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we evaluate how the hierarchical design and encoding tasks by human instructions benefit the generalization of learned policies in the following three ways. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we train $\\pi _ { 1 }$ in a simpler setting where in each episode, only one item (i.e, the target item of the given task) is present. We then test the policy $\\pi _ { 1 }$ for “Get $\\mathbf { X } ^ { \\prime \\prime }$ tasks in a room where there will be multiple items serving as distraction and the agent must interact with the correct one. Both the flat policy and the hierarchical policy can achieve near perfect testing success rate in the simple setting. However, in the more complex setting, flat policy can not differentiate the target item from other items that are also placed in the room (the success rate drops to $2 9 \\%$ ), whereas our hierarchical policy still maintains a high success rate $( 9 4 \\% )$ . This finding suggests that the hierarchical policy not only picks up the concept of “find” and “get” skills as the flat policy does, but also inherits the concept of items from the base policy by learning to utter correct instructions to deploy “find” skill in the base policy. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Second, we reconfigure the room layout in Figure 3 (left) and test the flat policy and our full model in the new rooms shown in Figure 3 (right) for various tasks. Both policies are trained in the same environment. There are multiple items in a room for both training and testing cases. The success rates are summarized in Table 1. Using the flat policy results in a much bigger drop in the testing success rate compared to using out full model. This is mainly because that our global policy will repeatedly call its base policy to execute the same task until the agent finally achieves the goal even though the trained agent is unable to reach the goal by just one shot due to the simplicity of the training environment. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Third, we evaluate the learned policy on the 6 unseen tasks for the “Put x on y” tasks as a zeroshort evaluation. The success rate reported in Table 1 suggests that our model is able to learn the decomposition of human instructions and generate correct hierarchical plans to perform unseen tasks. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            354
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 POLICY INTERPRETABILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            406,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We visualize typical hierarchical plans of several tasks generated by global policies learned by our full model in Appendix C (Figure 6 and Figure 7)1. It can been seen from the examples that our global policies adjust the composed plans in different scenarios. For instance, in the second plan on the first row, $\\pi _ { 1 }$ did not deploy base policy $\\pi _ { 0 }$ as the agent was already in front of the target item at the beginning of the episode, whereas in the plan on the second row, $\\pi _ { 1 }$ deployed $\\pi _ { 0 }$ for the “Find $\\mathbf { X } ^ { \\prime \\prime }$ base task twice consecutively, as it did not finish the base task in the first call. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            318,
+            521
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have proposed a hierarchal policy modulated by a stochastic temporal grammar as a novel framework for efficient multi-task reinforcement learning through multiple training stages. Each task in our settings is described by a human instruction. The resulting global policy is able to reuse previously learned skills for new tasks by generating corresponding human instructions to inform base policies to execute relevant base tasks. We evaluate this framework in Minecraft games and have shown that our full model i) has a significantly higher learning efficiency than a flat policy does, ii) generalizes well in unseen environments, and iii) is capable of composing hierarchical plans in an interpretable manner. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Currently, we rely on weak supervision from humans to define what skills to be learned in each training stage. In the future, we plan to automatically discover the optimal training procedures to increase the task set. ",
+        "bbox": [
+            176,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            285,
+            737
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jacob Andreas, Dan Klein, and Sergey Levine. Modular multitask reinforcement learning with policy sketches. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            173,
+            746,
+            823,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Luc Bacon and Doina Precup. The option-critic architecture. In NIPS Deep Reinforcement Learning Workshop, 2015. ",
+        "bbox": [
+            173,
+            786,
+            823,
+            815
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leonard E. Baum and Ted Petrie. Statistical inference for probabilistic functions of finite state markov chains. The Annals of Mathematical Statistics, 37(6):1554–1563, 1966. ",
+        "bbox": [
+            171,
+            827,
+            823,
+            856
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Deep learning of representations for unsupervised and transfer learning. In JMLR: Workshop on Unsupervised and Transfer Learning, 2012. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Devendra Singh Chaplot, Kanthashree Mysore Sathyendra, Rama Kumar Pasumarthi, Dheeraj Rajagopal, and Ruslan Salakhutdinov. Gated-attention architectures for task-oriented language grounding. arXiv preprint arXiv:1706.0723, 2017. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Moritz Hermann, Felix Hill, Simon Green, Fumin Wang, Ryan Faulkner, Hubert Soyer, David Szepesvari, Wojtek Czarnecki, Max Jaderberg, Denis Teplyashin, Marcus Wainwright, Chris Apps, Demis Hassabis, and Phil Blunsom. Grounded language learning in a simulated 3d world. arXiv preprint arXiv:1706.06551, 2017. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew Johnson, Katja Hofmann, Tim Hutton, and David Bignell. The malmo platform for artificial intelligence experimentation. In International Joint Conference on Artificial Intelligence (IJCAI), 2016. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michał Kempka, Marek Wydmuch, Grzegorz Runc, Jakub Tocze, and Wojciech Jaskowski. Viz- ´ doom: A doom-based ai research platform for visual reinforcement learning. In IEEE Conference on Computational Intelligence and Games (CIG), 2016. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            313
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tejas D. Kulkarni, Karthik Narasimhan, Ardavan Saeedi, , and Josh Tenenbaum. Hierarchical deep reinforcement learning: Integrating temporal abstraction and intrinsic motivation. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016a. ",
+        "bbox": [
+            173,
+            371,
+            821,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Peter Pastor, Alex Krizhevsky, Julian Ibarz, , and Deirdre Quillen. Learning handeye coordination for robotic grasping with deep learning and large-scale data collection. In ” International Symposium on Experimental Robotics (ISER), 2016b. ",
+        "bbox": [
+            174,
+            409,
+            825,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andy Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, Dharshan Kumaran, and Raia Hadsell. Learning to navigate in complex environments. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            516
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In International Conference on Machine Learning (ICML), 2016. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karthik Narasimhan, Tejas Kulkarni, and Regina Barzilay. Language understanding for text-based games using deep reinforcement learning. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2015. ",
+        "bbox": [
+            176,
+            654,
+            823,
+            698
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "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. ",
+        "bbox": [
+            174,
+            705,
+            825,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lerrel Pinto and Abhinav Gupta. Supersizing self-supervision: Learning to grasp from 50k tries and 700 robot hours. In IEEE Conference on Robotics and Automation (ICRA), 2016. ",
+        "bbox": [
+            169,
+            756,
+            823,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hamed Pirsiavash and Deva Ramanan. Parsing videos of actions with segmental grammars. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2014. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            821
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Sergio Gomez Colmenarejo, Caglar Gulcehre, Guillaume Desjardins, James Kirkpatrick, Razvan Pascanu, Volodymyr Mnih, Koray Kavukcuoglu, and Raia Hadsell. Policy distillation. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            176,
+            829,
+            821,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhangzhang Si, Mingtao Pei, Benjamin Yao, and Song-Chun Zhu. Unsupervised learning of event and-or grammar and semantics from video. In IEEE International Conference on Computer Vision (ICCV), 2011. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, and Julian Schrittwieser et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, Yutian Chen, Timothy Lillicrap, Fan Hui, Laurent Sifre, George Van Den Driessche, Thore Graepel, and Demis Hassabis. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pei-Hao Su, Pawel Budzianowski, Stefan Ultes, Milica Gasic, and Steve Young. Sample-efficient actor-critic reinforcement learning with supervised data for dialogue management. In The 18th Annual SIGdial Meeting on Discourse and Dialogue (SIGDIAL), 2017. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton, Doina Precup, and Satinder Singh. Between mdps anad semi-mdps: A framework fro temporal abstraction in reinforcement learning. Artificial Intelligence, 112:181–211, 1999. ",
+        "bbox": [
+            173,
+            271,
+            823,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yee Whye Teh, Victor Bapst, Wojciech Marian Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            353
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen Tessler, Shahar Givony, Tom Zahavy, Daniel J. Mankowitz, and Shie Mannor. A deep hierarchical approach to lifelong learning in Minecraft. In AAAI Conference on Artificial Intelligence (AAAI), 2017. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012. ",
+        "bbox": [
+            173,
+            412,
+            825,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander (Sasha) Vezhnevets, Volodymyr Mnih, John Agapiou, Simon Osindero, Alex Graves, Orial Vinyals, and Koray Kavukcuoglu. Strategic attentive writer for learning macro-actions. In Advances in Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            176,
+            450,
+            823,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            176,
+            502,
+            823,
+            545
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A PSEUDO CODE OF OUR ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            524,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm $1 \\mathrm { R U N } ( k , g )$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            336,
+            154
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Input: Policy level $k$ , task $g \\in { \\mathcal { G } } _ { k }$   \nOutput: Episode trajectory $\\Gamma$ at the top level policy   \n1: $t \\gets 0$   \n2: $\\Gamma = \\emptyset$   \n3: Get initial state $s _ { 0 }$   \n4: repeat   \n5: if ${ \\bf k } = = 1$ then   \n6: Sample $a _ { t } \\sim \\pi _ { k } ( \\cdot | s _ { t } , g )$ and execute $a _ { t }$   \n7: Get current state st+1   \n8: $r _ { t } \\gets R ( s _ { t + 1 } , g )$   \n9: Add $\\langle s _ { t } , a _ { t } , r _ { t } , \\pi _ { k } ( \\cdot | s _ { t } , g ) , g \\rangle$ to $\\Gamma$   \n10: else   \n11: Sample $e _ { t }$ and $g _ { t } ^ { \\prime }$ as in Section 3.3 for using STG as guidance   \n12: Sample at ∼ πauk $a _ { t } \\sim \\pi _ { k } ^ { \\mathrm { a u g } } ( \\cdot | s _ { t } , g )$   \n13: if $e _ { t } = 0$ then   \n14: // Execute base policy $\\pi _ { k - 1 }$ by giving instruction $g _ { t } ^ { \\prime }$   \n15: $\\mathrm { R U N } ( k - 1 , g _ { t } ^ { \\prime } )$ 5   \n16: else   \n17: Execute $a _ { t }$   \n18: end if   \n19: Get current state st+1   \n20: $r _ { t } \\gets R ( s _ { t + 1 } , g )$   \n21: Add $\\langle s _ { t } , e _ { t } , g _ { t } ^ { \\prime } , a _ { t } , r _ { t } , \\pi _ { k } ^ { \\mathrm { s w } } \\big ( \\cdot | s _ { t } \\big ) , \\pi _ { k } ^ { \\mathrm { i n s t } } \\big ( \\cdot | s _ { t } , g \\big ) , \\pi _ { k } ^ { \\mathrm { a u g } } \\big ( \\cdot | s _ { t } , g \\big ) , g \\rangle$ to Γ   \n22: end if   \n23: t ← t + 1   \n24: until t > T or $\\boldsymbol r _ { t } \\neq 0$ ",
+        "bbox": [
+            173,
+            157,
+            630,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Learning global policy and STG at stage $k > 0$ ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            513,
+            573,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1: Specify $\\lambda$ , maximum training iterations $N$ , alternating update rotation frequency $M$ , and reward threshold   \n$R _ { \\mathrm { m i n } }$   \n2: Initialize total replay memory $D \\gets \\emptyset$ and its subset for positive episodes $D _ { + }  \\emptyset$   \n3: Initialize current iteration id $i \\gets 0$ and set current updating term to be $\\tau \\gets 1$   \n4: Initialize parameters of policies and value functions $\\mathrm { { \\dot { \\Theta } } } = \\langle \\theta ^ { \\mathrm { s w } } , \\theta ^ { \\mathrm { i n s t } } , \\theta ^ { \\mathrm { a u g } } , \\theta _ { v } , \\theta _ { v } ^ { \\mathrm { s w } } \\rangle$   \n5: Initialize distributions of the STG as uniform distributions   \n6: repeat   \n7: Determine current learning phase by comparing average rewards of tasks in $\\mathcal { G } _ { k - 1 }$ with $R _ { \\mathrm { m i n } }$   \n8: if in curriculum learning phase 1 then   \n9: Sample a task $g$ from base task set $\\mathcal { G } _ { k - 1 }$   \n10: else   \n11: Sample a task $g$ from global task set $\\mathcal { G } _ { k }$   \n12: end if   \n13: //Run an episode   \n15: 14: $\\Gamma  \\operatorname { R U N } ( k , g )$   \n16: if the maximum reward in $\\Gamma$ is $+ 1$ then   \n17: $D _ { + } \\gets D _ { + } \\cup \\Gamma$   \n18: Re-estimate the distributions of the STG based on updated $D _ { + }$ by MLE   \n19: end if   \n20: Sample $n \\sim \\mathrm { P o s s i o n } ( \\lambda )$   \n21: for $\\bar { j } \\in \\{ 1 , \\cdots , n \\}$ do   \n22: Sample a mini-batch $S$ from $D$   \n23: Update $\\Theta$ based on (9) and the $\\tau$ -th term in (8)   \n24: $i \\stackrel { - } {  } i + 1$   \n25: if $i \\% M = 0$ then   \n26: $\\tau  \\tau \\% 3 + 1$   \n27: end if   \n28: end for   \n29: until $i \\geq N$ ",
+        "bbox": [
+            171,
+            532,
+            820,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B ARCHITECTURES OF MODULES ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            468,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The architecture designs of all modules in our model shown in Figure 2 are as follows: ",
+        "bbox": [
+            176,
+            133,
+            738,
+            148
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Visual Encoder extracts feature maps from an input RGB frame with the size of $8 4 \\times 8 4$ through three convolutional layers: i) the first layer has 32 filters with kernel size of $8 \\times 8$ and stride of 4; ii) the second layer has 64 filters with kernel size of $4 \\times 4$ and stride of 2; iii) the last layer includes 64 filters with kernel size of $3 \\times 3$ and stride of 1. The feature maps are flatten into a 3136-dim vector. We reduce the dimension of this vector to 256 by a fully connected (FC) layer resulting a 256-dim visual feature as the final output of this module. ",
+        "bbox": [
+            174,
+            155,
+            825,
+            238
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Instruction Encoder first embeds each word into a 128-dim vector and combines them into a single vector by bag-of-words (BOW). Thus the output of this module is a 128-dim vector. For more complex instructions such as “Put $\\mathbf { X }$ on y”, we replace BOW by a GRU with 128 hidden units. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Fusion layer simply concatenates the encoded visual and language representations together and outputs 384-dim fused representation. We then feed this 384-dim vector into an LSTM with 256 hidden units. The hidden layer output of the LSTM is served as the input of all policy modules and value function modules. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            351
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Switch Policy module has a FC layer with output dimension of 2 and a softmax activation to get $\\pi _ { k } ^ { \\mathrm { s w } } ( e | s , g )$ . Instruction Policy module has two separate FC layers, both of which are activated by softmax to output the distribution of skill, $p _ { k } ^ { \\mathrm { s k i l l } } ( u _ { \\mathrm { s k i l l } } | s , g )$ , and the distribution of item, $p _ { k } ^ { \\mathrm { i t e m } } ( u _ { \\mathrm { i t e m } } | s , g )$ , respectively. Augmented Policy module outputs $\\pi _ { \\mathrm { a u g } } ( a | s , g )$ also through a FC layer and softmax activation. The two Value Function modules, $V ( s , \\bar { g } )$ and $\\dot { V } ^ { \\mathrm { s w } } ( s , e , g )$ , all have a scalar output through a FC layer. ",
+        "bbox": [
+            174,
+            357,
+            825,
+            444
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Finally, the Selector module selects the action sampled from Augmented Policy module or Base Policy module based on the switching decision sampled from the Switch Policy module. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            479
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C COMPOSED HIERARCHICAL PLANS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            500,
+            501,
+            516
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 and Figure 7 show several plans for different tasks composed by executing our hierarchical policies. ",
+        "bbox": [
+            174,
+            531,
+            823,
+            560
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/befdfbb5ae792734629bcca3d43768eaf0b510d8afdd69983060b44d6a65c07d.jpg",
+        "image_caption": [
+            "Figure 6: Samples of typical hierarchical plans for different tasks composed by our global policies. Note that all tasks must start from the top-level policy. The branches are ordered from left to right in time indicating consecutive steps carried out by a policy. We also show the egocentric view and the item in hands at critical moments for a real episode example. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            123,
+            792,
+            818
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6448093b4a41c6d19f74c7174a7e08647dad5d2a95334aaf5cfe1fb5320b506.jpg",
+        "image_caption": [
+            "Figure 7: Hierarchical plans for “Put x on y” tasks. Top: an example of performing trained tasks; bottom: an example of generalizing the plan composition to unseen tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            231,
+            789,
+            750
+        ],
+        "page_idx": 14
+    }
+]