Add files using upload-large-folder tool

parse/train/BJlyznAcFm/BJlyznAcFm.md

@@ -0,0 +1,214 @@
+# Advocacy Learning
+
+Anonymous authors Paper under double-blind review
+
+# Abstract
+
+We introduce advocacy learning, a novel supervised training scheme for classification problems. This training scheme applies to a framework consisting of two connected networks: 1) the Advocates, composed of one subnetwork per class, which take the input and provide a convincing class-conditional argument in the form of an attention map, and 2) a Judge, which predicts the inputs class label based on these arguments. Each Advocate aims to convince the Judge that the input example belongs to their corresponding class. In contrast to a standard network, in which all subnetworks are trained to jointly cooperate, we train the Advocates to competitively argue for their class, even when the input belongs to a different class. We also explore a variant, honest advocacy learning, where the Advocates are only trained on data corresponding to their class. Applied to several different classification tasks, we show that advocacy learning can lead to small improvements in classification accuracy over an identical supervised baseline. Through a series of follow-up experiments, we analyze when and how Advocates improve discriminative performance. Though it may seem counter-intuitive, a framework in which subnetworks are trained to competitively provide evidence in support of their class shows promise, performing as well as or better than standard approaches. This provides a foundation for further exploration into the effect of competition and class-conditional representations.
+
+# 1 Introduction
+
+In a classification setting, a model is trained to minimize training loss, typically subject to some penalty or prior (e.g., regularization). In recent years, researchers have proposed a large number of modifications to the standard supervised learning setting with the goal of improving performance (Parascandolo et al., 2018; Vaswani et al., 2017). However, these approaches focus on training different parts of the network to cooperate. In several real world settings, such as the allocation of resources or the determination of legal truth, agents who compete are critical to identifying good solutions. While recent work in adversarial networks investigates the use of competition for training models, the model evaluated (i.e., the generator) is self-cooperative (Goodfellow et al., 2014). In contrast, we investigate training a model where different components compete during training and evaluation. In our model, subnetworks compete to provide class-conditional representations of evidence in the form of attention maps. Here, we use the term ‘attention map’ to refer to parts of the input that are useful for accurate classification, similar to the idea of saliency (Itti et al., 1998). We hypothesize that classconditional attention maps (which attend to portions of the input indicative of a certain class) could offer advantages over standard attention maps by emphasizing class-specific evidence.
+
+Our proposed approach consists of two main components: a single Judge and multiple Advocates. Each Advocate produces an attention map that advocates for a particular class. A decision is reached by the Judge, which weighs the arguments produced by the Advocates. For this approach to work well, there must be a balance between the Advocates (so that each Advocate can influence the Judge), and the Judge must be able to effectively use the given evidence (so as not to be deceived by incorrect advocates). We achieve this balance via advocacy learning, which trains the components jointly, but according to multiple different objectives. These different objectives are key to striking the right balance between providing strong but factual evidence. We also explore a variant, honest advocacy learning, where the Advocates are not trained to deceptively compete with one another, but still provide class-conditional attention maps. In a series of experiments, we compare advocacy learning to several baselines in which the entire network is trained according to the same standard objective. Across all datasets, we observe an improvement in discriminative performance when learning class-conditional attention maps under either an advocacy or honest advocacy learning framework.
+
+# 2 Methods
+
+We propose a novel approach to optimizing networks for supervised classification that encourages class-conditional representations of evidence in the form of attention maps. We hypothesize that, depending on how they are learned, class-conditional attention maps could offer advantages over standard attention maps, by encouraging competition between components of the network. Our proposed approach consists of training two connected networks: i) the Judge and ii) the Advocates (see Figure 1b). At a high level, the Judge learns to solve the classification problem given some evidence, while the Advocates supply that evidence by arguing in support of a class which they are assigned. This method draws inspiration from the legal system, where lawyers work to represent the interests of clients while judges (or juries) establish facts. This setup is appealing because it reveals evidence that supports different classes, and encourages each side’s strongest showing, potentially leading to better final decisions. Advocacy learning consists of both a specific architecture (i.e., Advocate and Judge networks) and a specific method for training, both are described below.
+
+# 2.1 Problem Setting
+
+We consider the task of solving a multi-class classification problem in a supervised learning setting. We assume access to a labeled training set consisting of labeled examples $\{ \mathbf { x } , y \}$ , where $\mathbf { x } \in \mathbb { R } ^ { d }$ (where $d$ may be a product $d _ { 1 } \times d _ { 2 }$ , such as in an image) and $y \in \{ 1 , . . . , N \}$ , where $N$ is the number of classes. We refer to the one-hot label distribution entailed by $y$ as $\mathbf { y }$ , so $\mathbf { y } [ y ] = 1$ and $\mathbf { y } [ j ] = 0$ for all $j \neq y$ . We use square brackets for indexing into a vector. While there exist many learning frameworks to solve this class of problem, we focus on a deep learning approach. When necessary, we indicate the parameters of a deep model $M ^ { i }$ using $\theta _ { i }$ , as in: $\hat { \mathbf { y } } = M ^ { \iota } ( \mathbf { x } ; \theta _ { i } )$ . Our proposed approach aims to solve the multi-class classification problem through a novel training scheme, designed to discover evidence in support of specific class predictions.
+
+# 2.2 Network Architecture
+
+As mentioned above, our proposed approach is composed of two sets of modules: one set consisting of multiple Advocate modules (1 per class) and the other of a single Judge module. A highlevel overview of our architecture, which we call an advocacy net, is given in Figure 1b. Here, we briefly describe a generic framework that can lend context throughout the remainder of this section. Additional implementation details (e.g., number of layers) are provided in Appendix A.
+
+![](images/30f24cded3fd5657d51e1478a9c89b647a388f3bec6b97bf588fffd31da66f6e.jpg)  
+Figure 1: a) A simple single-attention framework. The encoder-decoder produce an attention map $\mathbf { a }$ , which is multiplied by the input $\mathbf { x }$ to create the input to the decision module, or Judge $J$ . b) Our advocacy learning framework. Each decoder $D e c ^ { i }$ is trained separately to output a class-conditional attention map, or argument $\mathbf { a } ^ { i }$ , which is combined with the input to create evidence $\mathbf { E } = [ \mathbf { e } _ { 0 } , . . . , \mathbf { e } _ { N } ]$ , where $\mathbf { e } _ { i }$ is evidence supporting class $_ i$ . Each advocate is shown in a different color, the number of Advocates is equal to the number of classes. c) An example of a multiplicative visual attention map $\mathbf { a } ^ { i }$ used to generate evidence $\mathbf { e } _ { i }$ .
+
+Advocate Modules. This subnetwork consists of $N$ Advocate modules $A d v ^ { i }$ , where $i \in$ $\{ 1 , . . . N \}$ corresponds to the class the Advocate represents. Given the input $\mathbf { x }$ , each advocate generates an argument in the form of an attention map $A d v ^ { \ i } ( \mathbf { x } )  \mathbf { a } ^ { \ i } \in [ 0 , 1 ] ^ { d }$ where each entry lies in the closed unit interval. In our implementation, the Advocate modules produce an attention map with dimensionality equal to the input. This is accomplished using a convolutional encoder-decoder, as is standard for producing pixel-level output in images (Badrinarayanan et al., 2017). Note that for complex input, such as medical images, other fully convolutional architectures such as U-Nets may be more appropriate Ronneberger et al. (2015). Based on these attention maps, each Advocate presents an argument $\mathbf { e } _ { i }$ as evidence to the Judge in the form of an element-wise product between attention maps and the input, $\mathbf { e } _ { i } = \mathbf { a } ^ { i } \textcircled { \cdot } \mathbf { x }$ .
+
+Each Advocate is trained to emphasizes parts of the input that are indicative of the Advocate’s class. This differs from a supervised attention map, which focuses on aspects of the input that are indicative of the underlying class. In an advocacy learning system, each Advocate should argue for a single class. In our implementation, Advocates share some underlying evidence in the form of a shared encoder. This allows the Advocates to work together while also playing off of each other.
+
+Judge Network. The Judge $J$ takes as input the combined evidence ${ \bf E } = [ { \bf e } _ { 1 } , . . . , { \bf e } _ { N } ] \in \mathbb { R } ^ { N \times d }$ , and outputs a probability distribution over classes $\hat { \mathbf { y } }$ . We make specific class predictions by taking argmax $\left( \hat { \mathbf { y } } \right)$ . The architecture of the Judge is flexible; the only limitation is that the input size must be proportional to the total number of classes. In our implementation, the Judge module is a convolutional network with fully connected output layers.
+
+While there are certain constraints on the architecture of the network, primarily the existence of the $N$ Advocate modules and Judge, it’s the interplay between the modules and how they are trained that is key. Trained end-to-end with the objective of minimizing training loss, there would be no difference between the proposed architecture and a network with multiple attention channels. This has important implications for the interpretability of the derived attention maps. If the judge is a high-capacity nonlinear network then the evidence which may convince it will by default be non-interpretable to humans. However, the flexibility of architecture requirements means that work which has examined training interpretable networks or interpreting trained networks applies Ribeiro et al. (2016); Zhang et al. (2017). In the next section, we describe the key differences in how we train the Advocates vs. the Judge.
+
+# 2.3 Training Algorithm
+
+The complete advocacy learning algorithm is presented in Algorithm 1. We learn the parameters of the Judge network by minimizing the cross-entropy loss: $C E ( \hat { \mathbf { y } } , y ) = - \mathrm { l o g } \hat { \mathbf { y } } [ y ]$ However, the Advocates are trained according to a different objective.
+
+Advocate $_ i$ is trained by minimizing the advocate cross-entropy loss: $C E ^ { A } ( \hat { \mathbf { y } } , i ) = - \mathrm { l o g } \hat { \mathbf { y } } [ i ]$ Under this objective, the Advocate is trained to represent samples from all classes as its own. We also consider a variant, called honest Advocates, which is not trained to deceive. The honest advocate loss function is:
+
+$$
+\begin{array} { r } { C E ^ { H A } ( \hat { \mathbf { y } } , i , y ) = \left\{ \begin{array} { l l } { - \mathrm { l o g } \hat { \mathbf { y } } [ i ] , } & { \mathrm { i f } \ i = y } \\ { 0 , } & { \mathrm { o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+We optimize the parameters of the Judge and Advocates by interleaving steps of gradient descent, updating the Judge and each Advocate individually according to their specific loss function. We freeze the parameters of the sub-networks not updated. This allows the Advocates to react to updates from the Judge, and the Judge to respond to the Advocates’ arguments. This optimization procedure is similar to the adversarial training procedure used for generative adversarial networks, though the objective functions differ.
+
+# 3 Baselines & Experimental Setup
+
+We evaluate our proposed advocacy learning approach across a variety of datasets and tasks, and compare against a series of different baselines. In this section, we explain our choice of datasets and baselines. We conclude by providing implementation details.
+
+# Algorithm 1: Advocacy Learning Algorithm
+
+Input :Labeled training data $\mathbf { D } = \{ \mathbf { x } _ { k } , y _ { k } \} _ { k = 1 } ^ { S }$ where $S$ is the number of samples, $\mathbf { x } _ { k } \in \mathcal { R } ^ { d }$ , and $y _ { k } \in \{ 1 , . . . N \}$ Output :Trained Network $A = ( J , A d v ^ { 1 } , . . . A d v ^ { N } )$ 1 Initialize parameters for Judge $\theta _ { J }$ and Advocates $\pmb { \theta } _ { 1 } , . . . , \pmb { \theta } _ { N }$ ; 2 while training do 3 Draw example $( \mathbf { x } , y ) \in \mathbf { D }$ ; // Showing single sample for simplicity 4 for $i \in \{ 1 , . . . N \}$ do 5 $\begin{array} { l } { { \bf { a } } ^ { i }  A d v ^ { i } ( { \bf { x } } ; { \pmb { \theta } } _ { i } ) ; } \\ { { \bf { e } } _ { i } = { \bf { a } } ^ { i } \odot { \bf { x } } ; } \end{array}$ ; 6 7 end 8 $\mathbf { E }  [ \mathbf { e } _ { 1 } , \ldots , \mathbf { e } _ { N } ]$ ; 9 $\hat { \mathbf { y } }  J ( \mathbf { E } ; \theta _ { J } )$ ; 10 $L _ { J } = - \mathrm { l o g } ( \hat { \mathbf { y } } [ y ] )$ ; // Cross-Entropy Loss, $[ * ]$ used for indexing 11 $\pmb { \theta } _ { J }  \pmb { \theta } _ { J } - \eta \bigtriangledown \theta _ { J } \pmb { L } _ { J } ;$ ; 12 for $i \in \{ 1 , . . . N \}$ do 13 if not honest or $i = y$ then // Honest Advocates update on true examples 14 $L _ { A d v ^ { i } } = - \mathrm { l o g } ( \hat { \mathbf { y } } [ i ] )$ ; 15 $\pmb { \theta } _ { i }  \pmb { \theta } _ { i } - \eta \bigtriangledown \pmb { \theta } _ { i } L _ { A d v ^ { i } }$ ; 16 end 17 end 18 end 19 return $A$
+
+# 3.1 Model and Baselines
+
+On both datasets we compare (honest) advocacy learning against three baselines that incorporate attention:
+
+• Attention Net: This baseline modifies the advocacy net architecture by removing all but one attention module, however, that module is trained using a standard end-to-end optimizer. This allows us to compare advocacy learning against a similar model using standard supervision.   
+• Multi-Attention Net: Two differences exist between attention nets and advocacy nets: the optimization procedure and the architecture. To highlight the specific effects of advocacy learning, we include a comparison against a model with an identical architecture, but trained using a standard end-to-end loss.   
+• Random Net: This baseline uses an identical architecture to the Advocate net, but does not update the Advocates. This leaves the Judge to learn from a series of random attention maps equal to the number of classes. This baseline measures whether the Advocate training is neutral, beneficial, or harmful relative to a random feature projection. It is conceptually similar to the random-pixel baseline used by (Irving et al., 2018).
+
+# 3.2 Implementation Details
+
+We implement our models using PyTorch (Paszke et al., 2017). Our specific model architecture (number of layers, filters, etc.) is given in Appendix A. In our experiments, we optimize the network weights using Adam (Kingma and Ba, 2014) with a learning rate of $1 e - 4$ , and use Dropout (Srivastava et al., 2014) and batch normalization (Ioffe and Szegedy, 2015) to prevent overfitting. We examined using stochastic gradient descent with momentum in place of ADAM, but found that it led the advocacy networks to diverge. We split off $1 0 \%$ of our training data to use as a validation set for early stopping. We cease training when validation loss fails to improve over 10 epochs. Model performance is reported on the canonical test splits for each dataset. We regularize the attention maps by adding a penalty proportional to the L1-norm of the map to encourage sparsity consistent with common notions of attention. Parameters were initialized using the default PyTorch method. All code and data used to produce our experiments will be made publicly available after review to allow for replication and extensions.
+
+Table 1: Accuracy ( $\pm$ standard deviation over 5 random seeds) on the datasets between the various models.   
+
+<table><tr><td></td><td colspan="2">Dataset</td></tr><tr><td>Model</td><td>MNIST</td><td>FMNIST</td></tr><tr><td>Random Net</td><td>99.16±0.08</td><td>88.69±0.72</td></tr><tr><td>Attention Net</td><td>99.16±0.30</td><td>89.71±0.86</td></tr><tr><td>Multi-Attention Net</td><td>99.33±0.09</td><td>90.11±0.40</td></tr><tr><td>Honest Advocacy Net</td><td>99.32±0.08</td><td>90.81±0.34</td></tr><tr><td>Advocacy Net</td><td>99.42±0.05</td><td>91.62±0.41</td></tr></table>
+
+# 4 Results and Discussion
+
+We present our main result: the performance of advocacy learning across two image datasets. We then present experiments that examine the impact of advocacy learning and the properties of advocacy networks.
+
+4.1 Advocacy Learning on Multi-Class Balanced Image Data We begin by examining the performance of our advocacy net variants and baselines on two publicly available image classification datasets: MNIST and Fashion-MNIST (Xiao et al., 2017). The Advocate modules are not optimized to improve classification performance, and their optimization could plausibly lead to a reduction in performance (by learning to deceive the Judge). However, we find across a range of datasets that this is not the case. Our results are presented in Table 1. On these datasets, advocacy learning does as well as or outperforms all baselines. The improvement is most pronounced in Fashion-MNIST, perhaps due to the denser images or the larger available room for improvement. Moreover, we find that this difference is not solely attributable to the class-conditional nature of the attention-maps, as in all datasets the advocacy nets outperform the honest advocacy nets. This suggests that deception, in addition to competition, can help produce high-quality attention maps.
+
+# 4.2 Impact of Class Conditional Attention
+
+Results in Table 1 demonstrate that class-conditional attention, or arguments, can improve upon supervised attention maps. We observe that honest advocacy nets perform similarly to multi-attention nets on MNIST, and slightly better on FMNIST. The only difference between these architectures is that the honest Advocates receive fewer gradient updates than the attention modules per epoch, in a way that makes them class specific. The competition introduced by advocacy nets further improves performance, outperforming the multi-attention net on both datasets.
+
+To get a closer look at how advocacy learning compares with the end-to-end supervised baselines, we plot the averaged difference between the confusion matrices of the multi-attention nets (MA) and advocacy nets (Adv) Figure 2. Overall, we observe that advocacy nets result in improvements for a subset of class pairs (e.g., classes 4 and 9), but leave the majority of predictions unchanged. On MNIST (Figure 2a), we find a few examples where advocacy learning lowers performance. In particular, the advocacy net is more likely to misclassify 8s as 9s; though the reverse error (9s as 8s) does not increase. This is likely due to the asymmetric morphological relationship between the digits: an 8 can be obscured to look like a 9, but the converse is less likely. It appears to help emphasize curves in the input (reducing the instances with 9 classified as 4 or 7 classified as 9). On Fashion-MNIST (Figure 2b) we observe that certain class pairs (pullovers or coats v.s. shirts) are markedly improved, while most others are unaffected. This evidence suggests that advocacy learning most improves performance by distinguishing among classes with similar morphology, though this analysis is confounded by the fact that it tends to be those class pairs that have the greatest potential room for improvement.
+
+Qualitative examples of attention maps from the honest Advocate and multi-attention network are given in Figure 3. We found honest advocacy nets gave denser (and thus more interpretable) attention maps than advocacy nets. We observe that both honest advocacy nets and multi-attention nets generate a variety of attention maps with checkering characteristic of deconvolutional layers (Odena et al., 2016). An interesting example of class-conditional behavior is shown by the advocate for class 1. This Advocate, representing the "pants" class, emphasizes the sides of the shirt, similar to pants legs.
+
+![](images/321050de97e5488edd90002e852c1bd2912952e53caaa22fe239f5505a1a15ba.jpg)  
+Figure 2: Averaged difference across five runs in confusion matrices between the multi-attention and advocacy networks ( $\geq 0$ means the Advocacy net performed better) on a) MNIST and b) FMNIST. We zero out the diagonal elements to focus on misclassification. A positive number means the multi-attention net made more misclassifications than the advocacy net and vice-versa. We observe the advocacy net tends to improve performance across classes, but can make certain morphologically similar examples (i.e., 8 vs 9 in a) more difficult.
+
+![](images/f444d7207299b84553d286cbdd1d21c33a367933f10aa550acb1f135bac2ead8.jpg)  
+Figure 3: Evidence generated from a Fashion-MNIST example. The top row shows a sample from the class the column represents. The second row shows evidence generated by the multi-attention net (the ordering is arbitrary), the bottom row shows evidence from an honest Advocate network (the order corresponds to class). The image is an example of class 6 (shirts). Of particular note is the argument generated by the Advocate for class 1 (pants).
+
+![](images/5d132ff8166f259dcaf1913f71003233c784e5e7c09dfc609a579bcca553933c.jpg)  
+Figure 4: a) A heatmap showing effect of varying Judge and Advocate capacity (in terms of residual blocks: high $\#$ means high capacity) for an advocacy net on MNIST. b-c) The two general trends seen over the heatmap. In (b) we see that performance decreases as we increase Advocate capacity, in (c) we see that performance increases as we increase Judge capacity.
+
+# 4.3 Impact of Advocate and Judge Capacity
+
+As the Advocates try to deceive the Judge, a natural question is how the relative capacity of these components impacts performance. To answer this question, we look a variation of our advocacy net where we can easily vary the capacity of different pieces. We replace the convolutional layers in the Advocate encoder and Judge with some number of convolutional residual blocks. By changing the number of blocks, we can increase or decrease the capacity of the Advocate or
+
+Table 2: Accuracy ( $\pm$ standard deviation over 5 random seeds, this is not a confidence interval) on the modified MNIST datasets between the various models. The MIMIC results are reported in terms of AUPR.   
+
+<table><tr><td></td><td colspan="3">Dataset</td></tr><tr><td>Model</td><td>MIMIC</td><td>Imbalanced MNIST</td><td>Binary MNIST</td></tr><tr><td>Random Net</td><td>39.26±1.51</td><td>99.02±0.08</td><td>98.58±1.35</td></tr><tr><td>Attention Net</td><td>45.79±1.80</td><td>98.68±0.48</td><td>99.23±0.22</td></tr><tr><td>Multi-Attention Net</td><td>45.74±1.71</td><td>99.00±0.13</td><td>99.32±0.14</td></tr><tr><td>Honest Advocacy Net</td><td>46.34±1.73</td><td>99.17±0.06</td><td>99.31±0.13</td></tr><tr><td>Advocacy Net</td><td>39.03±4.58</td><td>99.17±0.14</td><td>98.72±0.58</td></tr></table>
+
+Judge. Details of this modification are given in Appendix A. We observe that the advocacy net performs best when Judge capacity is high and Advocate capacity is low. Our best result from Figure 4a is slightly higher than our best MNIST result in Table 1 ( $9 9 . 4 6 \%$ v.s. $9 9 . 4 2 \%$ ). We performed an identical architecture search with the multi-attention net, there was no capacity setting that beat the best results attained by the advocacy net (best $9 9 . 3 4 \%$ v.s. $9 9 . 4 6 \%$ ).
+
+# 4.4 Competition and Deception
+
+On the tasks considered above, it is somewhat surprising that advocacy nets outperform honest advocacy nets. Both incorporate class-conditional attention maps that compete to influence the Judge. The fact that advocacy nets, which are trained to actively deceive the Judge, do better suggests that such deception may play a useful role in learning.
+
+To better understand the potential strength of the deception, we examined the effect of freezing the Judge while continuing to update the Advocates for both advocate and honest advocate nets. We found that training without the Judge did not affect network performance in the honest advocate net, but decreased performance in the advocate net by $8 5 \%$ . Thus it is clear that adaptations by the Judge play a crucial role in maintaining advocate net accuracy.
+
+Up to this point, we have considered only advocacy networks in which all Advocates share an encoder. Such an architecture could encourage implicit sharing of information, possibly tempering the negative effects of deception. To test this hypothesis, we evaluated an advocacy net without a shared encoder on MNIST and FMNIST. On both datasets (averaged across 5 runs), we found that the advocacy network without a shared encoder achieved lower performance both in absolute terms and relative to an honest advocacy network without a shared encoder (98.29 v.s. 99.05 for MNIST, 86.47 v.s. 89.29 for FMIST). This suggests the shared encoder is an important way for Advocates to share information.
+
+The results presented so far all involve multi-class image datasets with balanced classes. To explore how these assumptions change the impact of deception in competition, we applied advocacy learning to a large electronic health record (EHR) dataset, MIMIC III (Johnson et al., 2016). This dataset, the largest publicly available repository of EHR data, has become an important benchmark in the machine learning for health community (Harutyunyan et al., 2017), and is helping to drive advances in precision health (Desautels et al., 2016; Maslove et al., 2017; Oh et al., 2018). We used the clinical time-series subset of the database for mortality prediction, as in Harutyunyan et al. (2017). We also considered variants of MNIST that break the multi-class and balanced assumptions. These additional experiments test the generalizability of our findings to i) different data types (time series as opposed to images), ii) imbalanced classes, and iii) binary labels. Our results are presented in Table 2.
+
+We report our results on MIMIC in terms of the area under the precision recall curve (AUPR), since the task is binary with considerable class imbalance in the test set. We find that honest advocacy learning continues to provide benefits relative to the baselines, though the differences are small. Notably, in this task advocacy learning performs slightly worse than the random attention, while honest advocacy learning outperforms the fully supervised system.
+
+This reversal of the results from Table 1 is interesting, and helps illuminate cases where advocacy learning may or may not work. There are many differences between MIMIC and MNIST/FMNIST which may explain why advocacy learning fails. Two of the major differences, besides the data type, are the imbalanced classes and the number of classes. To see the isolated effect of these changes, we created two modified versions of MNIST.
+
+For the first modified MNIST, Imbalanced MNIST, we subsampled the training set, introducing class imbalance. After subsampling, the least represented class, 0, had 600 training samples, and each successive class had 600 additional samples. The test set remained unchanged, which is why we report results in accuracy. We found that class imbalance lowered the performance of all models by $0 . 1 \mathrm { - } 0 . 3 \%$ ; the Advocate net was more strongly affected than the honest Advocate net. However, both models wind up with very similar accuracy (advocacy learning 99.17±0.14 vs. honest advocacy learning 99.17 $\pm$ 0.06).
+
+For the second modification, we created Binary MNIST, a variant with only two classes: 4 and 9. The per-class number of examples in the training and test set were unchanged. We found that the switch to a binary formulation reduced absolute performance for the advocacy network by $0 . 7 \%$ , a sizable decrease for MNIST for what should be an easier problem. We did not observe similar decreases with either the honest advocate net or the multi-attention net. This decrease suggests that, in practice, the competition between many advocates helps the Judge achieve good performance in the presence of deception. In all datasets considered, the class-conditional attention provided by honest advocacy learning did not hurt, and in the presence of imbalanced data helped, performance relative to the supervised baseline. This suggests the value of competition in training, with or without deception.
+
+# 4.5 Intuition for Advocates
+
+The fundamental idea of this work: advocate modules that compete with one another instead of cooperating, is counter-intuitive from a performance perspective. The fact that this training scheme works at all, let alone better than the baselines in several datasets, is quite surprising. However, there are reasons other than the empirically demonstrated performance to suggest that such a training approach could work. Honest Advocates are similar to a Mixture-of-Experts model, and such models have a long and rich history (Yuksel et al., 2012). As for vanilla Advocates, their original motivation was to introduce competition into the training of a neural network. In economic theory, competition plays a vital role in efficiently allocating resources, leading to better functioning systems (Godfrey, 2008). In machine learning, the notion of competition has been found useful as an adaptive loss function for image generation (Goodfellow et al., 2014) and self-competition was used to surpass professional Go players (Silver et al., 2017). While these systems used competition between networks during training, competition within a network has been used as well. A winner-take-all competitive framework was found to lead to superior semi-supervised image classification performance (Makhzani and Frey, 2015), and the dynamic routing used in Capsule Networks can been seen as type of competition (Sabour et al., 2017).
+
+The field of multi-objective optimization also gives evidence that advocacy learning could plausibly be expected to work. A well known result from that field is that multiple gradient descent, a form of gradient descent applied against multiple (possibly contradicting) objective functions, achieves a Pareto equilibrium, or a setting where no objective can be improved without damaging the performance of a different objective (Désidéri, 2014). Viewed through this lens, advocacy learning may be expected to work because of the asymmetry in the objective functions for the advocates vs. the judge. Over a batch of data, each advocate is neutral to the ordering of class assignments, as the objective depends solely on the number of class labels which it is assigned. However, the Judge is highly sensitive to this ordering, as its objective function requires classes to be properly labeled. Thus, over the optimization procedure we might expect predictions for misclassified examples to change, as the advocates are neutral to this, but we would expect the predictions for correctly classified examples to remain constant as the judge is sensitive to this. As a result, over the optimization procedure we expect the performance to increase, converging at perfect training performance. Of course, our use of standard gradient descent (using ADAM) and the non-convexity of the loss function complicates this analysis, but such complications are not unusual in the analysis of neural networks. This provides some theoretical backing to the empirical success of advocacy learning.
+
+# 5 Related Work
+
+Our proposed advocacy learning setup, in which the Advocates are trained to consistently argue for their particular class in order to convince a Judge, is related to several different ideas proposed in recent years. These include 1) mixture-of-experts, 2) generative adversarial networks and 3) debate agents. Here, we review each of these in turn, highlighting relevant similarities and differences with our proposed approach.
+
+Others have considered transformations of the input in the context of improving classification. Parascandolo et al. (2018) proposed the use of a mixture-of-experts model to learn inverse data transforms, such as denoising, to improve performance. These transforms are similar in nature to the attention maps generated by our fully supervised baselines, and the competition between experts resembles our Advocate-Advocate relationships. Our work differs in the nature of our Advocate loss (unsupervised), the goal of the Advocates (convincing the Judge of a particular class), and the manner in which Advocates specialize (our Advocates are assigned particular classes to represent).
+
+Advocacy learning consists of Advocate-Advocate relationships and Advocate-Judge relationships. In standard neural networks, all relationships are cooperative. I.e., all parts of the network are trained to accomplish the same goal. Adversarial relationships, or situations where the submodules compete with one another, have recently garnered interest (Durugkar et al., 2016; Goodfellow et al., 2014; Ghosh et al., 2017). Within a generative adversarial network framework, researchers have examined multiple discriminators (Durugkar et al., 2016) and multiple generators (Ghosh et al., 2017). In the multi-generator setting, each generator is encouraged to capture distinct portions of the class distribution. This bears a resemblance to the way in which each of our advocates captures relevant evidence in favor of its corresponding class. However, in contrast to GANs, advocacy learning focuses discrimination, not generation. Moreover, the Advocate-Judge relationship is neither entirely cooperative (the Advocate may argue for an untrue class) nor entirely adversarial (the Advocate may argue for a true class).
+
+Concurrent work sets up a similar task to our own, training agents to ‘debate’ in order to convince a Judge about the class associated with an input (Irving et al., 2018). The authors use MonteCarlo tree search to simulate a debate with the goal of identifying a series of pixels to convince a pre-trained Judge classifier of an input example’s class. While conceptually similar to advocacy learning, our work differs in motivation and methodologically. In addition to considering a different learning framework: neural networks, vs. Monte-Carlo tree search, there are two key differences in problem formulation: 1) our work is geared towards jointly learning Judges and Advocates, instead of learning debaters that convince a separately trained (or human) Judge, and 2) our work involves Advocates, not debaters, the distinction is that the debaters choose what they will argue for and are awarded based on relative performance, whereas Advocates are forced to argue for particular outcomes and are rewarded only insofar as those outcomes are realized.
+
+# 6 Conclusion
+
+We have presented a novel approach to supervised classification: advocacy learning. Our approach divides a network into two sub-networks: i) a set of Advocates trained to provide arguments supporting their corresponding class, and ii) a Judge that uses these arguments to predict the true class. These sub-networks differ not only in their goals, but also in how they are trained. Over a series of experiments on three publicly available datasets, we showed that class-condition attention can improve performance relative to standard attention. These results were particularly notable in a multi-class setting. Despite the lack of supervision, Advocates can effectively compete to generate higher quality evidence, though this effect was largely localized to a few class-pairs (e.g. shirts v.s. pullovers). Moreover, by varying the network architecture (e.g., by changing the capacity and or by increasing the amount of weight sharing), one can tradeoff deception, competition, and cooperation of the various subnetworks. Extensions may consider further improving this balance, by controlling the ratio of honest and deceptive updates, or the ratio of class-specific updates. A limitation of this architecture is the one-to-one relationship between the number of classes and number of advocates, which makes training on datasets like ImageNet implausible. Future work could examine methods to remove this linear relationship, such as training advocates that work across class hierarchies.
+
+# References
+
+V. Badrinarayanan, A. Kendall, and R. Cipolla. Segnet: A deep convolutional encoder-decoder architecture for image segmentation. IEEE transactions on pattern analysis and machine intelligence, 39(12):2481–2495, 2017.
+
+T. Desautels, J. Calvert, J. Hoffman, M. Jay, Y. Kerem, L. Shieh, D. Shimabukuro, U. Chettipally, M. D. Feldman, C. Barton, D. J. Wales, and R. Das. Prediction of Sepsis in the Intensive Care Unit With Minimal Electronic Health Record Data: A Machine Learning Approach. JMIR Medical Informatics, 4(3), Sept. 2016. ISSN 2291-9694. doi: 10.2196/medinform.5909. URL https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5065680/.
+
+I. Durugkar, I. Gemp, and S. Mahadevan. Generative Multi-Adversarial Networks. arXiv:1611.01673 [cs], Nov. 2016. URL http://arxiv.org/abs/1611.01673. arXiv: 1611.01673.
+
+J.-A. Désidéri. Multiple-gradient Descent Algorithm for Pareto-Front Identification. In W. Fitzgibbon, Y. A. Kuznetsov, P. Neittaanmäki, and O. Pironneau, editors, Modeling, Simulation and Optimization for Science and Technology, Computational Methods in Applied Sciences, pages 41–58. Springer Netherlands, Dordrecht, 2014. ISBN 978-94-017-9054-3. doi: 10.1007/978-94-017-9054-3_3. URL https://doi.org/10.1007/978-94-017-9054-3_3.
+
+A. Ghosh, V. Kulharia, V. Namboodiri, P. H. Torr, and P. K. Dokania. Multi-agent diverse generative adversarial networks. arXiv preprint arXiv:1704.02906, 2017.
+
+N. Godfrey. WHY IS COMPETITION IMPORTANT FOR GROWTH AND POVERTY REDUCTION? page 12, 2008.
+
+I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.
+
+H. Harutyunyan, H. Khachatrian, D. C. Kale, and A. Galstyan. Multitask Learning and Benchmarking with Clinical Time Series Data. arXiv:1703.07771 [cs, stat], Mar. 2017. URL http://arxiv.org/abs/1703.07771. arXiv: 1703.07771.
+
+S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+G. Irving, P. Christiano, and D. Amodei. AI safety via debate. arXiv:1805.00899 [cs, stat], May 2018. URL http://arxiv.org/abs/1805.00899. arXiv: 1805.00899.
+
+L. Itti, C. Koch, and E. Niebur. A model of saliency-based visual attention for rapid scene analysis. IEEE Transactions on Pattern Analysis and Machine Intelligence, 20(11): 1254–1259, Nov. 1998. ISSN 0162-8828. doi: 10.1109/34.730558.
+
+A. E. Johnson, T. J. Pollard, L. Shen, H. L. Li-wei, M. Feng, M. Ghassemi, B. Moody, P. Szolovits, L. A. Celi, and R. G. Mark. MIMIC-III, a freely accessible critical care database. Scientific data, 3:160035, 2016.
+
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+A. Makhzani and B. J. Frey. Winner-take-all autoencoders. In Advances in Neural Information Processing Systems, pages 2791–2799, 2015.
+
+D. M. Maslove, F. Lamontagne, J. C. Marshall, and D. K. Heyland. A path to precision in the ICU. Critical Care, 21(1):79, Apr. 2017. ISSN 1364-8535. doi: 10.1186/s13054-017-1653-x. URL https://doi.org/10.1186/s13054-017-1653-x.
+
+A. Odena, V. Dumoulin, and C. Olah. Deconvolution and checkerboard artifacts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/deconv-checkerboard.
+
+J. Oh, J. Wang, and J. Wiens. Learning to Exploit Invariances in Clinical Time-Series Data using Sequence Transformer Networks. arXiv preprint arXiv:1808.06725, 2018.   
+G. Parascandolo, N. Kilbertus, M. Rojas-Carulla, and B. Schölkopf. Learning Independent Causal Mechanisms. In International Conference on Machine Learning, pages 4036–4044, July 2018. URL http://proceedings.mlr.press/v80/parascandolo18a.html.   
+A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   
+M. T. Ribeiro, S. Singh, and C. Guestrin. Model-agnostic interpretability of machine learning. arXiv preprint arXiv:1606.05386, 2016.   
+O. Ronneberger, P. Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pages 234–241. Springer, 2015.   
+S. Sabour, N. Frosst, and G. E. Hinton. Dynamic routing between capsules. In Advances in Neural Information Processing Systems, pages 3856–3866, 2017.   
+D. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T. Hubert, L. Baker, M. Lai, A. Bolton, Y. Chen, T. Lillicrap, F. Hui, L. Sifre, G. van den Driessche, T. Graepel, and D. Hassabis. Mastering the game of Go without human knowledge. Nature, 550(7676):354–359, Oct. 2017. ISSN 0028-0836. doi: 10.1038/nature24270. URL https://www.nature.com/nature/journal/v550/n7676/full/nature24270.html.   
+N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.   
+A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention Is All You Need. arXiv:1706.03762 [cs], June 2017. URL http://arxiv.org/abs/1706.03762. arXiv: 1706.03762.   
+H. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. arXiv:1708.07747 [cs, stat], Aug. 2017. URL http://arxiv.org/abs/1708.07747. arXiv: 1708.07747.   
+S. E. Yuksel, J. N. Wilson, and P. D. Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   
+Q. Zhang, Y. N. Wu, and S.-C. Zhu. Interpretable convolutional neural networks. arXiv preprint arXiv:1710.00935, 2(3):5, 2017.
+
+# A Network Architecture
+
+We provide the specific architecture used for our Judge and Advocate Module on the image and MIMIC experiments. Other implementation details are found in the main paper.
+
+Table 3: The Judge network for Image data.   
+
+<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features</td><td></td></tr><tr><td>Conv1</td><td>32x3x3 Convolution 32 Channel 2d BatchNorm</td></tr><tr><td>Conv2</td><td>ReLU 32x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x3x3 Convolution 64 Channel 2d BatchNorm</td></tr><tr><td>Conv4</td><td>ReLU 64x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Output</td><td>2x2 Max Pool</td></tr><tr><td>FC1</td><td>512 node Linear layer 512 Channel1d BatchNorm ReLU</td></tr><tr><td>Out</td><td>Dropout(p=0.2) Linear Output</td></tr></table>
+
+Table 4: The Advocate Module for Image data.   
+
+<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Encoder</td><td></td></tr><tr><td>Conv1</td><td>32x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv2</td><td>32x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv4</td><td>64x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Decoder</td><td>2x2 Max Pool</td></tr><tr><td>Deconv1</td><td>32x3x3 Stride-1 Deconvolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv2</td><td>16x2x2 Stride-2 Deconvolution 16 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv3</td><td>8x2x2 Stride-2 Deconvolution 8 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv4</td><td>4x5x5 Stride-1 Deconvolution 4 Channel 2dBatchNorm</td></tr><tr><td>Output</td><td>ReLU 2x3x3 Convolution with Padding=1 2 channel 2d BatchNorm 1xlx1 Convolution</td></tr></table>
+
+Table 5: The residual blocks in the variable capacity Judge and Advocate components. Both blocks are repeated $n$ times where $n$ is the number of residual blocks for the network. Max pooling is done after each block. Three additional 2x2 convolutions are performed before the output. In the Advocate encoder, this output is given to the decoder. In the Judge, the output is given to the fully connected layers. In both cases, the architecture remains unchanged from the non-residual verison.   
+
+<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features</td><td></td></tr><tr><td>Block1</td><td>32x3x3 Convolution with padding 1 32 Channel 2d BatchNorm</td></tr><tr><td>Block2</td><td>ReLU 32x3x3 Convolution 64 Channel 2d BatchNorm</td></tr></table>
+
+Table 6: The Judge network for MIMIC III.   
+
+<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features Conv1</td><td>64x3 1D Convolution</td></tr><tr><td></td><td>64 Channel 1D BatchNorm ReLU 2-width 1D Max Pool</td></tr><tr><td>Conv2</td><td>64x31D Convolution 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>FC1</td><td>2-width 1D Max Pool 64 node Linear layer 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>Out</td><td>Dropout(p=0.2) Linear Output</td></tr></table>
+
+Table 7: The Advocate Module for MIMIC. Note the final convolution has a number of layers equal to the input channel size, which for the MIMIC III benchmark is 76.   
+
+<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Encoder</td><td></td></tr><tr><td>Conv1</td><td>32x3 1D Convolution 32 Channel !d BatchNorm</td></tr><tr><td>Conv2</td><td>ReLU 32x3 1D Convolution 32 Channel 1d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x31D Convolution 64 Channel 1d BatchNorm ReLU</td></tr><tr><td>Conv4</td><td>64x31D Convolution 64 Channel 2dBatchNorm ReLU</td></tr><tr><td>Decoder</td><td>2x2 Max Pool</td></tr><tr><td>Deconv1</td><td>32x3 Stride-1 1D Deconvolution 32 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv2</td><td>32x2 Stride-2 1D Deconvolution 32 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv3</td><td>64x2 Stride-2 1D Deconvolution 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv4</td><td>64x5 Stride-1 1D Deconvolution 64 Channel1d BatchNorm ReLU</td></tr><tr><td>Output</td><td>64x3 1D Convolution with Padding=1 64 channel 1D BatchNorm Nx1 1D Convolution</td></tr></table>

parse/train/BJlyznAcFm/BJlyznAcFm_content_list.json

@@ -0,0 +1,1120 @@
+[
+    {
+        "type": "text",
+        "text": "Advocacy Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            452,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            145,
+            415,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            209,
+            545,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce advocacy learning, a novel supervised training scheme for classification problems. This training scheme applies to a framework consisting of two connected networks: 1) the Advocates, composed of one subnetwork per class, which take the input and provide a convincing class-conditional argument in the form of an attention map, and 2) a Judge, which predicts the inputs class label based on these arguments. Each Advocate aims to convince the Judge that the input example belongs to their corresponding class. In contrast to a standard network, in which all subnetworks are trained to jointly cooperate, we train the Advocates to competitively argue for their class, even when the input belongs to a different class. We also explore a variant, honest advocacy learning, where the Advocates are only trained on data corresponding to their class. Applied to several different classification tasks, we show that advocacy learning can lead to small improvements in classification accuracy over an identical supervised baseline. Through a series of follow-up experiments, we analyze when and how Advocates improve discriminative performance. Though it may seem counter-intuitive, a framework in which subnetworks are trained to competitively provide evidence in support of their class shows promise, performing as well as or better than standard approaches. This provides a foundation for further exploration into the effect of competition and class-conditional representations. ",
+        "bbox": [
+            233,
+            242,
+            764,
+            520
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            550,
+            339,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In a classification setting, a model is trained to minimize training loss, typically subject to some penalty or prior (e.g., regularization). In recent years, researchers have proposed a large number of modifications to the standard supervised learning setting with the goal of improving performance (Parascandolo et al., 2018; Vaswani et al., 2017). However, these approaches focus on training different parts of the network to cooperate. In several real world settings, such as the allocation of resources or the determination of legal truth, agents who compete are critical to identifying good solutions. While recent work in adversarial networks investigates the use of competition for training models, the model evaluated (i.e., the generator) is self-cooperative (Goodfellow et al., 2014). In contrast, we investigate training a model where different components compete during training and evaluation. In our model, subnetworks compete to provide class-conditional representations of evidence in the form of attention maps. Here, we use the term ‘attention map’ to refer to parts of the input that are useful for accurate classification, similar to the idea of saliency (Itti et al., 1998). We hypothesize that classconditional attention maps (which attend to portions of the input indicative of a certain class) could offer advantages over standard attention maps by emphasizing class-specific evidence. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            776
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our proposed approach consists of two main components: a single Judge and multiple Advocates. Each Advocate produces an attention map that advocates for a particular class. A decision is reached by the Judge, which weighs the arguments produced by the Advocates. For this approach to work well, there must be a balance between the Advocates (so that each Advocate can influence the Judge), and the Judge must be able to effectively use the given evidence (so as not to be deceived by incorrect advocates). We achieve this balance via advocacy learning, which trains the components jointly, but according to multiple different objectives. These different objectives are key to striking the right balance between providing strong but factual evidence. We also explore a variant, honest advocacy learning, where the Advocates are not trained to deceptively compete with one another, but still provide class-conditional attention maps. In a series of experiments, we compare advocacy learning to several baselines in which the entire network is trained according to the same standard objective. Across all datasets, we observe an improvement in discriminative performance when learning class-conditional attention maps under either an advocacy or honest advocacy learning framework. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            183,
+            295,
+            199
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel approach to optimizing networks for supervised classification that encourages class-conditional representations of evidence in the form of attention maps. We hypothesize that, depending on how they are learned, class-conditional attention maps could offer advantages over standard attention maps, by encouraging competition between components of the network. Our proposed approach consists of training two connected networks: i) the Judge and ii) the Advocates (see Figure 1b). At a high level, the Judge learns to solve the classification problem given some evidence, while the Advocates supply that evidence by arguing in support of a class which they are assigned. This method draws inspiration from the legal system, where lawyers work to represent the interests of clients while judges (or juries) establish facts. This setup is appealing because it reveals evidence that supports different classes, and encourages each side’s strongest showing, potentially leading to better final decisions. Advocacy learning consists of both a specific architecture (i.e., Advocate and Judge networks) and a specific method for training, both are described below. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Problem Setting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            404,
+            354,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider the task of solving a multi-class classification problem in a supervised learning setting. We assume access to a labeled training set consisting of labeled examples $\\{ \\mathbf { x } , y \\}$ , where $\\mathbf { x } \\in \\mathbb { R } ^ { d }$ (where $d$ may be a product $d _ { 1 } \\times d _ { 2 }$ , such as in an image) and $y \\in \\{ 1 , . . . , N \\}$ , where $N$ is the number of classes. We refer to the one-hot label distribution entailed by $y$ as $\\mathbf { y }$ , so $\\mathbf { y } [ y ] = 1$ and $\\mathbf { y } [ j ] = 0$ for all $j \\neq y$ . We use square brackets for indexing into a vector. While there exist many learning frameworks to solve this class of problem, we focus on a deep learning approach. When necessary, we indicate the parameters of a deep model $M ^ { i }$ using $\\theta _ { i }$ , as in: $\\hat { \\mathbf { y } } = M ^ { \\iota } ( \\mathbf { x } ; \\theta _ { i } )$ . Our proposed approach aims to solve the multi-class classification problem through a novel training scheme, designed to discover evidence in support of specific class predictions. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Network Architecture ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            577,
+            411,
+            590
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, our proposed approach is composed of two sets of modules: one set consisting of multiple Advocate modules (1 per class) and the other of a single Judge module. A highlevel overview of our architecture, which we call an advocacy net, is given in Figure 1b. Here, we briefly describe a generic framework that can lend context throughout the remainder of this section. Additional implementation details (e.g., number of layers) are provided in Appendix A. ",
+        "bbox": [
+            174,
+            592,
+            823,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/30f24cded3fd5657d51e1478a9c89b647a388f3bec6b97bf588fffd31da66f6e.jpg",
+        "image_caption": [
+            "Figure 1: a) A simple single-attention framework. The encoder-decoder produce an attention map $\\mathbf { a }$ , which is multiplied by the input $\\mathbf { x }$ to create the input to the decision module, or Judge $J$ . b) Our advocacy learning framework. Each decoder $D e c ^ { i }$ is trained separately to output a class-conditional attention map, or argument $\\mathbf { a } ^ { i }$ , which is combined with the input to create evidence $\\mathbf { E } = [ \\mathbf { e } _ { 0 } , . . . , \\mathbf { e } _ { N } ]$ , where $\\mathbf { e } _ { i }$ is evidence supporting class $_ i$ . Each advocate is shown in a different color, the number of Advocates is equal to the number of classes. c) An example of a multiplicative visual attention map $\\mathbf { a } ^ { i }$ used to generate evidence $\\mathbf { e } _ { i }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            662,
+            805,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Advocate Modules. This subnetwork consists of $N$ Advocate modules $A d v ^ { i }$ , where $i \\in$ $\\{ 1 , . . . N \\}$ corresponds to the class the Advocate represents. Given the input $\\mathbf { x }$ , each advocate generates an argument in the form of an attention map $A d v ^ { \\ i } ( \\mathbf { x } )  \\mathbf { a } ^ { \\ i } \\in [ 0 , 1 ] ^ { d }$ where each entry lies in the closed unit interval. In our implementation, the Advocate modules produce an attention map with dimensionality equal to the input. This is accomplished using a convolutional encoder-decoder, as is standard for producing pixel-level output in images (Badrinarayanan et al., 2017). Note that for complex input, such as medical images, other fully convolutional architectures such as U-Nets may be more appropriate Ronneberger et al. (2015). Based on these attention maps, each Advocate presents an argument $\\mathbf { e } _ { i }$ as evidence to the Judge in the form of an element-wise product between attention maps and the input, $\\mathbf { e } _ { i } = \\mathbf { a } ^ { i } \\textcircled { \\cdot } \\mathbf { x }$ . ",
+        "bbox": [
+            174,
+            138,
+            825,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each Advocate is trained to emphasizes parts of the input that are indicative of the Advocate’s class. This differs from a supervised attention map, which focuses on aspects of the input that are indicative of the underlying class. In an advocacy learning system, each Advocate should argue for a single class. In our implementation, Advocates share some underlying evidence in the form of a shared encoder. This allows the Advocates to work together while also playing off of each other. ",
+        "bbox": [
+            174,
+            285,
+            823,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Judge Network. The Judge $J$ takes as input the combined evidence ${ \\bf E } = [ { \\bf e } _ { 1 } , . . . , { \\bf e } _ { N } ] \\in \\mathbb { R } ^ { N \\times d }$ , and outputs a probability distribution over classes $\\hat { \\mathbf { y } }$ . We make specific class predictions by taking argmax $\\left( \\hat { \\mathbf { y } } \\right)$ . The architecture of the Judge is flexible; the only limitation is that the input size must be proportional to the total number of classes. In our implementation, the Judge module is a convolutional network with fully connected output layers. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While there are certain constraints on the architecture of the network, primarily the existence of the $N$ Advocate modules and Judge, it’s the interplay between the modules and how they are trained that is key. Trained end-to-end with the objective of minimizing training loss, there would be no difference between the proposed architecture and a network with multiple attention channels. This has important implications for the interpretability of the derived attention maps. If the judge is a high-capacity nonlinear network then the evidence which may convince it will by default be non-interpretable to humans. However, the flexibility of architecture requirements means that work which has examined training interpretable networks or interpreting trained networks applies Ribeiro et al. (2016); Zhang et al. (2017). In the next section, we describe the key differences in how we train the Advocates vs. the Judge. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Training Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            383,
+            621
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The complete advocacy learning algorithm is presented in Algorithm 1. We learn the parameters of the Judge network by minimizing the cross-entropy loss: $C E ( \\hat { \\mathbf { y } } , y ) = - \\mathrm { l o g } \\hat { \\mathbf { y } } [ y ]$ However, the Advocates are trained according to a different objective. ",
+        "bbox": [
+            174,
+            621,
+            825,
+            662
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Advocate $_ i$ is trained by minimizing the advocate cross-entropy loss: $C E ^ { A } ( \\hat { \\mathbf { y } } , i ) = - \\mathrm { l o g } \\hat { \\mathbf { y } } [ i ]$ Under this objective, the Advocate is trained to represent samples from all classes as its own. We also consider a variant, called honest Advocates, which is not trained to deceive. The honest advocate loss function is: ",
+        "bbox": [
+            174,
+            669,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9c114c080b884ea56264b21727a1d8df1a948304ee64f6a776080bfaecbf6f7.jpg",
+        "text": "$$\n\\begin{array} { r } { C E ^ { H A } ( \\hat { \\mathbf { y } } , i , y ) = \\left\\{ \\begin{array} { l l } { - \\mathrm { l o g } \\hat { \\mathbf { y } } [ i ] , } & { \\mathrm { i f } \\ i = y } \\\\ { 0 , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            729,
+            632,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We optimize the parameters of the Judge and Advocates by interleaving steps of gradient descent, updating the Judge and each Advocate individually according to their specific loss function. We freeze the parameters of the sub-networks not updated. This allows the Advocates to react to updates from the Judge, and the Judge to respond to the Advocates’ arguments. This optimization procedure is similar to the adversarial training procedure used for generative adversarial networks, though the objective functions differ. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            857
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Baselines & Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            529,
+            880
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our proposed advocacy learning approach across a variety of datasets and tasks, and compare against a series of different baselines. In this section, we explain our choice of datasets and baselines. We conclude by providing implementation details. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Advocacy Learning Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            107,
+            496,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input :Labeled training data $\\mathbf { D } = \\{ \\mathbf { x } _ { k } , y _ { k } \\} _ { k = 1 } ^ { S }$ where $S$ is the number of samples, $\\mathbf { x } _ { k } \\in \\mathcal { R } ^ { d }$ , and $y _ { k } \\in \\{ 1 , . . . N \\}$ Output :Trained Network $A = ( J , A d v ^ { 1 } , . . . A d v ^ { N } )$ 1 Initialize parameters for Judge $\\theta _ { J }$ and Advocates $\\pmb { \\theta } _ { 1 } , . . . , \\pmb { \\theta } _ { N }$ ; 2 while training do 3 Draw example $( \\mathbf { x } , y ) \\in \\mathbf { D }$ ; // Showing single sample for simplicity 4 for $i \\in \\{ 1 , . . . N \\}$ do 5 $\\begin{array} { l } { { \\bf { a } } ^ { i }  A d v ^ { i } ( { \\bf { x } } ; { \\pmb { \\theta } } _ { i } ) ; } \\\\ { { \\bf { e } } _ { i } = { \\bf { a } } ^ { i } \\odot { \\bf { x } } ; } \\end{array}$ ; 6 7 end 8 $\\mathbf { E }  [ \\mathbf { e } _ { 1 } , \\ldots , \\mathbf { e } _ { N } ]$ ; 9 $\\hat { \\mathbf { y } }  J ( \\mathbf { E } ; \\theta _ { J } )$ ; 10 $L _ { J } = - \\mathrm { l o g } ( \\hat { \\mathbf { y } } [ y ] )$ ; // Cross-Entropy Loss, $[ * ]$ used for indexing 11 $\\pmb { \\theta } _ { J }  \\pmb { \\theta } _ { J } - \\eta \\bigtriangledown \\theta _ { J } \\pmb { L } _ { J } ;$ ; 12 for $i \\in \\{ 1 , . . . N \\}$ do 13 if not honest or $i = y$ then // Honest Advocates update on true examples 14 $L _ { A d v ^ { i } } = - \\mathrm { l o g } ( \\hat { \\mathbf { y } } [ i ] )$ ; 15 $\\pmb { \\theta } _ { i }  \\pmb { \\theta } _ { i } - \\eta \\bigtriangledown \\pmb { \\theta } _ { i } L _ { A d v ^ { i } }$ ; 16 end 17 end 18 end 19 return $A$ ",
+        "bbox": [
+            151,
+            125,
+            826,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Model and Baselines ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            392,
+            491
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On both datasets we compare (honest) advocacy learning against three baselines that incorporate attention: ",
+        "bbox": [
+            176,
+            492,
+            821,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Attention Net: This baseline modifies the advocacy net architecture by removing all but one attention module, however, that module is trained using a standard end-to-end optimizer. This allows us to compare advocacy learning against a similar model using standard supervision.   \n• Multi-Attention Net: Two differences exist between attention nets and advocacy nets: the optimization procedure and the architecture. To highlight the specific effects of advocacy learning, we include a comparison against a model with an identical architecture, but trained using a standard end-to-end loss.   \n• Random Net: This baseline uses an identical architecture to the Advocate net, but does not update the Advocates. This leaves the Judge to learn from a series of random attention maps equal to the number of classes. This baseline measures whether the Advocate training is neutral, beneficial, or harmful relative to a random feature projection. It is conceptually similar to the random-pixel baseline used by (Irving et al., 2018). ",
+        "bbox": [
+            215,
+            535,
+            825,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Implementation Details ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            413,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We implement our models using PyTorch (Paszke et al., 2017). Our specific model architecture (number of layers, filters, etc.) is given in Appendix A. In our experiments, we optimize the network weights using Adam (Kingma and Ba, 2014) with a learning rate of $1 e - 4$ , and use Dropout (Srivastava et al., 2014) and batch normalization (Ioffe and Szegedy, 2015) to prevent overfitting. We examined using stochastic gradient descent with momentum in place of ADAM, but found that it led the advocacy networks to diverge. We split off $1 0 \\%$ of our training data to use as a validation set for early stopping. We cease training when validation loss fails to improve over 10 epochs. Model performance is reported on the canonical test splits for each dataset. We regularize the attention maps by adding a penalty proportional to the L1-norm of the map to encourage sparsity consistent with common notions of attention. Parameters were initialized using the default PyTorch method. All code and data used to produce our experiments will be made publicly available after review to allow for replication and extensions. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c990eb6d58bfdc89122c99415476c49cfd3c4eee628ee70d5429d4e603c01fc8.jpg",
+        "table_caption": [
+            "Table 1: Accuracy ( $\\pm$ standard deviation over 5 random seeds) on the datasets between the various models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Dataset</td></tr><tr><td>Model</td><td>MNIST</td><td>FMNIST</td></tr><tr><td>Random Net</td><td>99.16±0.08</td><td>88.69±0.72</td></tr><tr><td>Attention Net</td><td>99.16±0.30</td><td>89.71±0.86</td></tr><tr><td>Multi-Attention Net</td><td>99.33±0.09</td><td>90.11±0.40</td></tr><tr><td>Honest Advocacy Net</td><td>99.32±0.08</td><td>90.81±0.34</td></tr><tr><td>Advocacy Net</td><td>99.42±0.05</td><td>91.62±0.41</td></tr></table>",
+        "bbox": [
+            312,
+            141,
+            681,
+            258
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Results and Discussion ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            282,
+            434,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We present our main result: the performance of advocacy learning across two image datasets. We then present experiments that examine the impact of advocacy learning and the properties of advocacy networks. ",
+        "bbox": [
+            174,
+            303,
+            823,
+            344
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Advocacy Learning on Multi-Class Balanced Image Data We begin by examining the performance of our advocacy net variants and baselines on two publicly available image classification datasets: MNIST and Fashion-MNIST (Xiao et al., 2017). The Advocate modules are not optimized to improve classification performance, and their optimization could plausibly lead to a reduction in performance (by learning to deceive the Judge). However, we find across a range of datasets that this is not the case. Our results are presented in Table 1. On these datasets, advocacy learning does as well as or outperforms all baselines. The improvement is most pronounced in Fashion-MNIST, perhaps due to the denser images or the larger available room for improvement. Moreover, we find that this difference is not solely attributable to the class-conditional nature of the attention-maps, as in all datasets the advocacy nets outperform the honest advocacy nets. This suggests that deception, in addition to competition, can help produce high-quality attention maps. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Impact of Class Conditional Attention ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            545,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Results in Table 1 demonstrate that class-conditional attention, or arguments, can improve upon supervised attention maps. We observe that honest advocacy nets perform similarly to multi-attention nets on MNIST, and slightly better on FMNIST. The only difference between these architectures is that the honest Advocates receive fewer gradient updates than the attention modules per epoch, in a way that makes them class specific. The competition introduced by advocacy nets further improves performance, outperforming the multi-attention net on both datasets. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To get a closer look at how advocacy learning compares with the end-to-end supervised baselines, we plot the averaged difference between the confusion matrices of the multi-attention nets (MA) and advocacy nets (Adv) Figure 2. Overall, we observe that advocacy nets result in improvements for a subset of class pairs (e.g., classes 4 and 9), but leave the majority of predictions unchanged. On MNIST (Figure 2a), we find a few examples where advocacy learning lowers performance. In particular, the advocacy net is more likely to misclassify 8s as 9s; though the reverse error (9s as 8s) does not increase. This is likely due to the asymmetric morphological relationship between the digits: an 8 can be obscured to look like a 9, but the converse is less likely. It appears to help emphasize curves in the input (reducing the instances with 9 classified as 4 or 7 classified as 9). On Fashion-MNIST (Figure 2b) we observe that certain class pairs (pullovers or coats v.s. shirts) are markedly improved, while most others are unaffected. This evidence suggests that advocacy learning most improves performance by distinguishing among classes with similar morphology, though this analysis is confounded by the fact that it tends to be those class pairs that have the greatest potential room for improvement. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Qualitative examples of attention maps from the honest Advocate and multi-attention network are given in Figure 3. We found honest advocacy nets gave denser (and thus more interpretable) attention maps than advocacy nets. We observe that both honest advocacy nets and multi-attention nets generate a variety of attention maps with checkering characteristic of deconvolutional layers (Odena et al., 2016). An interesting example of class-conditional behavior is shown by the advocate for class 1. This Advocate, representing the \"pants\" class, emphasizes the sides of the shirt, similar to pants legs. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/321050de97e5488edd90002e852c1bd2912952e53caaa22fe239f5505a1a15ba.jpg",
+        "image_caption": [
+            "Figure 2: Averaged difference across five runs in confusion matrices between the multi-attention and advocacy networks ( $\\geq 0$ means the Advocacy net performed better) on a) MNIST and b) FMNIST. We zero out the diagonal elements to focus on misclassification. A positive number means the multi-attention net made more misclassifications than the advocacy net and vice-versa. We observe the advocacy net tends to improve performance across classes, but can make certain morphologically similar examples (i.e., 8 vs 9 in a) more difficult. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            108,
+            741,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f444d7207299b84553d286cbdd1d21c33a367933f10aa550acb1f135bac2ead8.jpg",
+        "image_caption": [
+            "Figure 3: Evidence generated from a Fashion-MNIST example. The top row shows a sample from the class the column represents. The second row shows evidence generated by the multi-attention net (the ordering is arbitrary), the bottom row shows evidence from an honest Advocate network (the order corresponds to class). The image is an example of class 6 (shirts). Of particular note is the argument generated by the Advocate for class 1 (pants). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            353,
+            754,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/5d132ff8166f259dcaf1913f71003233c784e5e7c09dfc609a579bcca553933c.jpg",
+        "image_caption": [
+            "Figure 4: a) A heatmap showing effect of varying Judge and Advocate capacity (in terms of residual blocks: high $\\#$ means high capacity) for an advocacy net on MNIST. b-c) The two general trends seen over the heatmap. In (b) we see that performance decreases as we increase Advocate capacity, in (c) we see that performance increases as we increase Judge capacity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            556,
+            799,
+            675
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            768,
+            825,
+            811
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Impact of Advocate and Judge Capacity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            549,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the Advocates try to deceive the Judge, a natural question is how the relative capacity of these components impacts performance. To answer this question, we look a variation of our advocacy net where we can easily vary the capacity of different pieces. We replace the convolutional layers in the Advocate encoder and Judge with some number of convolutional residual blocks. By changing the number of blocks, we can increase or decrease the capacity of the Advocate or ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/9e10d957f555f87782178cd2bb6d579e93fab6fb7ea5e50b39bec36c2174ded5.jpg",
+        "table_caption": [
+            "Table 2: Accuracy ( $\\pm$ standard deviation over 5 random seeds, this is not a confidence interval) on the modified MNIST datasets between the various models. The MIMIC results are reported in terms of AUPR. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Dataset</td></tr><tr><td>Model</td><td>MIMIC</td><td>Imbalanced MNIST</td><td>Binary MNIST</td></tr><tr><td>Random Net</td><td>39.26±1.51</td><td>99.02±0.08</td><td>98.58±1.35</td></tr><tr><td>Attention Net</td><td>45.79±1.80</td><td>98.68±0.48</td><td>99.23±0.22</td></tr><tr><td>Multi-Attention Net</td><td>45.74±1.71</td><td>99.00±0.13</td><td>99.32±0.14</td></tr><tr><td>Honest Advocacy Net</td><td>46.34±1.73</td><td>99.17±0.06</td><td>99.31±0.13</td></tr><tr><td>Advocacy Net</td><td>39.03±4.58</td><td>99.17±0.14</td><td>98.72±0.58</td></tr></table>",
+        "bbox": [
+            230,
+            154,
+            764,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Judge. Details of this modification are given in Appendix A. We observe that the advocacy net performs best when Judge capacity is high and Advocate capacity is low. Our best result from Figure 4a is slightly higher than our best MNIST result in Table 1 ( $9 9 . 4 6 \\%$ v.s. $9 9 . 4 2 \\%$ ). We performed an identical architecture search with the multi-attention net, there was no capacity setting that beat the best results attained by the advocacy net (best $9 9 . 3 4 \\%$ v.s. $9 9 . 4 6 \\%$ ). ",
+        "bbox": [
+            173,
+            285,
+            825,
+            356
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 Competition and Deception ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            444,
+            387
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the tasks considered above, it is somewhat surprising that advocacy nets outperform honest advocacy nets. Both incorporate class-conditional attention maps that compete to influence the Judge. The fact that advocacy nets, which are trained to actively deceive the Judge, do better suggests that such deception may play a useful role in learning. ",
+        "bbox": [
+            176,
+            388,
+            823,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To better understand the potential strength of the deception, we examined the effect of freezing the Judge while continuing to update the Advocates for both advocate and honest advocate nets. We found that training without the Judge did not affect network performance in the honest advocate net, but decreased performance in the advocate net by $8 5 \\%$ . Thus it is clear that adaptations by the Judge play a crucial role in maintaining advocate net accuracy. ",
+        "bbox": [
+            174,
+            449,
+            823,
+            520
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Up to this point, we have considered only advocacy networks in which all Advocates share an encoder. Such an architecture could encourage implicit sharing of information, possibly tempering the negative effects of deception. To test this hypothesis, we evaluated an advocacy net without a shared encoder on MNIST and FMNIST. On both datasets (averaged across 5 runs), we found that the advocacy network without a shared encoder achieved lower performance both in absolute terms and relative to an honest advocacy network without a shared encoder (98.29 v.s. 99.05 for MNIST, 86.47 v.s. 89.29 for FMIST). This suggests the shared encoder is an important way for Advocates to share information. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results presented so far all involve multi-class image datasets with balanced classes. To explore how these assumptions change the impact of deception in competition, we applied advocacy learning to a large electronic health record (EHR) dataset, MIMIC III (Johnson et al., 2016). This dataset, the largest publicly available repository of EHR data, has become an important benchmark in the machine learning for health community (Harutyunyan et al., 2017), and is helping to drive advances in precision health (Desautels et al., 2016; Maslove et al., 2017; Oh et al., 2018). We used the clinical time-series subset of the database for mortality prediction, as in Harutyunyan et al. (2017). We also considered variants of MNIST that break the multi-class and balanced assumptions. These additional experiments test the generalizability of our findings to i) different data types (time series as opposed to images), ii) imbalanced classes, and iii) binary labels. Our results are presented in Table 2. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We report our results on MIMIC in terms of the area under the precision recall curve (AUPR), since the task is binary with considerable class imbalance in the test set. We find that honest advocacy learning continues to provide benefits relative to the baselines, though the differences are small. Notably, in this task advocacy learning performs slightly worse than the random attention, while honest advocacy learning outperforms the fully supervised system. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This reversal of the results from Table 1 is interesting, and helps illuminate cases where advocacy learning may or may not work. There are many differences between MIMIC and MNIST/FMNIST which may explain why advocacy learning fails. Two of the major differences, besides the data type, are the imbalanced classes and the number of classes. To see the isolated effect of these changes, we created two modified versions of MNIST. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the first modified MNIST, Imbalanced MNIST, we subsampled the training set, introducing class imbalance. After subsampling, the least represented class, 0, had 600 training samples, and each successive class had 600 additional samples. The test set remained unchanged, which is why we report results in accuracy. We found that class imbalance lowered the performance of all models by $0 . 1 \\mathrm { - } 0 . 3 \\%$ ; the Advocate net was more strongly affected than the honest Advocate net. However, both models wind up with very similar accuracy (advocacy learning 99.17±0.14 vs. honest advocacy learning 99.17 $\\pm$ 0.06). ",
+        "bbox": [
+            174,
+            138,
+            823,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the second modification, we created Binary MNIST, a variant with only two classes: 4 and 9. The per-class number of examples in the training and test set were unchanged. We found that the switch to a binary formulation reduced absolute performance for the advocacy network by $0 . 7 \\%$ , a sizable decrease for MNIST for what should be an easier problem. We did not observe similar decreases with either the honest advocate net or the multi-attention net. This decrease suggests that, in practice, the competition between many advocates helps the Judge achieve good performance in the presence of deception. In all datasets considered, the class-conditional attention provided by honest advocacy learning did not hurt, and in the presence of imbalanced data helped, performance relative to the supervised baseline. This suggests the value of competition in training, with or without deception. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 Intuition for Advocates ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            430,
+            418,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The fundamental idea of this work: advocate modules that compete with one another instead of cooperating, is counter-intuitive from a performance perspective. The fact that this training scheme works at all, let alone better than the baselines in several datasets, is quite surprising. However, there are reasons other than the empirically demonstrated performance to suggest that such a training approach could work. Honest Advocates are similar to a Mixture-of-Experts model, and such models have a long and rich history (Yuksel et al., 2012). As for vanilla Advocates, their original motivation was to introduce competition into the training of a neural network. In economic theory, competition plays a vital role in efficiently allocating resources, leading to better functioning systems (Godfrey, 2008). In machine learning, the notion of competition has been found useful as an adaptive loss function for image generation (Goodfellow et al., 2014) and self-competition was used to surpass professional Go players (Silver et al., 2017). While these systems used competition between networks during training, competition within a network has been used as well. A winner-take-all competitive framework was found to lead to superior semi-supervised image classification performance (Makhzani and Frey, 2015), and the dynamic routing used in Capsule Networks can been seen as type of competition (Sabour et al., 2017). ",
+        "bbox": [
+            174,
+            468,
+            825,
+            693
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The field of multi-objective optimization also gives evidence that advocacy learning could plausibly be expected to work. A well known result from that field is that multiple gradient descent, a form of gradient descent applied against multiple (possibly contradicting) objective functions, achieves a Pareto equilibrium, or a setting where no objective can be improved without damaging the performance of a different objective (Désidéri, 2014). Viewed through this lens, advocacy learning may be expected to work because of the asymmetry in the objective functions for the advocates vs. the judge. Over a batch of data, each advocate is neutral to the ordering of class assignments, as the objective depends solely on the number of class labels which it is assigned. However, the Judge is highly sensitive to this ordering, as its objective function requires classes to be properly labeled. Thus, over the optimization procedure we might expect predictions for misclassified examples to change, as the advocates are neutral to this, but we would expect the predictions for correctly classified examples to remain constant as the judge is sensitive to this. As a result, over the optimization procedure we expect the performance to increase, converging at perfect training performance. Of course, our use of standard gradient descent (using ADAM) and the non-convexity of the loss function complicates this analysis, but such complications are not unusual in the analysis of neural networks. This provides some theoretical backing to the empirical success of advocacy learning. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            934
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            351,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our proposed advocacy learning setup, in which the Advocates are trained to consistently argue for their particular class in order to convince a Judge, is related to several different ideas proposed in recent years. These include 1) mixture-of-experts, 2) generative adversarial networks and 3) debate agents. Here, we review each of these in turn, highlighting relevant similarities and differences with our proposed approach. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            195
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Others have considered transformations of the input in the context of improving classification. Parascandolo et al. (2018) proposed the use of a mixture-of-experts model to learn inverse data transforms, such as denoising, to improve performance. These transforms are similar in nature to the attention maps generated by our fully supervised baselines, and the competition between experts resembles our Advocate-Advocate relationships. Our work differs in the nature of our Advocate loss (unsupervised), the goal of the Advocates (convincing the Judge of a particular class), and the manner in which Advocates specialize (our Advocates are assigned particular classes to represent). ",
+        "bbox": [
+            174,
+            202,
+            825,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Advocacy learning consists of Advocate-Advocate relationships and Advocate-Judge relationships. In standard neural networks, all relationships are cooperative. I.e., all parts of the network are trained to accomplish the same goal. Adversarial relationships, or situations where the submodules compete with one another, have recently garnered interest (Durugkar et al., 2016; Goodfellow et al., 2014; Ghosh et al., 2017). Within a generative adversarial network framework, researchers have examined multiple discriminators (Durugkar et al., 2016) and multiple generators (Ghosh et al., 2017). In the multi-generator setting, each generator is encouraged to capture distinct portions of the class distribution. This bears a resemblance to the way in which each of our advocates captures relevant evidence in favor of its corresponding class. However, in contrast to GANs, advocacy learning focuses discrimination, not generation. Moreover, the Advocate-Judge relationship is neither entirely cooperative (the Advocate may argue for an untrue class) nor entirely adversarial (the Advocate may argue for a true class). ",
+        "bbox": [
+            174,
+            319,
+            825,
+            487
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Concurrent work sets up a similar task to our own, training agents to ‘debate’ in order to convince a Judge about the class associated with an input (Irving et al., 2018). The authors use MonteCarlo tree search to simulate a debate with the goal of identifying a series of pixels to convince a pre-trained Judge classifier of an input example’s class. While conceptually similar to advocacy learning, our work differs in motivation and methodologically. In addition to considering a different learning framework: neural networks, vs. Monte-Carlo tree search, there are two key differences in problem formulation: 1) our work is geared towards jointly learning Judges and Advocates, instead of learning debaters that convince a separately trained (or human) Judge, and 2) our work involves Advocates, not debaters, the distinction is that the debaters choose what they will argue for and are awarded based on relative performance, whereas Advocates are forced to argue for particular outcomes and are rewarded only insofar as those outcomes are realized. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            320,
+            678
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented a novel approach to supervised classification: advocacy learning. Our approach divides a network into two sub-networks: i) a set of Advocates trained to provide arguments supporting their corresponding class, and ii) a Judge that uses these arguments to predict the true class. These sub-networks differ not only in their goals, but also in how they are trained. Over a series of experiments on three publicly available datasets, we showed that class-condition attention can improve performance relative to standard attention. These results were particularly notable in a multi-class setting. Despite the lack of supervision, Advocates can effectively compete to generate higher quality evidence, though this effect was largely localized to a few class-pairs (e.g. shirts v.s. pullovers). Moreover, by varying the network architecture (e.g., by changing the capacity and or by increasing the amount of weight sharing), one can tradeoff deception, competition, and cooperation of the various subnetworks. Extensions may consider further improving this balance, by controlling the ratio of honest and deceptive updates, or the ratio of class-specific updates. A limitation of this architecture is the one-to-one relationship between the number of classes and number of advocates, which makes training on datasets like ImageNet implausible. Future work could examine methods to remove this linear relationship, such as training advocates that work across class hierarchies. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            906
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            290,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "V. Badrinarayanan, A. Kendall, and R. Cipolla. Segnet: A deep convolutional encoder-decoder architecture for image segmentation. IEEE transactions on pattern analysis and machine intelligence, 39(12):2481–2495, 2017. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T. Desautels, J. Calvert, J. Hoffman, M. Jay, Y. Kerem, L. Shieh, D. Shimabukuro, U. Chettipally, M. D. Feldman, C. Barton, D. J. Wales, and R. Das. Prediction of Sepsis in the Intensive Care Unit With Minimal Electronic Health Record Data: A Machine Learning Approach. JMIR Medical Informatics, 4(3), Sept. 2016. ISSN 2291-9694. doi: 10.2196/medinform.5909. URL https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5065680/. ",
+        "bbox": [
+            176,
+            178,
+            825,
+            250
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "I. Durugkar, I. Gemp, and S. Mahadevan. Generative Multi-Adversarial Networks. arXiv:1611.01673 [cs], Nov. 2016. URL http://arxiv.org/abs/1611.01673. arXiv: 1611.01673. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            303
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J.-A. Désidéri. Multiple-gradient Descent Algorithm for Pareto-Front Identification. In W. Fitzgibbon, Y. A. Kuznetsov, P. Neittaanmäki, and O. Pironneau, editors, Modeling, Simulation and Optimization for Science and Technology, Computational Methods in Applied Sciences, pages 41–58. Springer Netherlands, Dordrecht, 2014. ISBN 978-94-017-9054-3. doi: 10.1007/978-94-017-9054-3_3. URL https://doi.org/10.1007/978-94-017-9054-3_3. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Ghosh, V. Kulharia, V. Namboodiri, P. H. Torr, and P. K. Dokania. Multi-agent diverse generative adversarial networks. arXiv preprint arXiv:1704.02906, 2017. ",
+        "bbox": [
+            169,
+            392,
+            823,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "N. Godfrey. WHY IS COMPETITION IMPORTANT FOR GROWTH AND POVERTY REDUCTION? page 12, 2008. ",
+        "bbox": [
+            173,
+            431,
+            820,
+            463
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            472,
+            823,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H. Harutyunyan, H. Khachatrian, D. C. Kale, and A. Galstyan. Multitask Learning and Benchmarking with Clinical Time Series Data. arXiv:1703.07771 [cs, stat], Mar. 2017. URL http://arxiv.org/abs/1703.07771. arXiv: 1703.07771. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            569
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015. ",
+        "bbox": [
+            171,
+            578,
+            823,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G. Irving, P. Christiano, and D. Amodei. AI safety via debate. arXiv:1805.00899 [cs, stat], May 2018. URL http://arxiv.org/abs/1805.00899. arXiv: 1805.00899. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "L. Itti, C. Koch, and E. Niebur. A model of saliency-based visual attention for rapid scene analysis. IEEE Transactions on Pattern Analysis and Machine Intelligence, 20(11): 1254–1259, Nov. 1998. ISSN 0162-8828. doi: 10.1109/34.730558. ",
+        "bbox": [
+            176,
+            656,
+            823,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. E. Johnson, T. J. Pollard, L. Shen, H. L. Li-wei, M. Feng, M. Ghassemi, B. Moody, P. Szolovits, L. A. Celi, and R. G. Mark. MIMIC-III, a freely accessible critical care database. Scientific data, 3:160035, 2016. ",
+        "bbox": [
+            176,
+            709,
+            823,
+            753
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Makhzani and B. J. Frey. Winner-take-all autoencoders. In Advances in Neural Information Processing Systems, pages 2791–2799, 2015. ",
+        "bbox": [
+            168,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "D. M. Maslove, F. Lamontagne, J. C. Marshall, and D. K. Heyland. A path to precision in the ICU. Critical Care, 21(1):79, Apr. 2017. ISSN 1364-8535. doi: 10.1186/s13054-017-1653-x. URL https://doi.org/10.1186/s13054-017-1653-x. ",
+        "bbox": [
+            176,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Odena, V. Dumoulin, and C. Olah. Deconvolution and checkerboard artifacts. Distill, 2016. doi: 10.23915/distill.00003. URL http://distill.pub/2016/deconv-checkerboard. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Oh, J. Wang, and J. Wiens. Learning to Exploit Invariances in Clinical Time-Series Data using Sequence Transformer Networks. arXiv preprint arXiv:1808.06725, 2018.   \nG. Parascandolo, N. Kilbertus, M. Rojas-Carulla, and B. Schölkopf. Learning Independent Causal Mechanisms. In International Conference on Machine Learning, pages 4036–4044, July 2018. URL http://proceedings.mlr.press/v80/parascandolo18a.html.   \nA. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.   \nM. T. Ribeiro, S. Singh, and C. Guestrin. Model-agnostic interpretability of machine learning. arXiv preprint arXiv:1606.05386, 2016.   \nO. Ronneberger, P. Fischer, and T. Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pages 234–241. Springer, 2015.   \nS. Sabour, N. Frosst, and G. E. Hinton. Dynamic routing between capsules. In Advances in Neural Information Processing Systems, pages 3856–3866, 2017.   \nD. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T. Hubert, L. Baker, M. Lai, A. Bolton, Y. Chen, T. Lillicrap, F. Hui, L. Sifre, G. van den Driessche, T. Graepel, and D. Hassabis. Mastering the game of Go without human knowledge. Nature, 550(7676):354–359, Oct. 2017. ISSN 0028-0836. doi: 10.1038/nature24270. URL https://www.nature.com/nature/journal/v550/n7676/full/nature24270.html.   \nN. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.   \nA. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention Is All You Need. arXiv:1706.03762 [cs], June 2017. URL http://arxiv.org/abs/1706.03762. arXiv: 1706.03762.   \nH. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. arXiv:1708.07747 [cs, stat], Aug. 2017. URL http://arxiv.org/abs/1708.07747. arXiv: 1708.07747.   \nS. E. Yuksel, J. N. Wilson, and P. D. Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   \nQ. Zhang, Y. N. Wu, and S.-C. Zhu. Interpretable convolutional neural networks. arXiv preprint arXiv:1710.00935, 2(3):5, 2017. ",
+        "bbox": [
+            169,
+            87,
+            828,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A Network Architecture ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            102,
+            446,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We provide the specific architecture used for our Judge and Advocate Module on the image and MIMIC experiments. Other implementation details are found in the main paper. ",
+        "bbox": [
+            173,
+            132,
+            823,
+            161
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/451a0a35b2c3e477e269655e3fda2a766e0f3db0fed186c509e2dbdb945a125b.jpg",
+        "table_caption": [
+            "Table 3: The Judge network for Image data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features</td><td></td></tr><tr><td>Conv1</td><td>32x3x3 Convolution 32 Channel 2d BatchNorm</td></tr><tr><td>Conv2</td><td>ReLU 32x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x3x3 Convolution 64 Channel 2d BatchNorm</td></tr><tr><td>Conv4</td><td>ReLU 64x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Output</td><td>2x2 Max Pool</td></tr><tr><td>FC1</td><td>512 node Linear layer 512 Channel1d BatchNorm ReLU</td></tr><tr><td>Out</td><td>Dropout(p=0.2) Linear Output</td></tr></table>",
+        "bbox": [
+            318,
+            200,
+            678,
+            522
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/98280076524e3287d94d5ab2b88f3545f6732542a0cf5c395e7fb244637e9360.jpg",
+        "table_caption": [
+            "Table 4: The Advocate Module for Image data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Encoder</td><td></td></tr><tr><td>Conv1</td><td>32x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv2</td><td>32x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x3x3 Convolution 64 Channel 2d BatchNorm ReLU</td></tr><tr><td>Conv4</td><td>64x3x3 Convolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Decoder</td><td>2x2 Max Pool</td></tr><tr><td>Deconv1</td><td>32x3x3 Stride-1 Deconvolution 32 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv2</td><td>16x2x2 Stride-2 Deconvolution 16 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv3</td><td>8x2x2 Stride-2 Deconvolution 8 Channel 2d BatchNorm ReLU</td></tr><tr><td>Deconv4</td><td>4x5x5 Stride-1 Deconvolution 4 Channel 2dBatchNorm</td></tr><tr><td>Output</td><td>ReLU 2x3x3 Convolution with Padding=1 2 channel 2d BatchNorm 1xlx1 Convolution</td></tr></table>",
+        "bbox": [
+            321,
+            150,
+            679,
+            613
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b9e56835d4dce76e062a964bb8b19d1ef42c77d837910a3e550008fc71b057cb.jpg",
+        "table_caption": [
+            "Table 5: The residual blocks in the variable capacity Judge and Advocate components. Both blocks are repeated $n$ times where $n$ is the number of residual blocks for the network. Max pooling is done after each block. Three additional 2x2 convolutions are performed before the output. In the Advocate encoder, this output is given to the decoder. In the Judge, the output is given to the fully connected layers. In both cases, the architecture remains unchanged from the non-residual verison. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features</td><td></td></tr><tr><td>Block1</td><td>32x3x3 Convolution with padding 1 32 Channel 2d BatchNorm</td></tr><tr><td>Block2</td><td>ReLU 32x3x3 Convolution 64 Channel 2d BatchNorm</td></tr></table>",
+        "bbox": [
+            294,
+            767,
+            702,
+            895
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/75fc5e157d1b74249c1c0287a185f7922875404fb991aeec9bdf402299438f97.jpg",
+        "table_caption": [
+            "Table 6: The Judge network for MIMIC III. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Conv Features Conv1</td><td>64x3 1D Convolution</td></tr><tr><td></td><td>64 Channel 1D BatchNorm ReLU 2-width 1D Max Pool</td></tr><tr><td>Conv2</td><td>64x31D Convolution 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>FC1</td><td>2-width 1D Max Pool 64 node Linear layer 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>Out</td><td>Dropout(p=0.2) Linear Output</td></tr></table>",
+        "bbox": [
+            321,
+            142,
+            676,
+            367
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/1c1d56460c67d8c3bd9d503d58d25da0f5d8d60bbfda147fcd3b7f731c25bf82.jpg",
+        "table_caption": [
+            "Table 7: The Advocate Module for MIMIC. Note the final convolution has a number of layers equal to the input channel size, which for the MIMIC III benchmark is 76. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td></tr><tr><td>Encoder</td><td></td></tr><tr><td>Conv1</td><td>32x3 1D Convolution 32 Channel !d BatchNorm</td></tr><tr><td>Conv2</td><td>ReLU 32x3 1D Convolution 32 Channel 1d BatchNorm ReLU</td></tr><tr><td>Conv3</td><td>2x2 Max Pool 64x31D Convolution 64 Channel 1d BatchNorm ReLU</td></tr><tr><td>Conv4</td><td>64x31D Convolution 64 Channel 2dBatchNorm ReLU</td></tr><tr><td>Decoder</td><td>2x2 Max Pool</td></tr><tr><td>Deconv1</td><td>32x3 Stride-1 1D Deconvolution 32 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv2</td><td>32x2 Stride-2 1D Deconvolution 32 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv3</td><td>64x2 Stride-2 1D Deconvolution 64 Channel 1D BatchNorm ReLU</td></tr><tr><td>Deconv4</td><td>64x5 Stride-1 1D Deconvolution 64 Channel1d BatchNorm ReLU</td></tr><tr><td>Output</td><td>64x3 1D Convolution with Padding=1 64 channel 1D BatchNorm Nx1 1D Convolution</td></tr></table>",
+        "bbox": [
+            313,
+            444,
+            684,
+            906
+        ],
+        "page_idx": 13
+    }
+]

parse/train/ByxAcjCqt7/ByxAcjCqt7.md

@@ -0,0 +1,456 @@
+# POINT CLOUD GAN
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Generative Adversarial Networks (GAN) can achieve promising performance on learning complex data distributions on different types of data. In this paper, we first show that a straightforward extension of an existing GAN algorithm is not applicable to point clouds, because the constraint required for discriminators is undefined for set data. We propose a two fold modification to a GAN algorithm to be able to generate point clouds (PC-GAN). First, we combine ideas from hierarchical Bayesian modeling and implicit generative models by learning a hierarchical and interpretable sampling process. A key component of our method is that we train a posterior inference network for the hidden variables. Second, PC-GAN defines a generic framework that can incorporate many existing GAN algorithms. We further propose a sandwiching objective, which results in a tighter Wasserstein distance estimate than the commonly used dual form in WGAN. We validate our claims on the ModelNet40 benchmark dataset and observe that PCGAN trained by the sandwiching objective achieves better results on test data than existing methods. We also conduct studies on several tasks, including generalization on unseen point clouds, latent space interpolation, classification, and image to point clouds transformation, to demonstrate the versatility of the proposed PC-GAN algorithm.
+
+# 1 INTRODUCTION
+
+A fundamental problem in machine learning is that given a data set, learn a generative model that can efficiently generate arbitrary many new sample points from the domain of the underlying distribution (Bishop, 2006). Deep generative models use deep neural networks as a tool for learning complex data distributions (Kingma & Welling, 2013; Oord et al., 2016; Goodfellow et al., 2014). Especially, Generative Adversarial Networks (GAN) (Goodfellow et al., 2014) has drawn attention because of its success in many applications. Compelling results have been demonstrated on different types of data, including text, images, and videos (Lamb et al., 2016; Karras et al., 2017; Vondrick et al., 2016). Their wide range of applicability was also shown in many important problems, including data augmentation (Salimans et al., 2016), image style transformation (Zhu et al., 2017), image captioning (Dai et al., 2017), and art creations (Kang, 2017).
+
+Recently, capturing 3D information is garnering attention. There are many different data types for 3D information, such as CAD, 3D meshes, and point clouds. 3D point clouds are getting popular since these store more information than 2D images and sensors capable of collecting point clouds have become more accessible. These include Lidar on self-driving cars, Kinect for Xbox, and face identification sensor on phones. Compared to other formats, point clouds can be easily represented as a set of points, which has several advantages, such as permutation invariance of the set members. The algorithms which can effectively learn from this type of data is an emerging field (Qi et al., 2017a;b; Zaheer et al., 2017; Kalogerakis et al., 2017; Fan et al., 2017). However, compared to supervised learning, unsupervised generative models for 3D data are still under explored (Achlioptas et al., 2017; Oliva et al., 2018).
+
+Extending existing GAN frameworks to point clouds or more generally set data is not straightforward. In this paper, we begin by formally defining the problem and discussing its difficulty (Section 2). Circumventing the challenges, we propose a deep generative adversarial network (PC-GAN) with a hierarchical sampling and inference network for point clouds. The proposed architecture learns a stochastic procedure which can generate new point clouds and draw samples from the generated point clouds without explicitly modeling the underlying density function (Section 3). The proposed PC-GAN is a generic algorithm which can incorporate many existing GAN variants. By utilizing the property of point clouds, we further propose a sandwiching objective by considering both upper and lower bounds of Wasserstein distance estimate, which can lead to tighter approximation (Section 3.1). Evaluation on ModelNet40 shows excellent generalization capability of PC-GAN. We first demonstrate that we can sample from the learned model to generate new point clouds and the latent representations learned by the inference network provide meaningful interpolations between point clouds. Then we show the conditional generation results on unseen classes of objects, which demonstrates the superior generalization ability of PC-GAN. Lastly, we also provide several interesting studies, such as classification and point clouds generation from images (Section 5).
+
+# 2 PROBLEM DEFINITION AND DIFFICULTY
+
+A point cloud for an object $\theta$ is a set of $n$ low dimensional vectors $X = \{ x _ { 1 } , . . . , x _ { n } \}$ with $x _ { i } \in \mathbb { R } ^ { d }$ , where $d$ is usually 3 and $n$ can be infinite. $M$ different objects can be described as a collection of point clouds $X ^ { ( 1 ) } , . . . , X ^ { ( M ) }$ . A generative model for sets should be able to: (1) Sample entirely new sets according to $p ( X )$ , and (2) sample arbitrarily many more points from the distribution of given set, i.e. $x \sim p ( x | X )$ .
+
+Based on the De-Finetti theorem, we could factor the probability with some suitably defined $\theta$ , such as object representation of point clouds, as $\begin{array} { r c l } { p ( X ) } & { = } & { \int _ { \theta } \prod _ { i = 1 } ^ { n } p ( x _ { i } | \theta ) p \bar { ( \theta ) } d \theta } \end{array}$ In this view, the factoring can be understood as follows:
+
+Given an object, $\theta$ , the points $x _ { i }$ in the point cloud can be considered as i.i.d. samples from $p ( x | \theta )$ , an unknown latent distribution representing object $\theta$ . Joint likelihood can be expressed as:
+
+$$
+p ( X , \theta ) = \underbrace { p ( \theta ) } _ { \mathrm { o b j e c t } } \quad \underbrace { \prod _ { i = 1 } ^ { n } p ( x _ { i } | \theta ) } _ { \mathrm { p o i n t s f o r o b j e c t } }
+$$
+
+![](images/107d2ecd3f79d89888e8b47a206f5cb4fd123176e52315b868c6529154626574.jpg)  
+Figure 1: Natural extension of GAN to handle set data does not work.
+
+$\{ \{ x _ { i } ^ { ( 1 ) } \} _ { i = 1 } ^ { n } , \ldots , \{ x _ { i } ^ { ( m ) } \} _ { i = 1 } ^ { n } \}$ d to model the distribution of the point cloud set together, i.e.,. In this setting, a naíve application of traditional GAN is possible points (reducing the problem to instances in $\mathbb { R } ^ { n \times 3 }$ ) with DeepSets (Zaheer et al., 2017) classifier as the discriminator to distinguish real sets from fake sets. However, this approach would not work in practice because the integral probability metric (IPM) guarantees behind the traditional GAN no longer hold (e.g. in case of Arjovsky et al. (2017), nor are 1-Lipschitz functions over sets welldefined). The probabilistic divergence approximated by a DeepSets classifier might be ill-defined. Counter examples for breaking IPM guarantees can be easily found as we show next.
+
+Counter Example Consider a simple GAN (Goodfellow et al., 2014) with a DeepSets classifier as the discriminator. In order to generate coherent sets of variable size, we consider a generator $G$ having two noise sources: $u$ and $z _ { i }$ . To generate a set, $u$ is sampled once and $z _ { i }$ is sampled for $i = 1 , 2 , . . . , n$ to produce $n$ points in the generated set. Intuitively, fixing the first noise source $u$ selects a set and ensures the points generated by repeated sampling of $z _ { i }$ are coherent and belong to the same set. The setup is depicted in Figure 1. In this setup, the GAN minimax problem would be:
+
+$$
+\operatorname* { m i n } _ { G } \operatorname* { m a x } _ { D } \ \underset { \theta \sim p ( \theta ) } { \mathbb { E } } \ \left[ \log D \left( \{ x _ { i } \} \right) \right] \ + \ \underset { \stackrel { u \sim p ( u ) } { z _ { i } \sim p ( z _ { i } ) } } { \mathbb { E } } \ \left[ \log \left( 1 - D \left( \{ G ( u , z _ { i } ) \} \right) \right) \right]
+$$
+
+Now consider the case, when there exists an ‘oracle’ mapping $T$ which maps each sample point deterministically to the object it originated from, i.e. $\exists T : { \bar { T } } ( \{ x _ { i } \} ) = \theta$ . A valid example is when different $\theta$ leads to conditional distribution $p ( x | \theta )$ with non-overlapping support. Let $\bar { D } = D ^ { \prime } \circ T$ and $G$ ignore $z$ , then the optimization task becomes as follows:
+
+$$
+\begin{array} { r l } & { \underset { G } { \mathrm { m i n } } \underset { D ^ { \prime } } { \mathrm { m a x } } \underset { \delta \sim p ( \theta ) } { \mathbb { E } } \ [ \log D ^ { \prime } ( T ( \{ x _ { i } \} ) ) ] + \underset { \varepsilon \sim p ( \varepsilon ) } { \mathbb { E } } \ [ \log \left( 1 - D ^ { \prime } ( T ( \{ G ( u , z _ { i } ) \} ) ) \right) ] } \\ & { \Rightarrow \underset { \varepsilon \sim p ( \varepsilon _ { i } ) } { \mathrm { m i n } } } \\ & { \Rightarrow \underset { G } { \mathrm { m i n } } \underset { D ^ { \prime } } { \mathrm { m a x } } \ \underset { \theta \sim p ( \theta ) } { \mathbb { E } } \ [ \log D ^ { \prime } ( \theta ) ] + \underset { \stackrel { u \sim p ( u ) } { \varepsilon \sim p ( \varepsilon ) } } { \mathbb { E } } \ [ \log \left( 1 - D ^ { \prime } ( T ( \{ G ( u ) \} ) ) \right) ] } \\ & { \underset { \stackrel { x _ { i } \sim p ( x _ { i } | \theta ) } { \Rightarrow } } { \mathrm { m i n } } } \\ & { \Rightarrow \underset { G } { \mathrm { m i n } } \underset { D ^ { \prime } } { \mathrm { m a x } } \ \underset { \theta \sim p ( \theta ) } { \mathbb { E } } \left[ \log D ^ { \prime } ( \theta ) \right] + \underset { u \sim p ( u ) } { \mathbb { E } } \ [ \log \left( 1 - D ^ { \prime } ( T ( \{ G ( u ) \} ) ) \right) ] } \end{array}
+$$
+
+Thus, we can achieve the lower bound $- \log ( 4 )$ by only matching the $p ( \theta )$ component, while the conditional $p ( x | \theta )$ is allowed to remain arbitrary. So simply using DeepSets classifier without any constraints in simple GAN in order to handle sets does not lead to a valid generative model.
+
+# 3 PROPOSED METHOD
+
+As described in Section 2, directly learning point cloud generation under GAN formulation is difficult. However, given $\theta$ , learning $p ( x | \theta )$ is a simpler task of learning a 3-dimensional distribution. Given two point clouds, one popular heuristic distance between them is the Chamfer distance (Achlioptas et al., 2017). On the other hand, if we treat each point cloud as a $^ 3$ -dimensional distribution, we can adopt a broader class of probabilistic divergences for comparing them. Instead of learning explicit densities (Jian & Vemuri, 2005; Strom et al., 2010; Eckart et al., 2015), we are interested in implicit generative models with a GAN-like objective (Goodfellow et al., 2014), which has been demonstrated to learn complicated distributions. Formally, given a $\theta$ , we train a generator $G _ { x } ( z , \theta )$ such that $x = G _ { x } ( z , \theta )$ , where $z \sim p ( z )$ . The generator $G _ { x } ^ { - } ( z , \theta )$ follows $\mathbb { G }$ by optimizing a probabilistic divergence $D ( \mathbb { P } | | \mathbb { G } )$ between the distribution $\mathbb { G }$ of $G _ { x } ( z , \theta )$ and $p ( x | \theta )$ , which is denoted as P. The full objective can be written as Eθ∼p(θ) $\mathbb { E } _ { \theta \sim p ( \theta ) } \left[ \operatorname* { m i n } _ { G _ { x } } D ( \mathbb { P } \| \mathbb { G } ) \right] .$ .
+
+![](images/94518484e5f8b38f7aa9d00703ce86c92ff8529ae76723fa51d2b6d0c07cfb38.jpg)  
+Figure 2: Overview of PC-GAN.
+
+Inference Although GANs have been extended to learn conditional distributions (Mirza & Osindero, 2014; Isola et al., 2017), they require conditioning variables to be observed, such as the one-hot label or a given image. Our $\theta$ , instead, is an unobserved latent variable for modeling different objects, which we need to infer during training. The proposed algorithm has to concurrently learn the inference network $Q ( X ) \approx \theta$ while we learn $p ( x { \bar { | \theta ) } }$ . Since $X$ is a set of points, we can adopt Qi et al. (2017a); Zaheer et al. (2017) for modeling $Q$ . We provide more discussion on this topic in the Appendix A.1.
+
+Hierarchical Sampling After training $G _ { x }$ and $Q$ , we use the trained $Q$ to collect the inferred $Q ( X )$ and train the generator $\mathbf { \boldsymbol { G } } _ { \theta } ( u ) \sim p ( \theta )$ for higher hierarchical sampling. Here $u \sim p ( u )$ is the other noise source independent of $z$ . In addition to layer-wise training, a joint training could further boost performance. The full generative process for sampling one point cloud could be represented as
+
+$\{ x _ { i } \} _ { i = 1 } ^ { n } = \{ G ( z _ { i } , u ) \} _ { i = 1 } ^ { n } = \{ G _ { x } ( z _ { i } , G _ { \theta } ( u ) ) \} _ { i = 1 } ^ { n }$ , where $z _ { 1 } , \dots , z _ { n } \sim p ( z )$ , and $u \sim p ( u )$ .
+
+The overview of proposed algorithm for point cloud generation (PC-GAN) is shown in Figure 2.
+
+# 3.1 DIFFERENT DIVERGENCES FOR MATCHING POINT CLOUDS
+
+To train the generator $G _ { x }$ using a GAN-like objective for point clouds, we need a discriminator $f ( \cdot )$ to distinguishes generated samples and true samples conditioned on $\theta$ . Combining with the inference network $\operatorname { \bar { Q } } ( X )$ discussed aforementioned, the objecitve with IPM-based GANs can be written as
+
+$$
+\mathbb { E } _ { \theta \sim p ( \theta ) } \bigg [ \operatorname* { m i n } _ { G _ { x } , Q } \underbrace { \operatorname* { m a x } _ { } \mathbb { E } _ { x \sim p ( X \mid \theta ) } \left[ f ( x ) \right] - \mathbb { E } _ { z \sim p ( z ) , X \sim p ( X \mid \theta ) } \left[ f ( G _ { x } ( z , Q ( X ) ) ) \right] } _ { D ( \mathbb { P } \| \mathbb { G } ) } \bigg ] ,
+$$
+
+where $\Omega _ { f }$ is the constraint for different probabilistic distances, such as 1-Lipschitz (Arjovsky et al., 2017), $L ^ { 2 }$ ball (Mroueh & Sercu, 2017) or Sobolev ball (Mroueh et al., 2017).
+
+# 3.2 TIGHTER SOLUTIONS VIA SANDWICHING
+
+In our setting, each point $x _ { i }$ in the point cloud can be considered to correspond to single images when we train GANs over images. An example is illustrated in Figure 3 where samples from MMD-GAN (Li et al., 2017a) trained on CelebA consists of both good and bad faces. In case of images, when quality is evaluated, it primarily focuses on coherence individual images and the few bad ones are usually left out. Whereas in case of point cloud, to get representation of an object we need many sampled points together and presence of outlier points degrades the quality of the object. Thus, when training a generative model for point cloud, we need to ensure a much lower distance $D ( \mathbb { P } | | \mathbb { G } )$ between true distribution $\mathbb { P }$ and generator distribution $\mathbb { G }$ than would be needed in case of images.
+
+We begin by noting that the popular Wasserstein GAN (Arjovsky et al., 2017), aims to optimize $G$ by min $w ( \mathbb { P } , \mathbb { G } )$ , where $w ( \mathbb { P } , \mathbb { G } )$ is the Wasserstein distance $w ( { \mathbb { P } } , \mathbb { G } )$ between the truth $\mathbb { P }$ and generated distribution $\mathbb { G }$ of $G$ Many GAN works (e.g. Arjovsky et al. (2017)) approximate $w ( \mathbb { P } , \mathbb { G } )$ in dual form (a maximization problem), such as (4), by neural networks. The resulting estimate $W _ { L } ( \mathbb { P } , \mathbb { G } )$ is a lower bound of the true Wasserstein distance, as neural networks can only recover a subset of 1-Lipschitz functions (Arora et al., 2017) required in the dual form. However, finding a lower bound $\bar { W } _ { L } ( \mathbb { P } , \mathbb { G } )$ for $w ( \mathbb { P } , \mathbb { G } )$ may not be an ideal surrogate for solving a minimization problem min $w ( \mathbb { P } , \mathbb { G } )$ . In optimal transport literature, Wassertein distance is usually estimated by approximate matching cost, $\bar { W } _ { U } ( \mathbb { P } , \mathbb { G } )$ , which gives us an upper bound of the true Wasserstein distance.
+
+![](images/555b6b4d212496107e43b6bde2bebad7aa1790178a5527e54293865483db67a6.jpg)  
+Figure 3: Connection between good/bad points and faces generated from a GAN.
+
+We propose to combine, in general, a lower bound $W _ { L }$ and upper bound estimate $W _ { U }$ by sandwiching the solution between the two, i.e. we solve the following minimization problem:
+
+$$
+\operatorname* { m i n } _ { G } \quad W _ { U } ( \mathbb { P } , \mathbb { G } ) \qquad \mathrm { s . t . } \quad W _ { U } ( \mathbb { P } , \mathbb { G } ) - W _ { L } ( \mathbb { P } , \mathbb { G } ) < \lambda
+$$
+
+The problem can be simplified and solved using method of lagrange multipliers as follows:
+
+$$
+\operatorname* { m i n } _ { G } W _ { s } ( \mathbb { P } , \mathbb { G } ) : = ( 1 - s ) W _ { U } ( \mathbb { P } , \mathbb { G } ) + s W _ { L } ( \mathbb { P } , \mathbb { G } )
+$$
+
+By solving the new sandwiched problem (6), we show that under certain conditions we obtain a better estimate of Wasserstein distance in the following lemma:
+
+Lemma 1. Suppose we have two approximators to Wasserstein distance: an upper bound $W _ { U }$ and a lower $W _ { L }$ , such that $\forall \mathbb { P } , \mathbb { G } : ( \bar { 1 } + \epsilon _ { 1 } ) w ( \mathbb { P } , \mathbb { G } ) \leq W _ { U } ( \mathbb { P } , \mathbb { G } ) \leq ( 1 + \epsilon _ { 2 } ) \bar { w } ( \mathbb { P } , \mathbb { G } )$ and $\forall P , G :$ $( 1 - \epsilon _ { 2 } ) w ( \mathbb { P } , \mathbb { G } ) \leq W _ { L } ( \mathbb { P } , \mathbb { G } ) \leq ( 1 - \epsilon 1 ) w ( \mathbb { P } , \mathbb { G } )$ respectively, for some $\epsilon _ { 2 } > \epsilon _ { 1 } > 0$ and $\epsilon _ { 1 } > \epsilon _ { 2 } / 3$ . Then, using the sandwiched estimator $W _ { s }$ from (6), we can achieve tighter estimate of the Wasserstein distance than using either one estimator, i.e.
+
+$$
+\exists s : | W _ { s } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | < \operatorname* { m i n } \{ | W _ { U } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | , | W _ { L } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | \}
+$$
+
+# 3.2.1 UPPER AND LOWER BOUND IMPLEMENTATION
+
+For $W _ { L }$ , we can adopt many GAN variants (Arjovsky et al., 2017; Gulrajani et al., 2017; Mroueh & Sercu, 2017). For $W _ { U }$ , we use Bertsekas (1985), which results in a fast $\epsilon$ approximation of the Wasserstein distance estimate in primal form without solving non-trivial linear programming. We remark estimating Wasserstein distance $w ( \mathbb { P } , \mathbb { G } )$ with finite samples via its primal is only favorable to low dimensional data, such as point clouds. The error of empirical estimate in primal is $O ( 1 / n ^ { 1 / d } )$ (Weed & Bach, 2017). When the dimension $d$ is large (e.g. images), we cannot accurately estimate $w ( \mathbb { P } , \mathbb { G } )$ in primal as well as its upper bound with a small minibatch. For detailed discussion of finding lower and upper bound, please refer to Appendix A.2 and A.3.
+
+# 4 RELATED WORKS
+
+Generative Adversarial Network (Goodfellow et al., 2014) aims to learn a generator that can sample data followed by the data distribution. Compelling results on learning complex data distributions with GAN have been shown on images (Karras et al., 2017), speech (Lamb et al., 2016), text (Yu et al., 2016; Hjelm et al., 2017), vedio (Vondrick et al., 2016) and 3D voxels (Wu et al., 2016). However, the GAN algorithm on 3D point cloud is still under explored (Achlioptas et al., 2017). Many alternative objectives for training GANs have been studied. Most of them are the dual form of $f$ -divergence (Goodfellow et al., 2014; Mao et al., 2017; Nowozin et al., 2016), integral probability metrics (IPMs) (Zhao et al., 2016; Li et al., 2017a; Arjovsky et al., 2017; Gulrajani et al., 2017) or IPM extensions (Mroueh & Sercu, 2017; Mroueh et al., 2017). Genevay et al. (2018) learn the generative model by the approximated primal form of Wasserstein distance (Cuturi, 2013).
+
+Instead of training a generative model on the data space directly, one popular approach is combining with autoencoder (AE), which is called adversarial autoencoder (AAE) (Makhzani et al., 2015). AAE constrain the encoded data to follow normal distribution via GAN loss, which is similar to VAE (Kingma & Welling, 2013) by replacing the KL-divergence on latent space via any GAN loss.
+
+Tolstikhin et al. (2017) provide a theoretical explanation for AAE by connecting it with the primal form of Wasserstein distance. The other variant of AAE is training the other generative model to learn the distribution of the encoded data instead of enforcing it to be similar to a known distribution (Engel et al., 2017; Kim et al., 2017). Achlioptas et al. (2017) explore a AAE variant for point cloud. They use a specially-designed encoder network (Qi et al., 2017a) for learning a compressed representation for point clouds before training GAN on the latent space. However, their decoder is restricted to be a MLP which generates $m$ fixed number of points, where $m$ has to be pre-defined. That is, the output of their decoder is fixed to be $3 m$ for 3D point clouds, while the output of the proposed $G _ { x }$ is only 3 dimensional and $G _ { x }$ can generate arbitrarily many points by sampling different random noise $z$ as input. Yang et al. (2018); Groueix et al. (2018b) propose similar decoders to $G _ { x }$ with fixed grids to break the limitation of Achlioptas et al. (2017) aforementioned, but they use heuristic Chamfer distance without any theoretical guarantee and do not exploit generative models for point clouds. The proposed PC-GAN can also be interpreted as an encoder-decoder formulation. However, the underlying interpretation is different. We start from De-Finetti theorem to learn both $p ( X | \theta )$ and $p ( \theta )$ with inference network interpretation of $Q$ , while Achlioptas et al. (2017) focus on learning $p ( \theta )$ without modeling $p ( X | \theta )$ .
+
+Lastly, GAN for learning conditional distribution (conditional GAN) has been studied in images with single conditioning (Mirza & Osindero, 2014; Pathak et al., 2016; Isola et al., 2017; Chang et al., 2017) or multiple conditioning (Wang & Gupta, 2016). The case on point cloud is still under explored. Also, most of the works assume the conditioning is given (e.g. labels and base images) without learning the inference during the training. Training GAN with inference is studied by Donahue et al. (2016); Dumoulin et al. (2016); Li et al. (2017b); however, their goal is to infer the random noise $z$ of generators and match the semantic latent variable to be similar to $z$ . Li et al. (2018) is a parallel work aiming to learn GAN and unseen latent variable simultaneously, but they only study image and video datasets.
+
+# 5 EXPERIMENTS
+
+In this section we demonstrate the point cloud generation capabilities of PC-GAN. As discussed in Section 4, we refer Achlioptas et al. (2017) as AAE as it could be treated as an AAE extension to point clouds and we use the implementation provided by the authors for experiments. The sandwitching objective $W _ { s }$ for PC-GAN combines $W _ { L }$ and $W _ { U }$ with the mixture 1:20 without tunning for all experiment. $W _ { L }$ is a GAN loss by combining Arjovsky et al. (2017) and Mroueh & Sercu (2017) (technical details are in Appendix A.3) and we adopt (Bertsekas, 1985) for $W _ { U }$ . We parametrize $Q$ in PC-GAN by DeepSets (Zaheer et al., 2017). The review of DeepSets is in Appendix E. Other detailed configurations of each experiment can be found in Appendix F.
+
+# 5.1 SYNTHETIC DATASETS
+
+We generate 2D circle point clouds. The center of circles follows a mixture of Gaussians $\mathcal { N } ( \{ \pm 1 6 \} \times \{ \pm 1 6 \} , 1 6 I )$ with equal mixture weights. The radius of the circles was drawn from a uniform distribution $U n i f ( 1 . 6 , 6 . 4 )$ . One sampled circile is shown in Figure 4a.
+
+For AAE, the output size of the decoder is $5 0 0 \times 2$ for 500 points, and the output size of the encoder (latent code) is 20. The total number of parameters are $2 4 K$ . For PCGAN, the inference network output size is 15. The total nuumber of parameters of PCGAN is only $1 2 K$ . We evaluated the conditional distributions on the 10, 000 testing circles. We measured the empirical distributions of the centers and the radius of the generated circles conditioning on the testing data as shown in Figure 4.
+
+From Figure 4, both AAE and PC-GAN can successfully recover the center distribution, but AAE does not learn the radius distribution well even with larger latent code
+
+![](images/ad13d0249a0054f6fd5e5f384785981c86d914ea60fb249791c7b35500d6ea53.jpg)  
+Figure 4: (a) (top) the true center distribution and (bottom) one example of a circle point cloud. (b-d) are the reconstructed center and radius distributions.
+
+Table 1: Quantitative results of different models trained on different subsets of ModelNet40 and evaluated on the corresponding test set. ModelNet10 is a subset containing 10 classes of objects, while ModelNet40 is a full training set. AAE is trained using the code from Achlioptas et al. (2017). The PC-GAN variants are trained via upper bound $W _ { U }$ , lower bound $W _ { L }$ and sandwiching loss $W _ { s }$ .   
+
+<table><tr><td rowspan="2">Data</td><td colspan="4">Distance to Face (D2F ↓)</td><td colspan="4">Coverage (↑)</td></tr><tr><td>PC-GAN (Ws)</td><td>AAE</td><td>PC-GAN(Wu)</td><td>PC-GAN (WL)</td><td>PC-GAN (Ws)</td><td>AAE</td><td>PC-GAN (Wu)</td><td>PC-GAN (WL)</td></tr><tr><td>Aeroplanes</td><td>1.89E+01</td><td>1.99E+01</td><td>1.53E+01</td><td>2.49E+01</td><td>1.95E-01</td><td>2.99E-02</td><td>1.73E-01</td><td>1.88E-01</td></tr><tr><td>Benches</td><td>1.09E+01</td><td>1.41E+01</td><td>1.05E+01</td><td>2.46E+01</td><td>4.44E-01</td><td>2.35E-01</td><td>2.58E-01</td><td>3.83E-01</td></tr><tr><td>Cars</td><td>4.39E+01</td><td>6.23E+01</td><td>4.25E+01</td><td>6.68E+01</td><td>2.35E-01</td><td>4.98E-02</td><td>1.78E-01</td><td>2.35E-01</td></tr><tr><td>Chairs</td><td>1.01E+01</td><td>1.08E+01</td><td>1.06E+01</td><td>1.08E+01</td><td>3.90E-01</td><td>1.82E-01</td><td>3.57E-01</td><td>3.95E-01</td></tr><tr><td>Cups</td><td>1.44E+03</td><td>1.79E+03</td><td>1.28E+03</td><td>3.01E+03</td><td>6.31E-01</td><td>3.31E-01</td><td>4.32E-01</td><td>5.68E-01</td></tr><tr><td>Guitars</td><td>2.16E+02</td><td>1.93E+02</td><td>1.97E+02</td><td>1.81E+02</td><td>2.25E-01</td><td>7.98E-02</td><td>2.11E-01</td><td>2.27E-01</td></tr><tr><td>Lamps</td><td>1.47E+03</td><td>1.60E+03</td><td>1.64E+03</td><td>2.77E+03</td><td>3.89E-01</td><td>2.33E-01</td><td>3.79E-01</td><td>3.66E-01</td></tr><tr><td>Laptops</td><td>2.43E+00</td><td>3.73E+00</td><td>2.65E+00</td><td>2.58E+00</td><td>4.31E-01</td><td>2.56E-01</td><td>3.93E-01</td><td>4.55E-01</td></tr><tr><td>Sofa</td><td>1.71E+01</td><td>1.64E+01</td><td>1.45E+01</td><td>2.76E+01</td><td>3.65E-01</td><td>1.62E-01</td><td>2.94E-01</td><td>3.47E-01</td></tr><tr><td>Tables</td><td>2.79E+00</td><td>2.96E+00</td><td>2.44E+00</td><td>3.69E+00</td><td>3.82E-01</td><td>2.59E-01</td><td>3.20E-01</td><td>3.53E-01</td></tr><tr><td>ModelNet10</td><td>5.77E+00</td><td>6.89E+00</td><td>6.03E+00</td><td>9.19E+00</td><td>3.47E-01</td><td>1.90E-01</td><td>3.36E-01</td><td>3.67E-01</td></tr><tr><td>ModelNet40</td><td>4.84E+01</td><td>5.86E+01</td><td>5.24E+01</td><td>7.96E+01</td><td>3.80E-01</td><td>1.85E-01</td><td>3.65E-01</td><td>3.71E-01</td></tr></table>
+
+(20) and more parameters $( 2 4 K )$ . The gap   
+of memory usage could be larger if we configure AAE to generate more points, while the model size required for PC-GAN is independent of the number of points. The reason is MLP decoder adopted by Achlioptas et al. (2017) wastes parameters for nearby points. Using the much larger model (more parameters) could boost the performance. However, it is still restricted to generate a fixed number of points for each object as we discussed in Section 4.
+
+# 5.2 STUDY ON MODELNET40
+
+We consider ModelNet40 (Wu et al., 2015) benchmark, which contains 40 classes of objects. There are 9, 843 training and 2, 468 testing instances. We follow Achlioptas et al. (2017) to consider two settings. One is training on single class of objects. The other is training on all 9, 843 objects in the training set. Achlioptas et al. (2017) set the latent code size of AAE to be 128 and 256 for these two settings, with the total number of parameters to be $1 5 M$ and $1 5 . 2 M$ , respectively. Similarly, we set the output dimension of $Q$ in PC-GAN to be 128 and 256 for single-class and all-classes. The total number of parameters are $1 M$ and $3 M$ , respectively.
+
+Metrics for Quantitative Comparison Firstly, we are interested in whether the learned $G _ { x }$ and $Q$ can model the distribution of unseen test data. For each test point cloud, we infer the latent variable $Q ( X )$ , then use $G _ { x }$ to generate points. We then compare the distribution between the input point cloud and the conditionally generated point clouds.
+
+There are many finite sample estimation for $f$ -divergence and IPM can be used for evaluation. However, those estimators with finite samples are either biased or with high variance (Peyré et al., 2017; Wang et al., 2009; Póczos et al., 2012; Weed & Bach, 2017). Also, it is impossible to use these estimators with infinitely many samples if they are accessible.
+
+For ModelNet40, the meshes of each object are available. In many statistically guaranteed distance estimates, the adopted statistics are commonly based on distance between nearest neighbors (Wang et al., 2009; Póczos et al., 2012). Therefore, we propose to measure the performance with the following criteria. Given a point cloud $\{ x _ { i } \} _ { i = 1 } ^ { n }$ and a mesh, which is a collection of faces $\{ F _ { j } \} _ { j = 1 } ^ { m }$ , we measure the distance to face $( D 2 F )$ as
+
+![](images/2406e5943476e3d5002668257f3b90649a847f3222b28db8ea14ce7f750f75e2.jpg)  
+Figure 5: Sample mesh of ModelNet40
+
+$$
+D 2 F \left( \{ x _ { i } \} _ { i = 1 } ^ { n } , \{ F _ { j } \} _ { j = 1 } ^ { m } \right) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \operatorname* { m i n } _ { j } \mathcal { D } ( x _ { i } , F _ { j } ) ,
+$$
+
+where $\mathcal { D } ( x _ { i } , F _ { j } )$ is the Euclidean distance from $x _ { i }$ to the face $F _ { j }$ . This distance is similar to Chamfer distance, which is commonly used for measuring images and point clouds (Achlioptas et al., 2017; Fan et al., 2017), with infinitely samples from true distributions (meshes).
+
+Nevertheless, the algorithm can have low or zero D2F by only focusing a small portion of the point clouds (mode collapse). Therefore, we are also interested in whether the generated points recover enough supports of the distribution. We compute the Coverage ratio as follows. For each point, we find the its nearest face, we then treat this face is covered1. We then compute the ratio of number of faces of a mesh is covered. A sampled mesh is showed in Figure 5, where the details have more faces (non-uniform). Thus, it is difficult to get high coverage for AAE or PC-GAN trained by limited number of sampled points. However, the coverage ratio, on the other hand, serve as an indicator about how much details the model recovers.
+
+![](images/acd739ce1caf67e04e52c3ecd0f41679f58fe426e82fe33fb0472ec8520db14a.jpg)  
+Figure 6: Example reconstruction (conditional generation) on test objects. PC-GAN with sandwiching $( \hat W _ { s } )$ is better in capturing fine details like wheels of aeroplane or proper chair legs.
+
+The results are reported in Table 1. We compare four different algorithm, AAE and PC-GAN with three objectives, including upper bound $W _ { U }$ ( $\epsilon$ approximated Wasserstein distance), lower bound $W _ { L }$ (GAN with $L ^ { 2 }$ ball constraints and weight clipping), and the sandwiching loss $W _ { s }$ as discussed in Section 3.2, The study with $W _ { U }$ and $W _ { L }$ also serves as the ablation test of $W _ { s }$ .
+
+Comparison between Upper bound, Lower bound and Sandwiching Since $W _ { U }$ directly optimizes distance between training and generated point clouds, $W _ { U }$ usually results in smaller D2F than $W _ { L }$ in Table 1. One the other hand, although $W _ { L }$ only recovers lower bound estimate of Wasserstein distance, its discriminator is known to focus on learning support of the distribution (Bengio, 2018), which results in better coverage (support) than $W _ { U }$ .
+
+Theoretically, the proposed sandwiching $W _ { s }$ results in a tighter Wasserstein distance estimation than $W _ { U }$ and $W _ { L } ^ { \dot { } }$ (Lemma 1). Based on above discussion, it can also be understood as balancing both D2F and coverage by combining both $W _ { U }$ and $W _ { L }$ to get a desirable middle ground. Empirically, we even observe that $W _ { s }$ results in better coverage than $\bar { \boldsymbol { W } } _ { L }$ , and competitive D2F with $\bar { W } _ { U }$ . The intuitive explanation is that some discriminative tasks are $o f f$ to $W _ { U }$ objective, so the discriminator can focus more on learning distribution supports. We argue that this difference is crucial for capturing the object details. Some reconstructed point clouds of testing data are shown in Figure 6. For aeroplane examples, $W _ { U }$ are failed to capture aeroplane tires and $W _ { s }$ has better tire than $W _ { L }$ . For Chair example, $W _ { s }$ recovers better legs than $W _ { U }$ and better seat cushion than $W _ { L }$ . Lastly, we highlight $W _ { s }$ outperforms others more significantly when training data is larger (ModelNet10 and ModelNet40) in Table 1.
+
+Comparison between PC-GAN and AAE In most of cases, PC-GAN with $W _ { s }$ has lower D2F in Table 1 with less number of parameters aforementioned. Similar to the argument in Section 5.1, although AAE use larger networks, the decoder wastes parameters for nearby points. AAE only outperforms PC-GAN $( W _ { s } )$ in Guitar and Sofa in terms of D2F, since the variety of these two classes are low. It is easier for MLP to learn the shared template (basis) of the point clouds. On the other hand, due to the limitation of the fixed number of output points and Chamfer distance objective, AAE has worse coverage than PC-GAN, It can be supported by Figure 6, where AAE is also failed to recover aeroplane tire.
+
+Hierarchical Sampling In Section 3, we propose a hierarchical sampling process for sampling point clouds. In the first hierarchy, the generator $G _ { \theta }$ , samples a object $( \theta \overset { \cdot } { = } \bar { G _ { \theta } } \bar { ( } u ) , u \sim \mathbb { P } ( u ) )$ , while the second generator $G _ { x }$ samples points based on $\theta$ to form the point cloud.
+
+The randomly sampled results without given any data as input are shown in Figure 7. More results can be found in Appendix C. The point clouds are all smooth, structured and almost symmetric. It shows PC-GAN captures inherent symmetries and patterns in all the randomly sampled objects, even if overall object is not perfectly formed. This highlights that learning point-wise generation scheme encourages learning basic building blocks of objects.
+
+![](images/c1581e8e47d9b2d33fe8c8cf980c6c3b1abad32e1733cd0c2e8143e4d7c2f7ea.jpg)  
+Figure 7: Randomly sampled objects and corresponding point cloud from the hierarchical sampling Even if there are some defects, the objects are smooth, symmetric and structured.
+
+Interpolation of Learned Manifold We study whether the interpolation between two objects on the latent space results in smooth change. We interpolate the inferred representations of two objects by $Q$ , and use the generator $G _ { x }$ to sample points based on the interpolation. The inter-class result is shown in Figure 8. More studies about interpolation between rotations can be found in Appendix D.1.
+
+![](images/ac5b8dff5f4ae8477313a05f0257b0c17cf7682d2fcaa77624d9ff7d20d4b9e1.jpg)  
+Figure 8: Interpolating between latent representations $Q ( X )$ of a table and a chair point clouds.
+
+Generalization on Unseen Classes In above, we studied the reconstruction of unseen testing objects, while PC-GAN still saw the point clouds from the same class during training. Here we study the more challenging task. We train PC-GAN on first 30 (Alphabetic order) class, and test on the other fully unseen 10 classes. Some reconstructed (conditionally generated) point clouds are shown in Figure 9. More (larger) results can be found in Appendix C. For the object from the unseen classes, the conditionally generated point clouds still recovers main shape and reasonable geometry structure, which confirms the advantage of the proposed PC-GAN: by enforcing the point-wise transformation, the model is forced to learn the underlying geometry structure and the shared building blocks, instead of naively copying the input from the conditioning. The rsulted D2F and coverage are 57.4 and 0.36, which are only slightly worse than 48.4 and 0.38 by training on whole 40 classes in Table 1 (ModelNet40), which also supports the claims of the good generalization ability of PC-GAN.
+
+![](images/21c8169acd5da45325513304887f8f5b94496af36af47474f5fd7aec8032b9c4.jpg)  
+Figure 9: The reconstructed objects from unseen classes (even in training). In each plot, LHS is true data while RHS is PC-GAN. PC-GAN generalizes well as it can match patterns and symmetries from classes seen in the past to new unseen classes.
+
+More Studies We also condct other studies to make experiments complete, including interpolation between different rotations, classification and image to point clouds. Due to space limit, all of the results can be found in Appendix D.
+
+# 6 CONCLUSION
+
+In this paper, we first showed a straightforward extension of existing GAN algorithm is not applicable to point clouds. We then proposed a GAN modification (PC-GAN) that is capable of learning to generate point clouds by using ideas both from hierarchical Bayesian modeling and implicit generative models. We further propose a sandwiching objective which results in a tighter Wasserstein distance estimate theoretically and better performance empirically.
+
+In contrast to some existing methods (Achlioptas et al., 2017), PC-GAN can generate arbitrary as many i.i.d. points as we need to form a point clouds without pre-specification. Quantitatively, PC-GAN achieves competitive or better results using smaller network than existing methods. We also demonstrated that PC-GAN can capture delicate details of point clouds and generalize well even on unseen data. Our method learns “point-wise” transformations which encourage the model to learn the building components of the objects, instead of just naively copying the whole object. We also demonstrate other interesting results, including point cloud interpolation and image to point clouds.
+
+Although we only focused on 3D applications in this paper, our framework can be naturally generalized to higher dimensions. In the future we would like to explore higher dimensional applications, where each 3D point can have other attributes, such as RGB colors and 3D velocity vectors.
+
+# REFERENCES
+
+Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Learning representations and generative models for 3d point clouds. arXiv preprint arXiv:1707.02392, 2017.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein gan. ICML, 2017.
+
+Sanjeev Arora, Rong Ge, Yingyu Liang, Tengyu Ma, and Yi Zhang. Generalization and equilibrium in generative adversarial nets (gans). arXiv preprint arXiv:1703.00573, 2017.
+
+Yoshua Bengio. Gans and unsupervised representation learning, 2018.
+
+Dimitri P Bertsekas. A distributed asynchronous relaxation algorithm for the assignment problem. In Decision and Control, 1985.
+
+M Christopher Bishop. Pattern Recognition and Machine Learning. Springer-Verlag New York, 2006.
+
+JH Rick Chang, Chun-Liang Li, Barnabas Poczos, BVK Vijaya Kumar, and Aswin C Sankaranarayanan. One network to solve them all—solving linear inverse problems using deep projection models. arXiv preprint, 2017.
+
+Ding-Yun Chen, Xiao-Pei Tian, Yu-Te Shen, and Ming Ouhyoung. On visual similarity based 3d model retrieval. In Computer graphics forum, 2003.
+
+Christopher B Choy, Danfei Xu, JunYoung Gwak, Kevin Chen, and Silvio Savarese. 3d-r2n2: A unified approach for single and multi-view 3d object reconstruction. In ECCV, 2016.
+
+Marco Cuturi. Sinkhorn distances: Lightspeed computation of optimal transport. In NIPS, 2013.
+
+Bo Dai, Sanja Fidler, Raquel Urtasun, and Dahua Lin. Towards diverse and natural image descriptions via a conditional gan. arXiv preprint arXiv:1703.06029, 2017.
+
+Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Olivier Mastropietro, Alex Lamb, Martin Arjovsky, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Ben Eckart, Kihwan Kim, Alejandro Troccoli, Alonzo Kelly, and Jan Kautz. Mlmd: Maximum likelihood mixture decoupling for fast and accurate point cloud registration. In 3DV, 2015.
+
+Jesse Engel, Matthew Hoffman, and Adam Roberts. Latent constraints: Learning to generate conditionally from unconditional generative models. arXiv preprint arXiv:1711.05772, 2017.
+
+Haoqiang Fan, Hao Su, and Leonidas J Guibas. A point set generation network for 3d object reconstruction from a single image. In CVPR, 2017.
+
+Aude Genevay, Gabriel Peyré, and Marco Cuturi. Learning generative models with sinkhorn divergences. In AISTATS, 2018.
+
+Rohit Girdhar, David F Fouhey, Mikel Rodriguez, and Abhinav Gupta. Learning a predictable and generative vector representation for objects. In European Conference on Computer Vision, 2016.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In NIPS, 2014.
+
+Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. Atlasnet: A papier- $. \mathrm { m } \rangle \hat { \ }$ ach\’e approach to learning 3d surface generation. arXiv preprint arXiv:1802.05384, 2018a.
+
+Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-mâché approach to learning 3d surface generation. In CVPR, 2018b.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Improved training of wasserstein gans. In NIPS, 2017.
+
+Christian Häne, Shubham Tulsiani, and Jitendra Malik. Hierarchical surface prediction for 3d object reconstruction. In 3D Vision (3DV), 2017 International Conference on, 2017.   
+R. Devon Hjelm, Athul Paul Jacob, Tong Che, Kyunghyun Cho, and Yoshua Bengio. Boundaryseeking generative adversarial networks. arXiv:1702.08431, 2017.   
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A Efros. Image-to-image translation with conditional adversarial networks. arXiv preprint, 2017.   
+Bing Jian and Baba C Vemuri. A robust algorithm for point set registration using mixture of gaussians. In ICCV, 2005.   
+Evangelos Kalogerakis, Melinos Averkiou, Subhransu Maji, and Siddhartha Chaudhuri. 3d shape segmentation with projective convolutional networks. CVPR, 2, 2017.   
+Eunsu Kang. FACE Exhibition, 2017. Judith Rae Solomon Gallery, Youngstown, OH. http://art.ysu.edu/2017/09/06/face-by-eunsu-kang-and-collaborators/.   
+Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. arXiv preprint arXiv:1710.10196, 2017.   
+Michael Kazhdan, Thomas Funkhouser, and Szymon Rusinkiewicz. Rotation invariant spherical harmonic representation of 3 d shape descriptors. In Symposium on geometry processing, 2003.   
+Yoon Kim, Kelly Zhang, Alexander M Rush, Yann LeCun, et al. Adversarially regularized autoencoders for generating discrete structures. arXiv preprint arXiv:1706.04223, 2017.   
+Diederik $\mathrm { \bf P }$ Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+Alex M Lamb, Anirudh Goyal ALIAS PARTH GOYAL, Ying Zhang, Saizheng Zhang, Aaron C Courville, and Yoshua Bengio. Professor forcing: A new algorithm for training recurrent networks. In NIPS, 2016.   
+Chongxuan Li, Max Welling, Jun Zhu, and Bo Zhang. Graphical generative adversarial networks. arXiv preprint arXiv:1804.03429, 2018.   
+Chun-Liang Li, Wei-Cheng Chang, Yu Cheng, Yiming Yang, and Barnabás Póczos. Mmd gan: Towards deeper understanding of moment matching network. In NIPS, 2017a.   
+Chunyuan Li, Hao Liu, Changyou Chen, Yuchen Pu, Liqun Chen, Ricardo Henao, and Lawrence Carin. Alice: Towards understanding adversarial learning for joint distribution matching. In NIPS, 2017b.   
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.   
+Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, and Zhen Wang. Least squares generative adversarial networks. In ICCV, 2017.   
+Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint arXiv:1411.1784, 2014.   
+Youssef Mroueh and Tom Sercu. Fisher gan. In NIPS, 2017.   
+Youssef Mroueh, Chun-Liang Li, Tom Sercu, Anant Raj, and Yu Cheng. Sobolev gan. arXiv preprint arXiv:1711.04894, 2017.   
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In NIPS, 2016.   
+Junier B Oliva, Avinava Dubey, Barnabás Póczos, Jeff Schneider, and Eric P Xing. Transformation autoregressive networks. arXiv preprint arXiv:1801.09819, 2018.   
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016.   
+Deepak Pathak, Philipp Krahenbuhl, Jeff Donahue, Trevor Darrell, and Alexei A Efros. Context encoders: Feature learning by inpainting. In CVPR, 2016.   
+Gabriel Peyré, Marco Cuturi, et al. Computational optimal transport. Technical report, 2017.   
+Barnabás Póczos, Liang Xiong, and Jeff Schneider. Nonparametric divergence estimation with applications to machine learning on distributions. arXiv preprint arXiv:1202.3758, 2012.   
+Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. CVPR, 2017a.   
+Charles Ruizhongtai Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In NIPS, 2017b.   
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In NIPS, 2016.   
+Hang Shao, Abhishek Kumar, and P Thomas Fletcher. The riemannian geometry of deep generative models. arXiv preprint arXiv:1711.08014, 2017.   
+Abhishek Sharma, Oliver Grau, and Mario Fritz. Vconv-dae: Deep volumetric shape learning without object labels. In European Conference on Computer Vision, 2016.   
+Johannes Strom, Andrew Richardson, and Edwin Olson. Graph-based segmentation for colored 3d laser point clouds. In IROS, 2010.   
+Hang Su, Subhransu Maji, Evangelos Kalogerakis, and Erik Learned-Miller. Multi-view convolutional neural networks for 3d shape recognition. In ICCV, 2015.   
+Ilya Tolstikhin, Olivier Bousquet, Sylvain Gelly, and Bernhard Schoelkopf. Wasserstein auto-encoders. arXiv preprint arXiv:1711.01558, 2017.   
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Generating videos with scene dynamics. In NIPS, pp. 613–621, 2016.   
+Qing Wang, Sanjeev R Kulkarni, and Sergio Verdú. Divergence estimation for multidimensional densities via $k$ -nearest-neighbor distances. IEEE Transactions on Information Theory, 2009.   
+Xiaolong Wang and Abhinav Gupta. Generative image modeling using style and structure adversarial networks. In ECCV, 2016.   
+Jonathan Weed and Francis Bach. Sharp asymptotic and finite-sample rates of convergence of empirical measures in wasserstein distance. arXiv preprint arXiv:1707.00087, 2017.   
+Jiajun Wu, Chengkai Zhang, Tianfan Xue, Bill Freeman, and Josh Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In NIPS, 2016.   
+Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In CVPR, 2015.   
+Yaoqing Yang, Chen Feng, Yiru Shen, and Dong Tian. Foldingnet: Point cloud auto-encoder via deep grid deformation. In CVPR, volume 3, 2018.   
+Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets with policy gradient. CoRR, abs/1609.05473, 2016.   
+Manzil Zaheer, Satwik Kottur, Siamak Ravanbakhsh, Barnabas Poczos, Ruslan R Salakhutdinov, and Alexander J Smola. Deep sets. In NIPS, 2017.   
+Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network. arXiv preprint arXiv:1609.03126, 2016.   
+Jun-Yan Zhu, Taesung Park, Phillip Isola, and Alexei A Efros. Unpaired image-to-image translation using cycle-consistent adversarial networks. arXiv preprint arXiv:1703.10593, 2017.
+
+# A DETAILS OF THE PROPOSED METHOD
+
+# A.1 NEURAL NETWORK REALIZATION OF INFERENCE NETWORK
+
+Our solution comprises of a generator $G _ { x } ( z , \psi )$ which takes in a noise source $z ~ \in ~ \mathbb { R } ^ { d _ { 1 } }$ and a descriptor $\psi \in \mathbb { R } ^ { d _ { 2 } }$ encoding information about distribution of $\theta$ . For a given $\theta _ { 0 }$ , the descriptor $\psi$ would encode information about the distribution $\delta ( \theta - \theta _ { 0 } )$ and samples generated as $x = G _ { x } ( z , \psi )$ would follow the distribution $p ( x | \theta _ { 0 } )$ . More generally, $\psi$ can be used to encode more complicated distributions regarding $\theta$ as well. In particular, it could be used to encode the posterior $p ( \theta | X )$ for a given sample set $X$ , such that $x = \bar { G } _ { x } ( z , \psi )$ follows the posterior predictive distribution:
+
+$$
+p ( x | X ) = \int p ( x | \theta ) p ( \theta | X ) d \theta .
+$$
+
+A major hurdle in taking this path is that $X$ is a set of points, which can vary in size and permutation of elements. Thus, making design of $Q$ complicated as traditional neural network can not handle this and possibly is the reason for absence of such framework in the literature despite being a natural solution for the important problem of generative modeling of point clouds. However, we can overcome this challenge and we propose to construct the inference network by utilizing the permutation equivariant layers from Deep Sets (Zaheer et al., 2017). This allows it handle variable number of inputs points in arbitrary order, yet yielding a consistent descriptor $\psi$ .
+
+After training $G _ { x }$ and the inference network $Q$ , we use trained $Q$ to collect inferred $Q ( X )$ and train the generator $G _ { \theta } ( u ) \sim p ( \theta )$ for higher hierarchical sampling, where $u$ is the other noise source independent of $z$ . In addition to the layer-wise training, a joint training may further boost the performance. The full generative process for sampling one point cloud could be represented as $\{ x _ { i } \bar  \} _ { i = 1 } ^ { n } = \{ G _ { x } ( z _ { i } , G _ { \theta } ( u ) \bar { ) } \} _ { i = 1 } ^ { n }$ , where $z _ { 1 } , \dots , z _ { n } \sim p ( z )$ and $u \sim p ( u )$ .
+
+We call the proposed GAN framework for learning to generative point clouds as PC-GAN as shown in Figure 2. The conditional distribution matching with a learned inference in PC-GAN can also be interpreted as an encoder-decoder formulation (Kingma & Welling, 2013). The difference between it and the point cloud autoencoder (Achlioptas et al., 2017; Yang et al., 2018) will be discussed in Section 4.
+
+# A.2 UPPER IMPLEMENTATION
+
+The primal form of Wasserstein distance is defined as
+
+$$
+w ( \mathbb { P } , \mathbb { G } ) = \operatorname* { i n f } _ { \gamma \in \Gamma ( \mathbb { P } , \mathbb { G } ) } \int \| x - y \| _ { 1 } d \gamma ( x , y ) ,
+$$
+
+where $\gamma$ is the coupling of $P$ and $G$ . The Wasserstein distance is also known as optimal transport $( \mathrm { O T } )$ or earth moving distance (EMD). As the name suggests, when $w ( \mathbb { P } , \mathbb { G } )$ is estimated with finite number of samples $X = x _ { 1 } , \ldots , x _ { n }$ and $Y = y _ { 1 } , \dots , y _ { n }$ , we find the one-to-one matching between $X$ and $Y$ such that the total pairwise distance is minimal. The resulting minimal total (average) pairwise distance is $w ( X , Y )$ . In practice, finding the exact matching efficiently is non-trivial and still an open research problem (Peyré et al., 2017). Instead, we consider an approximation provided by Bertsekas (1985). It is an iterative algorithm where each iteration operates like an auction whereby unassigned points $x \in X$ bid simultaneously for closest points $y \in Y$ , thereby raising their prices. Once all bids are in, points are awarded to the highest bidder. The crux of the algorithm lies in designing a non-greedy bidding strategy. One can see by construction the algorithm is embarrassingly parallelizable, which is favourable for GPU implementation. One can show that algorithm terminates with a valid matching and the resulting matching cost $W _ { U } ( X , Y )$ is an $\epsilon$ -approximation of $w ( X , Y )$ . Thus, the estimate can serve as an upper bound, i.e.
+
+$$
+w ( X , Y ) \leq W _ { U } ( X , Y ) \leq ( 1 + \epsilon ) w ( X , Y ) ,
+$$
+
+We remark estimating Wasserstein distance $w ( \mathbb { P } , \mathbb { G } )$ with finite sample via primal form is only favorable in low dimensional data, such as point clouds. The error between $w ( \mathbb { P } , \mathbb { G } )$ and $w ( X , Y )$ is $O ( 1 / n ^ { 1 / d } )$ , where $d$ is data dimension (Weed & Bach, 2017). Therefore, for high dimensional data, such as images, we cannot accurately estimate wasserstein distance in primal and its upper bound with a small minibatch.
+
+Finding a modified primal form with low sample complexity is also an open research problem (Cuturi, 2013; Genevay et al., 2018), and combining those into the proposed sandwiching objective for high dimensional data is left for future works.
+
+# A.3 LOWER IMPLEMENTATION
+
+The dual form of Wasserstein distance is defined as
+
+$$
+w ( \mathbb { P } , \mathbb { G } ) = \operatorname* { s u p } _ { f \in { \mathcal { L } } _ { 1 } } \mathbb { E } _ { x \sim P } f ( x ) - \mathbb { E } _ { x \sim G } f ( x ) ,
+$$
+
+where $\mathcal { L } _ { k }$ is the set of $k$ -Lipschitz functions whose Lipschitz constant is no larger than $k$ . In practice, deep neural networks parameterized by $\phi$ with constraints $f _ { \phi } \in \Omega _ { \phi }$ (Arjovsky et al., 2017), result in a distance approximation
+
+$$
+W _ { L } ( \mathbb { P } , \mathbb { G } ) = \operatorname* { m a x } _ { f _ { \phi } \in \Omega _ { \phi } } \mathbb { E } _ { x \sim P } f _ { \phi } ( x ) - \mathbb { E } _ { x \sim G } f _ { \phi } ( x ) .
+$$
+
+If there exists $k$ such that $\Omega _ { f } \subseteq { \mathcal { L } } _ { k }$ , then $W _ { L } ( \mathbb { P } , \mathbb { G } ) / k \le w ( \mathbb { P } , \mathbb { G } ) ~ \forall P , G$ is a lower bound. To enforce $\Omega _ { \phi } \subseteq { \mathcal { L } } _ { k }$ , Arjovsky et al. (2017) propose a weight clipping constraint $\Omega _ { c }$ , which constrains every weight to be in $[ - c , c ]$ and guarantees that $\Omega _ { c } \subseteq { \mathcal { L } } _ { k }$ for some $k$ . However, choosing clipping range $c$ is non-trivial in practice. Small ranges limit the capacity of networks, while large ranges result in numerical issues during the training. On the other hand, in addition to weight clipping, several constraints (regularization) have bee proposed with better empirical performance, such as gradient penalty (Gulrajani et al., 2017) and $L ^ { \frac { \ d } { 2 } }$ ball (Mroueh & Sercu, 2017). However, there is no guarantee the resulted functions are still Lipschitz or the resulted distances are lower bounds of Wasserstein distance. To take the advantage of those regularization with the Lipschitz guarantee, we propose a simple variation by combining weight clipping, which always ensures Lipschitz functions.
+
+Lemma 2. There exists $k > 0$ such that
+
+$$
+\operatorname* { m a x } _ { f \in \Omega _ { c } \cap \Omega _ { \phi } } \mathbb { E } _ { x \sim P } [ f _ { \phi } ( x ) ] - \mathbb { E } _ { x \sim G } [ f _ { \phi } ( x ) ] \leq \frac { 1 } { k } w ( \mathbb { P } , \mathbb { G } )
+$$
+
+Note that, if $c \to \infty$ , then $\Omega _ { c } \cap \Omega _ { \phi } = \Omega _ { \phi }$ . Therefore, from Proposition 2, for any regularization of discriminator (Gulrajani et al., 2017; Mroueh & Sercu, 2017; Mroueh et al., 2017), we can always combine it with a weight clipping constraint $\Omega _ { c }$ to ensure a valid lower bound estimate of Wasserstein distance and enjoy the advantage that it is numerically stable when we use large $c$ compared with original weight-clipping WGAN (Arjovsky et al., 2017).
+
+In practice, we found combing $L ^ { 2 }$ ball constraint and weight-clipping leads to satisfactory performance. We also studied popular WGAN-GP (Gulrajani et al., 2017) with weight clipping to ensure Lipschitz continuity of discriminator, but we found $L ^ { 2 }$ ball with weight clipping is faster and more numerically stable to train.
+
+# B TECHNICAL PROOF
+
+Lemma 1. Suppose we have two approximators to Wasserstein distance: an upper bound $W _ { U }$ and a lower $W _ { L }$ , such that $\forall P , G : ( \bar { 1 } + \epsilon _ { 1 } ) w ( \mathbb { P } , \mathbb { G } ) \leq W _ { U } ( \mathbb { P } , \mathbb { G } ) \leq ( 1 + \epsilon _ { 2 } ) \bar { w } ( \mathbb { P } , \mathbb { G } )$ and $\forall P , G :$ $( 1 - \epsilon _ { 2 } ) w ( \mathbb { P } , \mathbb { G } ) \leq W _ { L } ( \mathbb { P } , \mathbb { G } ) \leq ( 1 - \epsilon 1 ) w ( \mathbb { P } , \mathbb { G } )$ respectively, for some $\epsilon _ { 2 } > \epsilon _ { 1 } > 0$ and $\epsilon _ { 1 } > \epsilon _ { 2 } / 3$ . Then, using the sandwiched estimator $W _ { s }$ from (6), we can achieve tighter estimate of the Wasserstein distance than using either one estimator, i.e.
+
+$$
+\exists s : | W _ { s } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | < \operatorname* { m i n } \{ | W _ { U } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | , | W _ { L } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | \}
+$$
+
+Proof. We prove the claim by show that LHS is at most $\epsilon _ { 1 }$ , which is the lower bound for RHS.
+
+$$
+\begin{array} { r l } & { W _ { s } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | } \\ & { \qquad = | ( 1 - s ) W _ { U } ( \mathbb { P } , \mathbb { G } ) + s W _ { L } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | } \\ & { \qquad = | ( 1 - s ) \big ( W _ { U } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) \big ) - s ( w ( \mathbb { P } , \mathbb { G } ) - W _ { L } ( \mathbb { P } , \mathbb { G } ) ) | } \\ & { \qquad \le \operatorname* { m a x } \{ ( 1 - s ) \underbrace { ( W _ { U } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) ) } _ { \le \epsilon _ { 2 } } , s \underbrace { ( w ( \mathbb { P } , \mathbb { G } ) - W _ { L } ( \mathbb { P } , \mathbb { G } ) ) } _ { \le \epsilon _ { 2 } } \} } \\ & { \qquad - \operatorname* { m i n } \{ ( 1 - s ) \underbrace { ( W _ { U } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) ) } _ { \ge \epsilon _ { 1 } } , s \underbrace { ( w ( \mathbb { P } , \mathbb { G } ) - W _ { L } ( \mathbb { P } , \mathbb { G } ) ) } _ { \ge \epsilon _ { 1 } } \} } \\ & { \qquad \le \operatorname* { m a x } \{ ( 1 - s ) , s \} \epsilon _ { 2 } - \operatorname* { m i n } \{ ( 1 - s ) , s \} \epsilon _ { 1 } } \end{array}
+$$
+
+Without loss of generality we can assume $\lambda < 0 . 5$ , which brings us to
+
+$$
+| W _ { s } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | \le ( 1 - \lambda ) \epsilon _ { 2 } - \lambda \epsilon _ { 1 }
+$$
+
+Now if we chose $\textstyle \frac { \epsilon _ { 2 } - \epsilon _ { 1 } } { \epsilon _ { 2 } + \epsilon _ { 1 } } < \lambda < 0 . 5$ , then $| W _ { s } ( \mathbb { P } , \mathbb { G } ) - w ( \mathbb { P } , \mathbb { G } ) | < \epsilon _ { 1 }$ as desired.
+
+Lemma 2. There exists $k > 0$ such that
+
+$$
+\operatorname* { m a x } _ { f \in \Omega _ { c } \cap \Omega _ { \phi } } \mathbb { E } _ { x \sim P } [ f _ { \phi } ( x ) ] - \mathbb { E } _ { x \sim G } [ f _ { \phi } ( x ) ] \leq \frac { 1 } { k } w ( \mathbb { P } , \mathbb { G } )
+$$
+
+Proof. Since there exists $k$ such that $\begin{array} { r } { \operatorname* { m a x } _ { f \in \Omega _ { c } } \mathbb { E } _ { x \sim P } [ f _ { \phi } ( x ) ] - \mathbb { E } _ { x \sim G } [ f _ { \phi } ( x ) ] \le \frac { 1 } { k } w ( \mathbb { P } , \mathbb { G } ) } \end{array}$ , it is clear that
+
+$$
+\operatorname* { m a x } _ { f \in \Omega _ { c } \cap \Omega _ { \phi } } \mathbb { E } _ { x \sim P } [ f _ { \phi } ( x ) ] - \mathbb { E } _ { x \sim G } [ f _ { \phi } ( x ) ] \leq \operatorname* { m a x } _ { f \in \Omega _ { c } } \mathbb { E } _ { x \sim P } [ f _ { \phi } ( x ) ] - \mathbb { E } _ { x \sim G } [ f _ { \phi } ( x ) ] \leq \frac { 1 } { k } w ( \mathbb { P } , \mathbb { G } ) .
+$$
+
+# C LARGER RESULTS
+
+The larger and more hierarchical sampling discussed in Section 5.2 can be found in Figure 10. The reconstruction results on unseen classes are shown in Figure 11.
+
+# D ADDITIONAL STUDY
+
+# D.1 INTERPOLATION BETWEEN ROTATIONS
+
+It is also popular to show intra-class interpolation. In addition show simple intra-class interpolations, where the objects are almost aligned, we present an interesting study on interpolations between rotations. During the training, we only rotate data with 8 possible angles for augmentation, here we show it generalizes to other unseen rotations as shown in Figure 12.
+
+However, if we linearly interpolate the code, the resulted change is scattered and not smooth as shown in Figure 12. Instead of using linear interpolation, We train a 2-layer MLP with limited hidden layer size to be 16, where the input is the angle, output is the corresponding latent representation of rotated object. We then generate the code for rotated planes with this trained MLP. It suggests although the transformation path of rotation on the latent space is not linear, it follows a smooth trajectory2. It may also suggest the geodesic path of the learned manifold may not be nearly linear between rotations. Finding the geodesic path with a principal method (Shao et al., 2017) and Understanding the geometry of the manifold for point cloud worth more deeper study as future work.
+
+# D.2 CLASSIFICATION RESULTS
+
+We evaluate the quality of the representation acquired from the learned inference network $Q$ . We train the inference network $Q$ and the generator $G _ { x }$ on the training split of ModelNet40 with data augmentation as mentioned above for learning generative models without label information. We then extract the latent representation $Q ( X )$ for each point clouds and train linear SVM on the that with its label. We apply the same setting to a linear classifier on the latent code of Achlioptas et al. (2017).
+
+![](images/1feb5c9b951871c0079b8dd870b10c95a235edd4d55cd01d7c8d3d179fab5c87.jpg)  
+Figure 10: Randomly sampled objects and corresponding point cloud from the hierarchical sampling. Even if there are some defects, the objects are smooth, symmetric and structured. It suggests PC-GAN captures inherent patterns and learns basic building blocks of objects.
+
+We only sample 1000 as input for our inference network $Q$ . Benefited by the Deep Sets architecture for the inference network, which is invariant to number of points. Therefore, we are allowed to sample different number of points as input to the trained inference network for evaluation. Because of the randomness of sampling points for extracting latent representation, we repeat the experiments 20 times and report the average accuracy and standard deviation on the testing split in Table 2. By using 1000 points, we are already better than Achlioptas et al. (2017) with 2048 points, and competitive with the supervised learning algorithm Deep Sets. We also follow the same protocol as Achlioptas et al. (2017); Wu et al. (2016) that we train on ShapeNet55 and test the accuracy on ModelNet40. Compared with existing unsupervised learning algorithms, PC-GAN has the best performance as shown in Table 3.
+
+Table 2: Classification accuracy results.   
+
+<table><tr><td>Method</td><td>#points</td><td>Accuracy</td></tr><tr><td>PC-GAN</td><td>1000</td><td>87.5 ± .6%</td></tr><tr><td>PC-GAN</td><td>2048</td><td>87.8± .2%</td></tr><tr><td>AAE (Achlioptas et al., 2017)</td><td>2048</td><td>85.5 ± .3%</td></tr><tr><td>Deep Sets (Zaheer et al., 2017)</td><td>1000</td><td>87 ±1%</td></tr><tr><td>Deep Sets (Zaheer et al.,2017)</td><td>5000</td><td>90 ± .3%</td></tr></table>
+
+We note that Yang et al. (2018) using additional geometry features by appending pre-calculated features with 3-dimensional coordinate as input or using more advanced grouping structure to achieve better performance. Those techniques are all applicable to PC-GAN and leave it for future works by leveraging geometry information into the proposed PC-GAN framework.
+
+![](images/e063fe2fc65d41b4d5e928293c7e5211ad5ba4f9028b7b03498564f2b52deaf5.jpg)  
+Figure 11: The reconstructed objects from unseen categories. In each plot, LHS is true data while RHS is PC-GAN. PC-GAN generalizes well as it can match patterns and symmetries from categories seen in the past to new unseen categories.
+
+![](images/7c3c6dc58ed1a2cdea8bf5ea4398826e1c78e4fb2e588c467af5b491dcf7359a.jpg)  
+Figure 12: Interpolating between rotation of an aeroplane, using our latent space representation.
+
+# D.3 IMAGES TO POINT CLOUD
+
+Here we demonstrate a potential extension of the proposed PC-GAN for images to point cloud applications. After training $Q$ as described in 3 and Appendix A.1, instead of learning $G _ { \theta }$ for hierarchical sampling, we train a regressor $R$ , where the input is the different views of the point cloud $X$ , and the output is $Q ( X )$ . In this proof of concept experiment, we use the 12 view data and the Res18 architecture in Su et al. (2015), while we change the output size to be 256. Some example results on reconstructing testing data is shown in Figure 13. A straightforward extension is using end-to-end training instead of two-staged approached adopted here. Also, after aligning objects and take representative view along with traditional ICP techniques, we can also do single view to point cloud transformation as Choy et al. (2016); Fan et al. (2017); Häne et al. (2017); Groueix et al. (2018a), which is not the main focus of this paper and we leave it for future work.
+
+Table 3: Classification accuracy results (Trained on ShapeNet55).   
+
+<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>SPH (Kazhdan et al., 2003)</td><td>68.2%</td></tr><tr><td>T-L Network (Girdhar et al., 2016)</td><td>74.4%</td></tr><tr><td>LFD (Chen etal., 2003)</td><td>75.5%</td></tr><tr><td>VConv-DAE (Sharma et al., 2016)</td><td>75.5%</td></tr><tr><td>3D GAN (Wu et al., 2016)</td><td>83.3%</td></tr><tr><td>AAE (Achlioptas et al., 2017)</td><td>84.5%</td></tr><tr><td>PC-GAN</td><td>86.9%</td></tr></table>
+
+![](images/380216eec272914853e7627ec4b01fed17a03198d26bb2fd2b477692373b3bb1.jpg)  
+Figure 13: Image to Point Cloud
+
+# E DEEP SETS (PERMUTATION EQUIVARIANCE LAYERS)
+
+We briefly review the notion of Permutation Equivariance Layers proposed by Zaheer et al. (2017) as a background required for this paper. For more details, please refer to Zaheer et al. (2017).
+
+Zaheer et al. (2017) propose a generic framework of deep learning for set data. The building block which can be stacked to be deep neural networks is called Permutation Equivariance Layer. One Permutation Equivariance Layer example is defined as
+
+$$
+f ( x _ { i } ) = \sigma ( x _ { i } + \gamma \mathrm { m a x p o o l } ( X ) ) ,
+$$
+
+where $\sigma$ can be any functions (e.g. parametrized by neural networks) and $X = x _ { 1 } , \ldots , x _ { n }$ is an input set. Also, the mox pooling operation can be replaced with mean pooling. We note that PointNetQi et al. (2017a) is a special case of using Permutation Equivariance Layer by properly defining $\sigma ( \cdot )$ . In our experiments, we follow Zaheer et al. (2017) to set $\sigma$ to be a linear layer with output size $h$ followed by any nonlinear activation function.
+
+# F EXPERIMENT SETTINGS
+
+# F.1 SYNTHETIC DATA
+
+The batch size is fixed to be 64. We sampled 10,000 samples for training and testing.
+
+For the inference network, we stack 3 mean Permutation Equivariance Layer (Zaheer et al., 2017), where the hidden layer size (the output of the first two layers ) is 30 and the final output size is 15. The activation function are used SoftPlus. For the generater is a 5 layer MLP, where the hidden layer size is set to be 30. The discirminator is 4 layer MLP with hidden layer size to be 30. For Achlioptas et al. (2017), we change their implementation by replcing the number of filters for encoder to be [30, 30, 30, 30, 15], while the hidden layer width for decoder is 10 or 20 except for the output layer. The decoder is increased from 3 to 4 layers to have more capacity.
+
+# F.2 MODELNET40
+
+We follow Zaheer et al. (2017) to do pre-processing. For each object, we sampled $1 0 , 0 0 0$ points from the mesh representation and normalize it to have zero mean (for each axis) and unit (global) variance. During the training, we augment the data by uniformly rotating $0 , \pi / 8 , \ldots , 7 \pi / 8$ rad on the x-y plane. The random noise $z _ { 2 }$ of PC-GAN is fixed to be 10 dimensional for all experiments.
+
+For $Q$ of single class model, we stack 3 max Permutation Equivariance Layer with output size to be 128 for every layer. On the top of the satck, we have a 2 layer MLP with the same width and the output . The generator $G _ { x }$ is a 4 layer MLP where the hidden layer size is 128 and output size is 3.
+
+The discirminator is 4 layer MLP with hidden layer size to be 128. The random source $u$ and $z$ are set to be 64 and 10 dimensional and sampled from standard normal distributions.
+
+For training whole ModelNet40 training set, we increae the width to be 256. The generator $G _ { x }$ is a 5 layer MLP where the hidden layer size is 256 and output size is 3. The discirminator is 5 layer MLP with hidden layer size to be 256. For hirarchical sampling, the top generator $G _ { \theta }$ and discriminator are all 5-layer MLP with hidden layer size to be 256.
+
+For AAE, we follow every setting used in Achlioptas et al. (2017), where the latent code size is 128 and 256 for single class model and whole ModelNet40 models.

parse/train/H1lma24tPB/H1lma24tPB.md

@@ -0,0 +1,408 @@
+# PRINCIPLED WEIGHT INITIALIZATION FORHYPERNETWORKS
+
+Oscar Chang, Lampros Flokas, Hod Lipson   
+Columbia University   
+New York, NY 10027   
+{oscar.chang, lf2540, hod.lipson}@columbia.edu
+
+# ABSTRACT
+
+Hypernetworks are meta neural networks that generate weights for a main neural network in an end-to-end differentiable manner. Despite extensive applications ranging from multi-task learning to Bayesian deep learning, the problem of optimizing hypernetworks has not been studied to date. We observe that classical weight initialization methods like Glorot & Bengio (2010) and He et al. (2015), when applied directly on a hypernet, fail to produce weights for the mainnet in the correct scale. We develop principled techniques for weight initialization in hypernets, and show that they lead to more stable mainnet weights, lower training loss, and faster convergence.
+
+# 1 INTRODUCTION
+
+Meta-learning describes a broad family of techniques in machine learning that deals with the problem of learning to learn. An emerging branch of meta-learning involves the use of hypernetworks, which are meta neural networks that generate the weights of a main neural network to solve a given task in an end-to-end differentiable manner. Hypernetworks were originally introduced by Ha et al. (2016) as a way to induce weight-sharing and achieve model compression by training the same meta network to learn the weights belonging to different layers in the main network. Since then, hypernetworks have found numerous applications including but not limited to: weight pruning (Liu et al., 2019), neural architecture search (Brock et al., 2017; Zhang et al., 2018), Bayesian neural networks (Krueger et al., 2017; Ukai et al., 2018; Pawlowski et al., 2017; Henning et al., 2018; Deutsch et al., 2019), multi-task learning (Pan et al., 2018; Shen et al., 2017; Klocek et al., 2019; Serra et al., 2019; \` Meyerson & Miikkulainen, 2019), continual learning (von Oswald et al., 2019), generative models (Suarez, 2017; Ratzlaff & Fuxin, 2019), ensemble learning (Kristiadi & Fischer, 2019), hyperparameter optimization (Lorraine & Duvenaud, 2018), and adversarial defense (Sun et al., 2017).
+
+Despite the intensified study of applications of hypernetworks, the problem of optimizing them to this day remains significantly understudied. In fact, even the problem of initializing hypernetworks has not been studied. Given the lack of principled approaches, prior work in the area is mostly limited to ad-hoc approaches based on trial and error (c.f. Section 3). For example, it is common to initialize the weights of a hypernetwork by sampling a “small” random number. Nonetheless, these ad-hoc methods do lead to successful hypernetwork training primarily due to the use of the Adam optimizer (Kingma & Ba, 2014), which has the desirable property of being invariant to the scale of the gradients. However, even Adam will not work if the loss diverges (i.e. overflow) at initialization, which will happen in sufficiently big models. The normalization of badly scaled gradients also results in noisy training dynamics where the loss function suffers from bigger fluctuations during training compared to vanilla stochastic gradient descent (SGD). Wilson et al. (2017); Reddi et al. (2018) showed that while adaptive optimizers like Adam may exhibit lower training error, they fail to generalize as well to the test set as non-adaptive gradient methods. Moreover, Adam incurs a computational overhead and requires 3X the amount of memory for the gradients compared to vanilla SGD.
+
+Small random number sampling is reminiscent of early neural network research (Rumelhart et al., 1986) before the advent of classical weight initialization methods like Xavier init (Glorot & Bengio, 2010) and Kaiming init (He et al., 2015). Since then, a big lesson learned by the neural network optimization community is that architecture specific initialization schemes are important to the robust training of deep networks, as shown recently in the case of residual networks (Zhang et al., 2019). In fact, weight initialization for hypernetworks was recognized as an outstanding open problem by prior work (Deutsch et al., 2019) that had questioned the suitability of classical initialization methods for hypernetworks.
+
+Our results We show that when classical methods are used to initialize the weights of hypernetworks, they fail to produce mainnet weights in the correct scale, leading to exploding activations and losses. This is because classical network weights transform one layer’s activations into another, while hypernet weights have the added function of transforming the hypernet’s activations into the mainnet’s weights. Our solution is to develop principled techniques for weight initialization in hypernetworks based on variance analysis. The hypernet case poses unique challenges. For example, in contrast to variance analysis for classical networks, the case for hypernetworks can be asymmetrical between the forward and backward pass. The asymmetry arises when the gradient flow from the mainnet into the hypernet is affected by the biases, whereas in general, this does not occur for gradient flow in the mainnet. This underscores again why architecture specific initialization schemes are essential. We show both theoretically and experimentally that our methods produce hypernet weights in the correct scale. Proper initialization mitigates exploding activations and gradients or the need to depend on Adam. Our experiments reveal that it leads to more stable mainnet weights, lower training loss, and faster convergence.
+
+Section 2 briefly covers the relevant technical preliminaries, and Section 3 reviews problems with the ad-hoc methods currently deployed by hypernetwork practitioners. We derive novel weight initialization formulae for hypernetworks in Section 4, empirically evaluate our proposed methods in Section 5, and finally conclude in Section 6.
+
+# 2 PRELIMINARIES
+
+Definition. A hypernetwork is a meta neural network $H$ with its own parameters $\phi$ that generates the weights of a main network $\theta$ from some embedding e in a differentiable manner: $\theta = H _ { \phi } ( e )$ . Unlike a classical network, in a hypernetwork, the weights of the main network are not model parameters. Thus the gradients $\Delta \theta$ have to be further backpropagated to the weights of the hypernetwork $\Delta \phi$ , which is then trained via gradient descent $\phi _ { t + 1 } = \phi _ { t } - \lambda \Delta \phi _ { t }$ .
+
+This fundamental difference suggests that conventional knowledge about neural networks may not apply directly to hypernetworks and novel ways of thinking about weight initialization, optimization dynamics and architecture design for hypernetworks are sorely needed.
+
+# 2.1 RICCI CALCULUS
+
+We propose the use of Ricci calculus, as opposed to the more commonly used matrix calculus, as a suitable mathematical language for thinking about hypernetworks. Ricci calculus is useful because it allows us to reason about the derivatives of higher-order tensors with notational ease. For readers not familiar with the index-based notation of Ricci calculus, please refer to Laue et al. (2018) for a good introduction to the topic written from a machine learning perspective.
+
+For a general nth-order tensor $T ^ { i _ { 1 } , \dots , i _ { k } , \dots , i _ { n } }$ , we use ${ \bf d } _ { i _ { k } }$ to refer to the dimension of the index set that $i _ { k }$ is drawn from. We include explicit summations where the relevant expressions might be ambiguous, and use Einstein summation convention otherwise. We use square brackets to denote different layers for added clarity, so for example $W [ t ]$ denotes the $t$ -th weight layer.
+
+# 2.2 XAVIER INITIALIZATION
+
+Glorot & Bengio (2010) derived weight initialization formulae for a feedforward neural network by conducting a variance analysis over activations and gradients. For a linear layer $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ , suppose we make the following Xavier Assumptions at initialization: (1) The $W _ { j } ^ { i }$ , $x ^ { j }$ , and $b ^ { i }$ are all independent of each other. $( 2 ) \forall i , j : \mathbb { E } [ W _ { j } ^ { i } ] = 0$ . (3) $\forall j : \mathbb { E } [ x ^ { j } ] = 0$ . (4) $\forall i : b ^ { i } = 0$ .
+
+Then, $\mathbb { E } [ y ^ { i } ] = 0$ and $\mathrm { V a r } ( y ^ { i } ) = \mathrm { d } _ { j } \mathrm { V a r } ( W _ { j } ^ { i } ) \mathrm { V a r } ( x ^ { j } )$ . To keep the variance of the output and input activations the same, i.e. $\mathsf { V a r } ( y ^ { i } ) = \mathsf { V a r } ( x ^ { j } )$ , we have to sample $W _ { j } ^ { i }$ from a distribution whose variance is equal to the reciprocal of the fan-in: $\begin{array} { r } { \operatorname { V a r } ( W _ { j } ^ { i } ) = \frac { 1 } { \mathrm { d } _ { j } } } \end{array}$ .
+
+If analogous assumptions hold for the backward pass, then to keep the variance of the output and input gradients the same, we have to sample $W _ { j } ^ { i }$ from a distribution whose variance is equal to the reciprocal of the fan-out: $\begin{array} { r } { \mathrm { V a r } ( W _ { j } ^ { i } ) = \frac { 1 } { \mathsf d _ { i } } } \end{array}$ .
+
+Thus, the forward pass and backward pass result in symmetrical formulae. Glorot & Bengio (2010) proposed an initialization based on their harmonic mean: $\begin{array} { r } { \operatorname { V a r } ( W _ { j } ^ { i } ) = \frac { 2 } { \mathbb { d } _ { j } + \mathbb { d } _ { i } } } \end{array}$ .
+
+In general, a feedforward network is non-linear, so these assumptions are strictly invalid. But odd activation functions with unit derivative at 0 results in a roughly linear regime at initialization.
+
+# 2.3 KAIMING INITIALIZATION
+
+He et al. (2015) extended Glorot & Bengio (2010)’s analysis by looking at the case of ReLU activation functions, i.e. $y ^ { i } = W _ { j } ^ { i } \mathrm { R e L U } ( x ^ { j } ) \bar { + } b ^ { i }$ . We can write $z ^ { j } = \operatorname { R e L U } ( x ^ { j } )$ to get
+
+$$
+\operatorname { V a r } ( y ^ { i } ) = \sum _ { j } \mathbb { E } [ ( z ^ { j } ) ^ { 2 } ] \operatorname { V a r } ( W _ { j } ^ { i } ) = \sum _ { j } \frac { 1 } { 2 } \mathbb { E } [ ( x ^ { j } ) ^ { 2 } ] \operatorname { V a r } ( W _ { j } ^ { i } ) = \frac { 1 } { 2 } \mathbb { d } _ { j } \operatorname { V a r } ( W _ { j } ^ { i } ) \operatorname { V a r } ( x ^ { j } ) .
+$$
+
+This results in an extra factor of 2 in the variance formula. $W _ { j } ^ { i }$ have to be symmetric around 0 to enforce Xavier Assumption 3 as the activations and gradients propagate through the layers. He et al. (2015) argued that both the forward or backward version of the formula can be adopted, since the activations or gradients will only be scaled by a depth-independent factor. For convolutional layers, we have to further divide the variance by the size of the receptive field.
+
+‘Xavier init’ and ‘Kaiming init’ are terms that are sometimes used interchangeably. Where there might be confusion, we will refer to the forward version as fan-in init, the backward version as fan-out init, and the harmonic mean version as harmonic init.
+
+# 3 REVIEW OF CURRENT METHODS
+
+In the seminal Ha et al. (2016) paper, the authors identified two distinct classes of hypernetworks: dynamic (for recurrent networks) and static (for convolutional networks). They proposed Orthogonal init (Saxe et al., 2013) for the dynamic class, but omitted discussion of initialization for the static class. The static class has since proven to be the dominant variant, covering all kinds of non-recurrent networks (not just convolutional), and thus will be the central object of our investigation.
+
+Through an extensive literature and code review, we found that hypernet practitioners mostly depend on the Adam optimizer, which is invariant to and normalizes the scale of gradients, for training and resort to one of four weight initialization methods:
+
+M1 Xavier or Kaiming init (as found in Pawlowski et al. (2017); Balazevic et al. (2018); Serra\` et al. (2019); von Oswald et al. (2019)).   
+M2 Small random values (as found in Krueger et al. (2017); Lorraine & Duvenaud (2018)).   
+M3 Kaiming init, but with the output layer scaled by $\frac { 1 } { 1 0 }$ (as found in Ukai et al. (2018)).   
+M4 Kaiming init, but with the hypernet embedding set to be a suitably scaled constant (as found in Meyerson & Miikkulainen (2019)).
+
+M1 uses classical neural network initialization methods to initialize hypernetworks. This fails to produce weights for the main network in the correct scale. Consider the following illustrative example of a one-layer linear hypernet generating a linear mainnet with $T + 1$ layers, given embeddings sampled from a standard normal distribution and weights sampled entry-wise from a zero-mean distribution. We leave the biases out for now, and assume the input data $x [ 1 ]$ is standardized.
+
+$$
+\begin{array} { r l } & { \qquad x [ t + 1 ] ^ { i _ { t + 1 } } = W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } x [ t ] ^ { i _ { t } } , \qquad W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } = H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } e [ t ] ^ { k _ { t } } , \qquad 1 \le t \le T . } \\ & { \qquad \mathrm { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = \mathrm { V a r } ( x [ 1 ] ^ { i _ { 1 } } ) \displaystyle \prod _ { t = 1 } ^ { T } \mathrm { d } _ { i _ { t } } \mathrm { V a r } ( W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } ) = \mathrm { V a r } ( x [ 1 ] ^ { i _ { 1 } } ) \displaystyle \prod _ { t = 1 } ^ { T } \mathrm { d } _ { i _ { t } } \mathrm { d } _ { k _ { t } } \mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) . } \end{array}
+$$
+
+In this case, if the variance of the weights in the hypernet $\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } )$ is equal to the reciprocal of the fan-in ${ \mathrm { d } } _ { k _ { t } }$ , then the variance of the activations $\begin{array} { r } { \operatorname { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = \prod _ { t = 1 } ^ { T } \mathbf { d } _ { i _ { t } } } \end{array}$ explodes. If it is equal to the reciprocal of the fan-out $\mathrm { d } _ { i _ { t } } \mathrm { d } _ { i _ { t + 1 } }$ , then the activation variance $\begin{array} { r } { \operatorname { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = } \end{array}$ $\begin{array} { r } { \prod _ { t = 1 } ^ { T } \frac { \mathrm { d } _ { k _ { t } } } { \mathrm { d } _ { i _ { t } + 1 } } } \end{array}$ dktd is likely to vanish, since the size of the embedding vector is typically small relatively to the width of the mainnet weight layer being generated.
+
+Where the fan-in is of a different scale than the fan-out, the harmonic mean has a scale close to that of the smaller number. Therefore, the fan-in, fan-out, and harmonic variants of Xavier and Kaiming init will all result in activations and gradients that scale exponentially with the depth of the mainnet.
+
+M2 and M3 introduce additional hyperparameters into the model, and the ad-hoc manner in which they work is reminiscent of pre deep learning neural network research, before the introduction of classical initialization methods like Xavier and Kaiming init. This ad-hoc manner is not only inelegant and consumes more compute, but will likely fail for deeper and more complex hypernetworks.
+
+oses  and embeddings can seem to $e [ t ] ^ { k _ { t } }$ to a suitable constantnitialized with the sam $( \mathsf { d } _ { i _ { t } } ^ { - 1 / 2 }$ in this case), such that bothance as Kaiming init. This $W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } }$ $H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } }$ ensures that the variance of the activations in the mainnet are preserved through the layers, but the restrictions on the embeddings might not be desirable in many applications.
+
+Luckily, the fix appears simple — set $\begin{array} { r } { \mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) = \frac { 1 } { \mathsf { d } _ { i _ { t } } \mathsf { d } _ { k _ { t } } } } \end{array}$ . This results in the variance of the generated weights in the mainnet $\begin{array} { r } { \operatorname { V a r } ( W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } ) = \frac { 1 } { \mathrm { d } _ { i _ { t } } } } \end{array}$ resembling conventional neural networks initialized with fan-in init. This suggests a general hypernet weight initialization strategy: initialize the weights of the hypernet such that the mainnet weights approximate classical neural network initialization. We elaborate on and generalize this intuition in Section 4.
+
+# 4 HYPERFAN INITIALIZATION
+
+Most hypernetwork architectures use a linear output layer so that gradients can pass from the mainnet into the hypernet directly without any non-linearities. We make use of this fact in developing methods called hyperfan-in init and hyperfan-out init for hypernetwork weight initialization based on the principle of variance analysis.
+
+# 4.1 HYPERFAN-IN
+
+Proposition. Suppose a hypernetwork comprises a linear output layer. Then, the variance between the input and output activations of a linear layer in the mainnet $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ can be preserved using fan-in init in the hypernetwork with appropriately scaled output layers.
+
+Case 1. The hypernet generates the weights but not the biases of the mainnet. The bias in the mainnet is initialized to zero. We can write the weight generation in the form $W _ { j } ^ { i } = H _ { j k } ^ { i } h ( e ) ^ { k } + \beta _ { j } ^ { i }$ where $h$ computes all but the last layer of the hypernet and $( H , \beta )$ form the output layer. We make the following Hyperfan Assumptions at initialization: (1) Xavier assumptions hold for all the layers in the hypernet. (2) The $H _ { j k } ^ { i }$ , $h ( e ) ^ { k } , \beta _ { j } ^ { i } , x ^ { j }$ , and $b ^ { i }$ are all independent of each other. (3) $\forall i , j , k : \mathbb { E } [ H _ { j k } ^ { i } ] = 0 .$ . (4) $\mathbb { E } [ x ^ { j } ] = 0$ . (5) $\forall i : b ^ { i } = 0$ .
+
+Use fan-in init to initialize the weights for $h$ . Then, $\operatorname { V a r } ( h ( e ) ^ { k } ) = \operatorname { V a r } ( e ^ { l } )$ . If we initialize $H$ with the formula $\begin{array} { r } { \mathrm { V a r } ( H _ { j k } ^ { i } ) = \frac { 1 } { \mathrm { d } _ { j } \mathrm { d } _ { k } \mathrm { V a r } ( e ^ { l } ) } } \end{array}$ and $\beta$ with zeros, we arrive at $\begin{array} { r } { \mathrm { V a r } ( W _ { j } ^ { i } ) = \frac { 1 } { \mathrm { d } _ { j } } } \\ { . } \end{array}$ , which is the formula for fan-in init in the mainnet. The Hyperfan assumptions imply the Xavier assumptions hold in the mainnet, thus preserving the input and output activations.
+
+$$
+\begin{array} { l } { { \displaystyle \mathsf { V a r } ( y ^ { i } ) = \sum _ { j } \mathsf { V a r } ( W _ { j } ^ { i } ) \mathsf { V a r } ( x ^ { j } ) = \sum _ { j } \sum _ { k } \mathsf { V a r } ( H _ { j k } ^ { i } ) \mathsf { V a r } ( h ( e ) ^ { k } ) \mathsf { V a r } ( x ^ { j } ) } \ ~ } \\ { { \displaystyle = \sum _ { j } \sum _ { k } \frac { 1 } { \mathsf { d } _ { j } \mathsf { d } _ { k } \mathsf { V a r } ( e ^ { l } ) } \mathsf { V a r } ( e ^ { l } ) \mathsf { V a r } ( x ^ { j } ) = \mathsf { V a r } ( x ^ { j } ) } . } \end{array}
+$$
+
+Case 2. The hypernet generates both the weights and biases of the mainnet. We can write the weight and bias generation in the form $W _ { j } ^ { i } \ : = \ : H _ { j k } ^ { i } h ( e [ 1 ] ) ^ { k } \ : + \ : \beta _ { j } ^ { i }$ and $b ^ { i } = G _ { l } ^ { i } g ( e [ 2 ] ) ^ { l } + \gamma ^ { i }$ respectively, where $h$ and $g$ compute all but the last layer of the hypernet, and $( H , \beta )$ and $( G , \gamma )$ form the output layers. We modify Hyperfan Assumption $2 \ \mathrm { s o }$ it includes $G _ { l } ^ { i }$ , $g ( e [ 2 ] ) ^ { l }$ , and $\gamma ^ { i }$ , and further assume $\mathrm { V a r } ( x ^ { j } ) = 1$ , which holds at initialization with the common practice of data standardization.
+
+Use fan-in init to initialize the weights for $h$ and $g$ . Then, $\mathrm { V a r } ( h ( e [ 1 ] ) ^ { k } ) ~ = ~ \mathrm { V a r } ( e [ 1 ] ^ { m } )$ and $\operatorname { V a r } ( g ( e [ 2 ] ) ^ { l } ) = \operatorname { V a r } ( e [ 2 ] ^ { n } )$ . If we initialize $H$ with the formula $\begin{array} { r } { \mathrm { V a r } ( H _ { j k } ^ { i } ) = \frac { 1 } { 2 \mathrm { d } _ { j } \mathrm { d } _ { k } \mathrm { V a r } ( e [ 1 ] ^ { m } ) } } \end{array}$ , $G$ with the formula $\begin{array} { r } { \operatorname { V a r } ( G _ { l } ^ { i } ) = \frac { 1 } { 2 \mathrm { d } _ { l } \operatorname { V a r } ( e [ 2 ] ^ { n } ) } } \end{array}$ , and $\beta , \gamma$ with zeros, then the input and output activations in the mainnet can be preserved.
+
+$$
+\begin{array} { l } { \displaystyle \mathrm { V a r } ( y ^ { i } ) = \sum _ { j } \big [ \mathrm { V a r } ( W _ { j } ^ { i } ) \mathrm { V a r } ( x ^ { j } ) \big ] + \mathrm { V a r } ( b ^ { i } ) } \\ { \displaystyle = \sum _ { j } \Bigg [ \sum _ { k } \mathrm { V a r } ( H _ { j k } ^ { i } ) \mathrm { V a r } ( h ( e [ 1 ] ) ^ { k } ) \mathrm { V a r } ( x ^ { j } ) \Bigg ] + \sum _ { l } \mathrm { V a r } ( G _ { l } ^ { i } ) \mathrm { V a r } ( g ( e [ 2 ] ) ^ { l } ) } \\ { \displaystyle = \sum _ { j } \Bigg [ \sum _ { k } \frac { 1 } { 2 \mathrm { d } _ { j } \mathrm { d } _ { k } \mathrm { V a r } ( e [ 1 ] ^ { m } ) } \mathrm { V a r } ( e [ 1 ] ^ { m } ) \mathrm { V a r } ( x ^ { j } ) \Bigg ] + \sum _ { l } \frac { 1 } { 2 \mathrm { d } _ { l } \mathrm { V a r } ( e [ 2 ] ^ { n } ) } \mathrm { V a r } ( e [ 2 ] ^ { n } ) } \\ { \displaystyle = \frac { 1 } { 2 } \mathrm { V a r } ( x ^ { j } ) + \frac { 1 } { 2 } = \mathrm { V a r } ( x ^ { j } ) . } \end{array}
+$$
+
+If we initialize $G _ { j } ^ { i }$ to zeros, then its contribution to the variance will increase during training, causing exploding activations in the mainnet. Hence, we prefer to introduce a factor of $1 / 2$ to divide the variance between the weight and bias generation, where the variance of each component is allowed to either decrease or increase during training. This becomes a problem if the variance of the activations in the mainnet deviates too far away from 1, but we found that it works well in practice.
+
+# 4.2 HYPERFAN-OUT
+
+Case 1. The hypernet generates the weights but not the biases of the mainnet. A similar derivation can be done for the backward pass using analogous assumptions on gradients flowing
+
+in the mainnet: $\begin{array} { r l r } & { \displaystyle \frac { \partial L } { \partial x [ t ] ^ { i _ { t } } } = \frac { \partial L } { \partial x [ t + 1 ] ^ { i _ { t + 1 } } } W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } , } & \\ & { \displaystyle \frac { \partial L } { \partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } = \frac { \partial L } { \partial x [ t + 1 ] ^ { i _ { t + 1 } } } x [ t ] ^ { i _ { t } } , \frac { \partial L } { \partial h [ t ] ( e ) ^ { k _ { t } } } = \frac { \partial L } { \partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } , } & \\ & { \displaystyle \frac { \partial L } { \partial b [ t ] ^ { i _ { t + 1 } } } = \frac { \partial L } { \partial x [ t + 1 ] ^ { i _ { t + 1 } } } , \frac { \partial L } { \partial g [ t ] ( e ) ^ { l _ { t } } } = \frac { \partial L } { \partial b [ t ] ^ { i _ { t + 1 } } } G [ t ] _ { l _ { t } } ^ { i _ { t + 1 } } . } & \end{array}$ through mainnet weights: and through mainnet biases:
+
+If we initialize the output layer $H$ with the analogous hyperfan-out formula $\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) ~ =$ 1di dk Var(ekt ) and the rest of the hypernet with fan-in init, then we can preserve input and output gradients on the mainnet: $\begin{array} { r } { \mathrm { V a r } ( \frac { \partial L } { \partial x [ t ] ^ { i _ { t } } } ) = \mathrm { V a r } ( \frac { \partial L } { \partial x [ t + 1 ] ^ { i _ { t + 1 } } } ) } \end{array}$ r( ∂L∂x[t+1]it+1 ). However, note that the gradients will shrink when flowing from the mainnet to the hypernet: Var( ∂L∂h[t](e)kt ) $\begin{array} { r } { \mathrm { V a r } ( \frac { \partial L } { \partial h [ t ] ( e ) ^ { k _ { t } } } ) = \frac { \mathrm { d } _ { i _ { t } } } { \mathrm { d } _ { k _ { t } } \mathrm { V a r } ( e ^ { k _ { t } } ) } \mathrm { V a r } ( \frac { \partial L } { \partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } ) . } \end{array}$ and scaled by a depth-independent factor due to the use of fan-in rather than fan-out init.
+
+Case 2. The hypernet generates both the weights and biases of the mainnet. In the classical case, the forward version (fan-in init) and the backward version (fan-out init) are symmetrical. This remains true for hypernets if they only generated the weights of the mainnet. However, if they were to also generate the biases, then the symmetry no longer holds, since the biases do not affect the gradient flow in the mainnet but they do so for the hypernet (c.f. Equation 4). Nevertheless, we can initialize $G$ so that it helps hyperfan-out init preserve activation variance on the forward pass as much as possible (keeping the assumption that $\bar { \mathsf { V a r } } ( x ^ { j } ) = 1$ as before):
+
+$$
+\begin{array} { l } { { \displaystyle \mathsf { V a r } ( y ^ { i } ) = \sum _ { j } \left[ \mathsf { V a r } ( W _ { j } ^ { i } x ^ { j } ) \right] + \mathsf { V a r } ( b ^ { i } ) } \ ~ } \\ { { \displaystyle \qquad = \mathsf { d } _ { j } \mathsf { d } _ { k } \mathsf { V a r } ( e [ 1 ] ^ { m } ) \mathsf { V a r } ( H [ \mathsf { h y p e r f a n } \mathsf { - o u t } ] _ { j k } ^ { i } ) \mathsf { V a r } ( x ^ { j } ) + \mathsf { d } _ { l } \mathsf { V a r } ( e [ 2 ] ^ { n } ) \mathsf { V a r } ( G _ { l } ^ { i } ) } \ ~ } \\ { { \displaystyle \qquad = \mathsf { d } _ { j } \mathsf { d } _ { k } \mathsf { V a r } ( e [ 1 ] ^ { m } ) \mathsf { V a r } ( H [ \mathsf { h y p e r f a n } \mathsf { - i n } ] _ { j k } ^ { i } ) \mathsf { V a r } ( x ^ { j } ) } \ ~ } \end{array}
+$$
+
+Plugging in the formulae for Hyperfan-in and Hyperfan-out from above, we get
+
+$$
+\implies \mathrm { V a r } ( G _ { l } ^ { i } ) = \frac { ( 1 - \frac { \mathrm { d } _ { j } } { \mathrm { d } _ { i } } ) } { \mathrm { d } _ { l } \mathrm { V a r } ( e [ 2 ] ^ { n } ) } .
+$$
+
+We summarize the variance formulae for hyperfan-in and hyperfan-out init in Table 1. It is not uncommon to re-use the same hypernet to generate different parts of the mainnet, as was originally done in Ha et al. (2016). We discuss this case in more detail in Appendix Section A.
+
+Table 1: Hyperfan-in and Hyperfan-out Variance Formulae for $W _ { j } ^ { i } = H _ { j k } ^ { i } h ( e [ 1 ] ) ^ { k } + \beta _ { j } ^ { i }$ . If $y ^ { i } =$ $\mathrm { R e L U } ( W _ { j } ^ { i } x ^ { j } + b ^ { i } )$ , then $\mathbb { 1 } _ { \mathrm { R e L U } } = 1$ , else if $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ , then $\mathbb { 1 } _ { \mathrm { R e L U } } = 0$ . If $b ^ { i } = G _ { l } ^ { i } g ( e [ 2 ] ) ^ { l } + \gamma ^ { i }$ , then $\mathbb { 1 } _ { \mathrm { H B i a s } } ~ = ~ 1$ , else if $b ^ { i } \ = \ 0$ , then $\mathbb { 1 } _ { \mathrm { H B i a s } } ~ = ~ 0$ . We initialize $h$ and $g$ with fan-in init, and $\beta _ { j } ^ { i } , \gamma ^ { i } = 0$ . For convolutional layers, we have to further divide $\mathrm { V a r } ( H _ { j k } ^ { i } )$ by the size of the receptive field. Uniform init: $X \sim { \mathcal { U } } ( - { \sqrt { 3 \operatorname { V a r } ( X ) } } , { \sqrt { 3 \operatorname { V a r } ( X ) } } )$ . Normal init: $X \sim { \mathcal { N } } ( 0 , \operatorname { V a r } ( X ) )$ .
+
+<table><tr><td>Initialization</td><td colspan="2">Variance Formula</td><td>Initialization</td><td>Variance Formula</td></tr><tr><td></td><td></td><td>21ReLU</td><td></td><td>21ReLU</td></tr><tr><td>Hyperfan-in</td><td></td><td>Var(Hj）=r(e)</td><td>Hyperfan-outVar(Hjk） =</td><td>didkVar(e[1]m) dj</td></tr><tr><td>Hyperfan-in</td><td>Var(Gi）=</td><td>21ReLU 2dVar(e[2]n)</td><td>Hyperfan-outVar(G&#x27;) = max(</td><td>21ReLU(1- a ,0 dVar(e[2]n)</td></tr></table>
+
+# 5 EXPERIMENTS
+
+We evaluated our proposed methods on four sets of experiments involving different use cases of hypernetworks: feedforward networks, continual learning, convolutional networks, and Bayesian neural networks. In all cases, we optimize with vanilla SGD and sample from the uniform distribution according to the variance formula given by the init method. More experimental details can be found in Appendix Section B.
+
+# 5.1 FEEDFORWARD NETWORKS ON MNIST
+
+As an illustrative first experiment, we train a feedforward network with five hidden layers (500 hidden units), a hyperbolic tangent activation function, and a softmax output layer, on MNIST across four different settings: (1) a classical network with Xavier init, (2) a hypernet with Xavier init that generates the weights of the mainnet, (3) a hypernet with hyperfan-in init that generates the weights of the mainnet, (4) and a hypernet with hyperfan-out init that generates the weights of the mainnet.
+
+The use of hyperfan init methods on a hypernetwork reproduces mainnet weights similar to those that have been trained from Xavier init on a classical network, while the use of Xavier init on a hypernetwork causes exploding activations right at the beginning of training (see Figure 1). Observe in Figure 2 that when the hypernetwork is initialized in the proper scale, the magnitude of generated weights stabilizes quickly. This in turn leads to a more stable training regime, as seen in Figure 3. More visualizations of the activations and gradients of both the mainnet and hypernet can be viewed in Appendix Section B.1. Qualitatively similar observations were made when we replaced the activation function with ReLU and Xavier with Kaiming init, with Kaiming init leading to even bigger activations at initialization.
+
+Suppose now the hypernet generates both the weights and biases of the mainnet instead of just the weights. We found that this architectural change leads the hyperfan init methods to take more time (but still less than Xavier init), to generate stable mainnet weights (c.f. Figure 25 in the Appendix).
+
+![](images/398fd064e8bbdeac3e97457e679647575721ae8effdd4e94ec5058070295c72a.jpg)  
+Figure 1: Mainnet Activations before the Start of Training on MNIST.
+
+![](images/cd093f8ececa31349d2cd7ad774bc83cee15e6ff74e095421ef1db6d1572f81e.jpg)  
+Figure 2: Evolution of Hypernet Output Layer Activations during Training on MNIST. Xavier init results in unstable mainnet weights throughout training, while hyperfan-in and hyperfan-out init result in mainnet weights that stabilize quickly.
+
+![](images/ea9b3ec23ac010201fcf92c1987fba5ad33a9cf0dfff2987d2e542771e759007.jpg)  
+Figure 3: Loss and Test Accuracy Plots on MNIST.
+
+# 5.2 CONTINUAL LEARNING ON REGRESSION TASKS
+
+Continual learning solves the problem of learning tasks in sequence without forgetting prior tasks. von Oswald et al. (2019) used a hypernetwork to learn embeddings for each task as a way to efficiently regularize the training process to prevent catastrophic forgetting. We compare different initialization schemes on their hypernetwork implementation, which generates the weights and biases of a ReLU mainnet with two hidden layers to solve a sequence of three regression tasks.
+
+In Figure 4, we plot the training loss averaged over 15 different runs, with the shaded area showing the standard error. We observe that the hyperfan methods produce smaller training losses at initialization and during training, eventually converging to a smaller loss for each task.
+
+![](images/759225e1953b3e8dfdbc6e79da51ffa690f5bb84fb8fc447f07360f36118734f.jpg)  
+Figure 4: Continual Learning Loss on a Sequence of Regression Tasks.
+
+# 5.3 CONVOLUTIONAL NETWORKS ON CIFAR-10
+
+Ha et al. (2016) applied a hypernetwork on a convolutional network for image classification on CIFAR-10. We note that our initialization methods do not handle residual connections, which were in their chosen mainnet architecture and are important topics for future study. Instead, we implemented their hypernetwork architecture on a mainnet with the All Convolutional Net architecture (Springenberg et al., 2014) that is composed of convolutional layers and ReLU activation functions.
+
+After searching through a dense grid of learning rates, we failed to enable the fan-in version of Kaiming init to train even with very small learning rates. The fan-out version managed to begin delayed training, starting from around epoch 270 (see Figure 5). By contrast, both hyperfan-in and hyperfan-out init led to successful training immediately. This shows a good init can make it possible to successfully train models that would have otherwise been unamenable to training on a bad init.
+
+![](images/7668061b86319ef7850b1d345783739865ecafb278107d807114648702168d09.jpg)  
+Figure 5: Loss and Test Accuracy Plots on CIFAR-10.
+
+# 5.4 BAYESIAN NEURAL NETWORKS ON IMAGENET
+
+Bayesian neural networks improve model calibration and provide uncertainty estimation, which guard against the pitfalls of overconfident networks. Ukai et al. (2018) developed a Bayesian neural network by using a hypernetwork to simulate an expressive prior distribution. We trained a similar hypernetwork by applying Ukai et al. (2018)’s methods on ImageNet, but differed in our choice of MobileNet (Howard et al., 2017) as a mainnet architecture that does not have residual connections.
+
+In the work of Ukai et al. (2018), it was noticed that even with the use of batch normalization in the mainnet, classical initialization approaches still led to diverging losses (due to exploding activations, c.f. Section 3). We observe similar results in our experiment (see Figure 6) — the fan-in version of Kaiming init, which is the default initialization in popular deep learning libraries like PyTorch and Chainer, resulted in substantially higher initial losses and led to slower training than the hyperfan methods. We found that the observation still stands even when the last layer of the mainnet is not generated by the hypernet. This shows that while batch normalization helps, it is not the solution for a bad init that causes exploding activations. Our approach solves this problem in a principled way, and is preferable to the trial-and-error based heuristics that Ukai et al. (2018) had to resort to in order to train their model.
+
+Surprisingly, the fan-out version of Kaiming init led to similar results as the hyperfan methods, suggesting that batch normalization might be sufficient to correct the bad initializations that result in vanishing activations. That being said, hypernet practitioners should not expect batch normalization to be the panacea for problems caused by bad initialization, especially in memory-constrained scenarios. In a Bayesian neural network application (especially in hypernet architectures without relaxed weight-sharing), the blowup in the number of parameters limits the use of big batch sizes, which is essential to the performance of batch normalization (Wu & He, 2018). For example, in this experiment, our hypernet model requires 32 times as many parameters as a classical MobileNet.
+
+To the best of our knowledge, the interaction between batch normalization and initialization is not well-understood, even in the classical case, and thus, our findings prompt an interesting direction for future research.
+
+![](images/cf7d8d08869fdeacf17d9b56a759f1ed04f371960aaa790693e39c9d9b31ee49.jpg)  
+Figure 6: Loss and Test Accuracy Plots on ImageNet.
+
+In all our experiments, hyperfan-in and hyperfan-out both led to successful hypernetwork training with SGD. We did not find a good reason to prefer one over the other (similar to He et al. (2015)’s observation in the classical case for fan-in and fan-out init).
+
+# 6 CONCLUSION
+
+For a long time, the promise of deep nets to learn rich representations of the world was left unfulfilled due to the inability to train these models. The discovery of greedy layer-wise pre-training (Hinton et al., 2006; Bengio et al., 2007) and later, Xavier and Kaiming init, as weight initialization strategies to enable such training was a pivotal achievement that kickstarted the deep learning revolution. This underscores the importance of model initialization as a fundamental step in learning complex representations.
+
+In this work, we developed the first principled weight initialization methods for hypernetworks, a rapidly growing branch of meta-learning. We hope our work will spur momentum towards the development of principled techniques for building and training hypernetworks, and eventually lead to significant progress in learning meta representations. Other non-hypernetwork methods of neural network generation (Stanley et al., 2009; Koutnik et al., 2010) can also be improved by considering whether their generated weights result in exploding activations and how to avoid that if so.
+
+# 7 ACKNOWLEDGEMENTS
+
+This research was supported in part by the US Defense Advanced Research Project Agency (DARPA) Lifelong Learning Machines Program, grant HR0011-18-2-0020. We thank Dan Martin and Yawei Li for helpful discussions, and the ICLR reviewers for their constructive feedback.
+
+# REFERENCES
+
+Ivana Balazevic, Carl Allen, and Timothy M Hospedales. Hypernetwork knowledge graph embeddings. arXiv preprint arXiv:1808.07018, 2018.
+
+Yoshua Bengio, Pascal Lamblin, Dan Popovici, and Hugo Larochelle. Greedy layer-wise training of deep networks. In Advances in neural information processing systems, pp. 153–160, 2007.
+
+Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017.
+
+Lior Deutsch, Erik Nijkamp, and Yu Yang. A generative model for sampling high-performance and diverse weights for neural networks. arXiv preprint arXiv:1905.02898, 2019.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+Christian Henning, Johannes von Oswald, Joao Sacramento, Simone Carlo Surace, Jean-Pascal Pfis- ˜ ter, and Benjamin F Grewe. Approximating the predictive distribution via adversarially-trained hypernetworks. In Bayesian Deep Learning Workshop, NeurIPS (Spotlight), volume 2018, 2018.
+
+Geoffrey E Hinton, Simon Osindero, and Yee-Whye Teh. A fast learning algorithm for deep belief nets. Neural computation, 18(7):1527–1554, 2006.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Sylwester Klocek, Łukasz Maziarka, Maciej Wołczyk, Jacek Tabor, Marek Smieja, and Jakub ´ Nowak. Hypernetwork functional image representation. arXiv preprint arXiv:1902.10404, 2019.
+
+Jan Koutnik, Faustino Gomez, and Jurgen Schmidhuber. Evolving neural networks in compressed ¨ weight space. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 619–626. ACM, 2010.
+
+Agustinus Kristiadi and Asja Fischer. Predictive uncertainty quantification with compound density networks. arXiv preprint arXiv:1902.01080, 2019.
+
+David Krueger, Chin-Wei Huang, Riashat Islam, Ryan Turner, Alexandre Lacoste, and Aaron Courville. Bayesian hypernetworks. arXiv preprint arXiv:1710.04759, 2017.
+
+Soren Laue, Matthias Mitterreiter, and Joachim Giesen. Computing higher order derivatives of ¨ matrix and tensor expressions. In Advances in Neural Information Processing Systems, pp. 2755– 2764, 2018.
+
+Zechun Liu, Haoyuan Mu, Xiangyu Zhang, Zichao Guo, Xin Yang, Tim Kwang-Ting Cheng, and Jian Sun. Metapruning: Meta learning for automatic neural network channel pruning. arXiv preprint arXiv:1903.10258, 2019.
+
+Jonathan Lorraine and David Duvenaud. Stochastic hyperparameter optimization through hypernetworks. arXiv preprint arXiv:1802.09419, 2018.
+
+Elliot Meyerson and Risto Miikkulainen. Modular universal reparameterization: Deep multi-task learning across diverse domains. arXiv preprint arXiv:1906.00097, 2019.
+
+Zheyi Pan, Yuxuan Liang, Junbo Zhang, Xiuwen Yi, Yong Yu, and Yu Zheng. Hyperst-net: Hypernetworks for spatio-temporal forecasting. arXiv preprint arXiv:1809.10889, 2018.
+
+Nick Pawlowski, Andrew Brock, Matthew CH Lee, Martin Rajchl, and Ben Glocker. Implicit weight uncertainty in neural networks. arXiv preprint arXiv:1711.01297, 2017.
+
+Neale Ratzlaff and Li Fuxin. Hypergan: A generative model for diverse, performant neural networks. arXiv preprint arXiv:1901.11058, 2019.
+
+Sashank J. Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. In International Conference on Learning Representations, 2018. URL https://openreview. net/forum?id $=$ ryQu7f-RZ.
+
+David E Rumelhart, Geoffrey E Hintont, and Ronald J Williams. Learning representations by backpropagating errors. NATURE, 323:9, 1986.
+
+Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013.
+
+Joan Serra, Santiago Pascual, and Carlos Segura. Blow: a single-scale hyperconditioned flow for \` non-parallel raw-audio voice conversion. arXiv preprint arXiv:1906.00794, 2019.
+
+Falong Shen, Shuicheng Yan, and Gang Zeng. Meta networks for neural style transfer. arXiv preprint arXiv:1709.04111, 2017.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.
+
+Kenneth O Stanley, David B D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artificial life, 15(2):185–212, 2009.
+
+Joseph Suarez. Language modeling with recurrent highway hypernetworks. In Advances in neural information processing systems, pp. 3267–3276, 2017.
+
+Zhun Sun, Mete Ozay, and Takayuki Okatani. Hypernetworks with statistical filtering for defending adversarial examples. arXiv preprint arXiv:1711.01791, 2017.
+
+Kenya Ukai, Takashi Matsubara, and Kuniaki Uehara. Hypernetwork-based implicit posterior estimation and model averaging of cnn. In Asian Conference on Machine Learning, pp. 176–191, 2018.
+
+Johannes von Oswald, Christian Henning, Joao Sacramento, and Benjamin F Grewe. Continual ˜ learning with hypernetworks. arXiv preprint arXiv:1906.00695, 2019.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nati Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, pp. 4148–4158, 2017.
+
+Yuxin Wu and Kaiming He. Group normalization. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 3–19, 2018.
+
+Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. arXiv preprint arXiv:1810.05749, 2018.
+
+Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. arXiv preprint arXiv:1901.09321, 2019.
+
+# APPENDIX
+
+# A RE-USING HYPERNET WEIGHTS
+
+# A.1 FOR MAINNET WEIGHTS OF THE SAME SIZE
+
+For model compression or weight-sharing purposes, different parts of the mainnet might be generated by the same hypernet function. This will cause some assumptions of independence in our analysis to be invalid. Consider the example of the same hypernet being used to generate multiple different mainnet weight layers of the same size, i.e. $\begin{array} { r } { H [ t ] _ { i _ { t } k } ^ { i _ { t + 1 } } = H [ t + 1 ] _ { i _ { t + 1 } k } ^ { i _ { t + 2 } } , \mathsf { d } _ { i _ { t + 1 } } = \mathsf { d } _ { i _ { t + 2 } } = \mathsf { d } _ { i _ { t } } } \end{array}$ . Then, $x [ t + 1 ] ^ { i _ { t + 1 } } = H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } e [ t ] ^ { k _ { t } } x [ t ] ^ { i _ { t } }$ t 6⊥⊥ $W [ t + 1 ] _ { i _ { t + 1 } } ^ { i _ { t + 2 } } = H [ t + 1 ] _ { i _ { t + 1 } k } ^ { i _ { t + 2 } } e [ t + 1 ] ^ { k _ { t + 1 } }$
+
+The relaxation of some of these independence assumptions does not always prove to be a big problem in practice, because the correlations introduced by repeated use of $H$ can be minimized with the use of flat distributions like the uniform distribution. It can even be helpful, since the re-use of the same hypernet for different layers causes the gradient flowing through the hypernet output layer to be the sum of the gradients from the weights of these layers: $\begin{array} { r } { \frac { \partial L } { \partial h ( e ) ^ { k } } = \sum _ { t } \frac { \partial L } { \partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } H _ { i _ { t } k } ^ { i _ { t + 1 } } } \end{array}$ H it+1i k , thus combating the shrinking effect.
+
+# A.2 FOR MAINNET WEIGHTS OF DIFFERENT SIZES
+
+Similar reasoning applies if the same hypernet was used to generate differently sized subsets of weights in the mainnet. However, we encourage avoiding this kind of hypernet architecture design if not otherwise essential, since it will complicate the initialization formulae listed in Table 1.
+
+Consider Ha et al. (2016)’s hypernetwork architecture. Their two-layer hypernet generated weight chunks of size $( K , n , n )$ for a main convolutional network where $K = 1 6$ was found to be the highest common factor among the size of mainnet layers, and ${ n ^ { 2 } = 9 }$ was the size of the receptive field. We simplify the presentation by writing $i$ for $i _ { t }$ , $j$ for $j _ { t }$ , $k$ for $k _ { t , m }$ , and $l$ for $l _ { t , m }$ .
+
+$$
+\begin{array} { r l } & { W [ t ] _ { j } ^ { i } = \left\{ \begin{array} { l l } { H _ { k } ^ { i ( \mathrm { m o d } K ) } \alpha [ t ] [ j + \lfloor \frac { i } { K } \rfloor \mathbf { d } _ { j } ] ^ { k } + \beta ^ { i ( \mathrm { m o d } K ) } } & { \mathrm { i f ~ } i \mathrm { i s ~ d i v i s i b l e ~ b y ~ } K } \\ { \delta _ { j ( \mathrm { m o d } K ) j ( \mathrm { m o d } K ) } \left[ H _ { k } ^ { j ( \mathrm { m o d } K ) } \alpha [ t ] [ i + \lfloor \frac { j } { K } \rfloor \mathbf { d } _ { i } ] ^ { k } + \beta ^ { j ( \mathrm { m o d } K ) } \right] } & { \mathrm { i f ~ } j \mathrm { ~ i s ~ d i v i s i b l e ~ b y ~ } K } \end{array} \right. } \\ & { \left. \times [ t ] [ m _ { t } ] ^ { k } = G [ t ] [ m _ { t } ] _ { i } ^ { k } e [ t ] [ m _ { t } ] ^ { l } + \gamma [ t ] [ m _ { t } ] ^ { k } \right. } \end{array}
+$$
+
+Because the output layer $( H , \beta )$ in the hypernet was re-used to generate mainnet weight matrices of different sizes (i.e. in general, $i _ { t } \neq i _ { t + 1 } , j _ { t } \neq j _ { t + 1 } )$ , $G$ effectively becomes the output layer that we want to be considering for hyperfan-in and hyperfan-out initialization.
+
+Hence, to achieve fan-in in the mainnet $\begin{array} { r } { \operatorname { V a r } ( W [ t ] _ { j } ^ { i } ) = \frac { 1 } { \mathsf { d } _ { j } } } \end{array}$ , we have to use fan-in init for $H$ (i.e.   
+$\begin{array} { r } { \mathrm { V a r } ( H _ { k } ^ { i ( \mathrm { m o d } K ) } ) ~ = ~ \frac { 1 } { \mathrm { d } _ { k } } ~ \ne ~ \frac { 1 } { \mathrm { d } _ { j } \mathrm { d } _ { k } \mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } ) } \end{array}$ , and hyperfan-in init for $G$ (i.e. $\mathrm { V a r } ( G [ t ] [ m _ { t } ] _ { l } ^ { k } ) ~ =$   
+dj dlVar(e[t][mt]l) ).
+
+Analogously, to achieve fan-out in the mainnet $\begin{array} { r } { \operatorname { V a r } ( W [ t ] _ { j } ^ { i } ) = \frac { 1 } { \mathrm { d } _ { i } } } \end{array}$ , we have to use fan-in init for $H$ $\begin{array} { r } { \mathrm { V a r } ( H _ { k } ^ { i ( \mathrm { m o d } K ) } ) = \frac { 1 } { \mathrm { d } _ { k } } \ne \frac { 1 } { \mathrm { d } _ { i } \mathrm { d } _ { k } \mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } ) } \end{array}$ , and hyperfan-out init for $G$ (i.e. $\mathrm { V a r } ( G [ t ] [ m _ { t } ] _ { l } ^ { k } ) =$ ${ \frac { 1 } { \mathbf { d } _ { i } \mathbf { d } _ { l } \mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } } \big )$
+
+# B MORE EXPERIMENTAL DETAILS
+
+# B.1 FEEDFORWARD NETWORKS ON MNIST
+
+The networks were trained on MNIST for 30 epochs with batch size 10 using a learning rate of 0.0005 for the hypernets and 0.01 for the classical network. The hypernets had one linear layer with embeddings of size 50 and different hidden layers in the mainnet were all generated by the same√ √ hypernet output layer with a different embedding, which was randomly sampled from $\mathcal { U } ( - \sqrt { 3 } , \sqrt { 3 } )$ and fixed. We use the mean cross entropy loss for training, but the summed cross entropy loss for testing.
+
+We show activation and gradient plots for two cases: (i) the hypernet generates only the weights of the mainnet, and (ii) the hypernet generates both the weights and biases of the mainnet. (i) covers Figures 3, 1, 7, 8, 9, 10, 11, 12, 2, 13, 14, 15, and 16. (ii) covers Figures 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, and 29.
+
+The activations and gradients in our plots were calculated by averaging across a fixed held-out set of 300 examples drawn randomly from the test set.
+
+In Figures 1, 8, 9, 11, 12, 13, 14, 16, 18, 20, 21, 23, 24, 26, 27, and 29, the y axis shows the number of activations/gradients, while the x axis shows the value of the activations/gradients. The value of activations/gradients from the hypernet output layer correspond to the value of mainnet weights.
+
+In Figures 2, 7, 10, 15, 19, 22, 25, and 28, the y axis shows the mean value of the activations/gradients, while each increment on the $\mathbf { X }$ axis corresponds to a measurement that was taken every 1000 training batches, with the bars denoting one standard deviation away from the mean.
+
+![](images/5ad9b55dd9ec7bf3f031f5abb5baf71586d95e11bf6dda303a2fcc03b381c706.jpg)  
+B.1.1 HYPERNET GENERATES ONLY THE MAINNET WEIGHTS   
+Figure 7: Evolution of Mainnet Activations during Training on MNIST.
+
+![](images/0c63046dbf51db8f2dc0237824fed4d2e9aebd99be2a2d30f9fe791d95f0f38e.jpg)  
+Figure 8: Mainnet Activations at the End of Training on MNIST.
+
+![](images/326add1208ab6c36e4724d5eea053231c59e15b9f30936bb032284c73f5af2bb.jpg)  
+Figure 9: Mainnet Gradients before the Start of Training on MNIST.
+
+![](images/62c1fcdd47b1e4a87d57c69401e1a251ab6d4fc89f19e55c41c4921fa24dca4e.jpg)  
+Figure 10: Evolution of Mainnet Gradients during Training on MNIST.
+
+![](images/3ef62276365c6a0c0a174b30c782a72bb2e23804b837ef376545f079cbb821f1.jpg)  
+Figure 11: Mainnet Gradients at the End of Training on MNIST.
+
+![](images/7715f3a0b91a444ba88326071c224b404a6302d576bdb348355eb9011fd6c948.jpg)  
+Figure 12: Hypernet Output Layer Activations before the Start of Training on MNIST.
+
+![](images/de6647baea08df0e6d3ebd8dfdb512949ceafdab17c908b6f5ff4d0e448983c7.jpg)  
+Figure 13: Hypernet Output Layer Activations at the End of Training on MNIST.
+
+![](images/e6b0f3ae1a7fddc0d383a19e0d0445576f01f540068faec6d4a6c71afda1f500.jpg)  
+Figure 14: Hypernet Output Layer Gradients before the Start of Training on MNIST.
+
+![](images/ddce62a81a34c7bfabaff0c611766d3a51b109b03e4eea3bbe94fe6957d025a9.jpg)  
+Figure 15: Evolution of Hypernet Output Layer Gradients during Training on MNIST.
+
+![](images/31d214815e89c9a16ecb28bb247c285b4888127c1d1b9b70894fd036688ffc2c.jpg)  
+Figure 16: Hypernet Output Layer Gradients at the End of Training on MNIST.
+
+![](images/4287f21cbf1a00d421681d5f87844e454e4d798c3735347082ac36369934b773.jpg)  
+B.1.2 HYPERNET GENERATES BOTH MAINNET WEIGHTS AND BIASES   
+Figure 17: Loss and Test Accuracy Plots on MNIST.
+
+![](images/91418bf64ad3ce38e4e69a011d9af73b3d08369a30b71d5c5dc0e79b6f38f56e.jpg)  
+Figure 18: Mainnet Activations before the Start of Training on MNIST.
+
+![](images/7296457f25f277ee74aa414dfd250f2dfe3bd9e2ad19234a698be544a2f6641f.jpg)  
+Figure 19: Evolution of Mainnet Activations during Training on MNIST.
+
+![](images/d3bc27149fd378f4be3413056eeaa1dd907f94731d15985ed741b1adda038d69.jpg)  
+Figure 20: Mainnet Activations at the End of Training on MNIST.
+
+![](images/1241190b9c8282900502bcd8123dbbe02db49a741730f50e53ed45dbf725a008.jpg)  
+Figure 21: Mainnet Gradients before the Start of Training on MNIST.
+
+![](images/d30a1c5e6540632ec19307216bfcc9c1bf027ac147e02b35b7f6c10b484cd025.jpg)  
+Figure 22: Evolution of Mainnet Gradients during Training on MNIST.
+
+![](images/a726295563a94ea8b0b6c15a1bb0ec85aea62f0bb7227989c0c62b4a6f27a90a.jpg)  
+Figure 23: Mainnet Gradients at the End of Training on MNIST.
+
+![](images/77323ddca1860a56057375f57ef03a72936016ba5cbce8c26fe00d5310213d3e.jpg)  
+Figure 24: Hypernet Output Layer Activations before the Start of Training on MNIST.
+
+![](images/9d817c31284315aba6647c77ebb8a9afa3ecc3700c82c9ccfcb41bb42e22f858.jpg)  
+Figure 25: Evolution of Hypernet Output Layer Activations during Training on MNIST.
+
+![](images/56026f4e97d7e379a614942b22a7ffc40a406a8bf33ec0a7c07b6df36e7215b0.jpg)  
+Figure 26: Hypernet Output Layer Activations at the End of Training on MNIST.
+
+![](images/51ae1852a9f6a32993ce3a7097bb9d1e61e776de968bde9f358e5b1c1632f1bf.jpg)  
+Figure 27: Hypernet Output Layer Gradients before the Start of Training on MNIST.
+
+![](images/8e6c0ca464c04e4954fe6612ca993895012190b437d9a049140076f5769da66f.jpg)  
+Figure 28: Evolution of Hypernet Output Layer Gradients during Training on MNIST.
+
+![](images/7c88c933892305fb34cf49b49bb0626def6d0900b413b3fbe5338e4e64195d8d.jpg)  
+Figure 29: Hypernet Output Layer Gradients at the End of Training on MNIST.
+
+# B.1.3 REMARK ON THE COMBINATION OF FAN-IN AND FAN-OUT INIT
+
+Glorot & Bengio (2010) proposed to use the harmonic mean of the two different initialization formulae derived from the forward and backward pass. He et al. (2015) commented that either version suffices for convergence, and that it does not really matter given that the difference between the two will be a depth-independent factor.
+
+We experimented with the harmonic, geometric, and arithmetic means of the two different formulae in both the classical and the hypernet case. There was no indication of any significant benefit from taking any of the three different means in both cases. Thus, we confirm and concur with He et al. (2015)’s original observation that either the fan-in or the fan-out version suffices.
+
+# B.2 CONTINUAL LEARNING ON REGRESSION TASKS
+
+The mainnet is a feedforward network with two hidden layers (10 hidden units) and the ReLU activation function. The weights and biases of the mainnet are generated from a hypernet with two hidden layers (10 hidden units) and trainable embeddings of size 2 sampled from ${ \dot { \mathcal { U } } } ( - { \sqrt { 3 } } , { \sqrt { 3 } } )$ . We keep the same continual learning hyperparameter $\beta _ { o u t p u t }$ value of 0.005 and pick the best learning rate for each initialization method from $\{ 1 0 ^ { - 2 } , 1 0 ^ { - 3 } , 1 \bar { 0 } ^ { - 4 } , 1 0 ^ { - 5 } \}$ . Notably, Kaiming (fan-in) could only be trained from learning rate $1 0 ^ { - 5 }$ , with losses diverging soon after initialization using the other learning rates. Each task was trained for 6000 training iterations using batch size 32, with Figure 4 plotted from losses measured at every 100 iterations.
+
+# B.3 CONVOLUTIONAL NETWORKS ON CIFAR-10
+
+The networks were trained on CIFAR-10 for 500 epochs starting with an initial learning rate of 0.0005 using batch size 100, and decaying with $\gamma = 0 . 1$ at epochs 350 and 450. The hypernet is composed of two layers (50 hidden units) with separate embeddings and separate input layers but shared output layers. The weight generation happens in blocks of $( 9 6 , 3 , 3 )$ where $K = 9 6$ is the highest common factor between the different sizes of the convolutional layers in the mainnet and $n =$ 3 is the size of the convolutional filters (see Appendix Section A.2 for a more detailed explanation on the hypernet architecture). The embeddings are size 50 and fixed after random sampling from $\mathcal { U } ( - \sqrt { 3 } , \sqrt { 3 } )$ . We use the mean cross entropy loss for training, but the summed cross entropy loss for testing.
+
+# B.4 BAYESIAN NEURAL NETWORK ON IMAGENET
+
+Ukai et al. (2018) showed that a Bayesian neural network can be developed by using a hypernetwork to express a prior distribution without substantial changes to the vanilla hypernetwork setting. Their methods simply require putting $\mathcal { L } _ { 2 }$ -regularization on the model parameters and sampling from stochastic embeddings. We trained a linear hypernet to generate the weights of a MobileNet mainnet architecture (excluding the batch normalization layers), using the block-wise sampling strategy described in Ukai et al. (2018), with a factor of 0.0005 for the $\mathcal { L } _ { 2 }$ -regularization. We initialize fixed embeddings of size 32 sampled from $\mathcal { U } ( - \sqrt { 3 } , \sqrt { 3 } )$ , and sample additive stochastic noise coming from $\mathcal { U } ( - \mathrm { { \bar { 0 } } } . 1 , 0 . 1 )$ at the beginning of every mini-batch training. The training was done on ImageNet with batch size 256 and learning rate 0.1 for 25 epochs, or equivalently, 125125 iterations. The testing was done with 10 Monte Carlo samples. We omit the test loss plots due to the computational expense of doing 10 forward passes after every mini-batch instead of every epoch.

parse/train/H1lma24tPB/H1lma24tPB_content_list.json

@@ -0,0 +1,2168 @@
+[
+    {
+        "type": "text",
+        "text": "PRINCIPLED WEIGHT INITIALIZATION FORHYPERNETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            687,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Oscar Chang, Lampros Flokas, Hod Lipson   \nColumbia University   \nNew York, NY 10027   \n{oscar.chang, lf2540, hod.lipson}@columbia.edu ",
+        "bbox": [
+            184,
+            170,
+            632,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hypernetworks are meta neural networks that generate weights for a main neural network in an end-to-end differentiable manner. Despite extensive applications ranging from multi-task learning to Bayesian deep learning, the problem of optimizing hypernetworks has not been studied to date. We observe that classical weight initialization methods like Glorot & Bengio (2010) and He et al. (2015), when applied directly on a hypernet, fail to produce weights for the mainnet in the correct scale. We develop principled techniques for weight initialization in hypernets, and show that they lead to more stable mainnet weights, lower training loss, and faster convergence. ",
+        "bbox": [
+            233,
+            295,
+            764,
+            419
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            446,
+            336,
+            463
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Meta-learning describes a broad family of techniques in machine learning that deals with the problem of learning to learn. An emerging branch of meta-learning involves the use of hypernetworks, which are meta neural networks that generate the weights of a main neural network to solve a given task in an end-to-end differentiable manner. Hypernetworks were originally introduced by Ha et al. (2016) as a way to induce weight-sharing and achieve model compression by training the same meta network to learn the weights belonging to different layers in the main network. Since then, hypernetworks have found numerous applications including but not limited to: weight pruning (Liu et al., 2019), neural architecture search (Brock et al., 2017; Zhang et al., 2018), Bayesian neural networks (Krueger et al., 2017; Ukai et al., 2018; Pawlowski et al., 2017; Henning et al., 2018; Deutsch et al., 2019), multi-task learning (Pan et al., 2018; Shen et al., 2017; Klocek et al., 2019; Serra et al., 2019; \\` Meyerson & Miikkulainen, 2019), continual learning (von Oswald et al., 2019), generative models (Suarez, 2017; Ratzlaff & Fuxin, 2019), ensemble learning (Kristiadi & Fischer, 2019), hyperparameter optimization (Lorraine & Duvenaud, 2018), and adversarial defense (Sun et al., 2017). ",
+        "bbox": [
+            174,
+            479,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite the intensified study of applications of hypernetworks, the problem of optimizing them to this day remains significantly understudied. In fact, even the problem of initializing hypernetworks has not been studied. Given the lack of principled approaches, prior work in the area is mostly limited to ad-hoc approaches based on trial and error (c.f. Section 3). For example, it is common to initialize the weights of a hypernetwork by sampling a “small” random number. Nonetheless, these ad-hoc methods do lead to successful hypernetwork training primarily due to the use of the Adam optimizer (Kingma & Ba, 2014), which has the desirable property of being invariant to the scale of the gradients. However, even Adam will not work if the loss diverges (i.e. overflow) at initialization, which will happen in sufficiently big models. The normalization of badly scaled gradients also results in noisy training dynamics where the loss function suffers from bigger fluctuations during training compared to vanilla stochastic gradient descent (SGD). Wilson et al. (2017); Reddi et al. (2018) showed that while adaptive optimizers like Adam may exhibit lower training error, they fail to generalize as well to the test set as non-adaptive gradient methods. Moreover, Adam incurs a computational overhead and requires 3X the amount of memory for the gradients compared to vanilla SGD. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Small random number sampling is reminiscent of early neural network research (Rumelhart et al., 1986) before the advent of classical weight initialization methods like Xavier init (Glorot & Bengio, 2010) and Kaiming init (He et al., 2015). Since then, a big lesson learned by the neural network optimization community is that architecture specific initialization schemes are important to the robust training of deep networks, as shown recently in the case of residual networks (Zhang et al., 2019). In fact, weight initialization for hypernetworks was recognized as an outstanding open problem by prior work (Deutsch et al., 2019) that had questioned the suitability of classical initialization methods for hypernetworks. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our results We show that when classical methods are used to initialize the weights of hypernetworks, they fail to produce mainnet weights in the correct scale, leading to exploding activations and losses. This is because classical network weights transform one layer’s activations into another, while hypernet weights have the added function of transforming the hypernet’s activations into the mainnet’s weights. Our solution is to develop principled techniques for weight initialization in hypernetworks based on variance analysis. The hypernet case poses unique challenges. For example, in contrast to variance analysis for classical networks, the case for hypernetworks can be asymmetrical between the forward and backward pass. The asymmetry arises when the gradient flow from the mainnet into the hypernet is affected by the biases, whereas in general, this does not occur for gradient flow in the mainnet. This underscores again why architecture specific initialization schemes are essential. We show both theoretically and experimentally that our methods produce hypernet weights in the correct scale. Proper initialization mitigates exploding activations and gradients or the need to depend on Adam. Our experiments reveal that it leads to more stable mainnet weights, lower training loss, and faster convergence. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Section 2 briefly covers the relevant technical preliminaries, and Section 3 reviews problems with the ad-hoc methods currently deployed by hypernetwork practitioners. We derive novel weight initialization formulae for hypernetworks in Section 4, empirically evaluate our proposed methods in Section 5, and finally conclude in Section 6. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            438
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            464,
+            338,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition. A hypernetwork is a meta neural network $H$ with its own parameters $\\phi$ that generates the weights of a main network $\\theta$ from some embedding e in a differentiable manner: $\\theta = H _ { \\phi } ( e )$ . Unlike a classical network, in a hypernetwork, the weights of the main network are not model parameters. Thus the gradients $\\Delta \\theta$ have to be further backpropagated to the weights of the hypernetwork $\\Delta \\phi$ , which is then trained via gradient descent $\\phi _ { t + 1 } = \\phi _ { t } - \\lambda \\Delta \\phi _ { t }$ . ",
+        "bbox": [
+            174,
+            500,
+            825,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This fundamental difference suggests that conventional knowledge about neural networks may not apply directly to hypernetworks and novel ways of thinking about weight initialization, optimization dynamics and architecture design for hypernetworks are sorely needed. ",
+        "bbox": [
+            176,
+            584,
+            825,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 RICCI CALCULUS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            338,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose the use of Ricci calculus, as opposed to the more commonly used matrix calculus, as a suitable mathematical language for thinking about hypernetworks. Ricci calculus is useful because it allows us to reason about the derivatives of higher-order tensors with notational ease. For readers not familiar with the index-based notation of Ricci calculus, please refer to Laue et al. (2018) for a good introduction to the topic written from a machine learning perspective. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For a general nth-order tensor $T ^ { i _ { 1 } , \\dots , i _ { k } , \\dots , i _ { n } }$ , we use ${ \\bf d } _ { i _ { k } }$ to refer to the dimension of the index set that $i _ { k }$ is drawn from. We include explicit summations where the relevant expressions might be ambiguous, and use Einstein summation convention otherwise. We use square brackets to denote different layers for added clarity, so for example $W [ t ]$ denotes the $t$ -th weight layer. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            810
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 XAVIER INITIALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            385,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Glorot & Bengio (2010) derived weight initialization formulae for a feedforward neural network by conducting a variance analysis over activations and gradients. For a linear layer $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ , suppose we make the following Xavier Assumptions at initialization: (1) The $W _ { j } ^ { i }$ , $x ^ { j }$ , and $b ^ { i }$ are all independent of each other. $( 2 ) \\forall i , j : \\mathbb { E } [ W _ { j } ^ { i } ] = 0$ . (3) $\\forall j : \\mathbb { E } [ x ^ { j } ] = 0$ . (4) $\\forall i : b ^ { i } = 0$ . ",
+        "bbox": [
+            174,
+            862,
+            825,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Then, $\\mathbb { E } [ y ^ { i } ] = 0$ and $\\mathrm { V a r } ( y ^ { i } ) = \\mathrm { d } _ { j } \\mathrm { V a r } ( W _ { j } ^ { i } ) \\mathrm { V a r } ( x ^ { j } )$ . To keep the variance of the output and input activations the same, i.e. $\\mathsf { V a r } ( y ^ { i } ) = \\mathsf { V a r } ( x ^ { j } )$ , we have to sample $W _ { j } ^ { i }$ from a distribution whose variance is equal to the reciprocal of the fan-in: $\\begin{array} { r } { \\operatorname { V a r } ( W _ { j } ^ { i } ) = \\frac { 1 } { \\mathrm { d } _ { j } } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            102,
+            825,
+            155
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If analogous assumptions hold for the backward pass, then to keep the variance of the output and input gradients the same, we have to sample $W _ { j } ^ { i }$ from a distribution whose variance is equal to the reciprocal of the fan-out: $\\begin{array} { r } { \\mathrm { V a r } ( W _ { j } ^ { i } ) = \\frac { 1 } { \\mathsf d _ { i } } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            161,
+            825,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Thus, the forward pass and backward pass result in symmetrical formulae. Glorot & Bengio (2010) proposed an initialization based on their harmonic mean: $\\begin{array} { r } { \\operatorname { V a r } ( W _ { j } ^ { i } ) = \\frac { 2 } { \\mathbb { d } _ { j } + \\mathbb { d } _ { i } } } \\end{array}$ . ",
+        "bbox": [
+            171,
+            215,
+            821,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In general, a feedforward network is non-linear, so these assumptions are strictly invalid. But odd activation functions with unit derivative at 0 results in a roughly linear regime at initialization. ",
+        "bbox": [
+            171,
+            253,
+            823,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 KAIMING INITIALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            304,
+            397,
+            318
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "He et al. (2015) extended Glorot & Bengio (2010)’s analysis by looking at the case of ReLU activation functions, i.e. $y ^ { i } = W _ { j } ^ { i } \\mathrm { R e L U } ( x ^ { j } ) \\bar { + } b ^ { i }$ . We can write $z ^ { j } = \\operatorname { R e L U } ( x ^ { j } )$ to get ",
+        "bbox": [
+            173,
+            332,
+            823,
+            362
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/313031343fccc9057528cc9a0ca1032eb827fae65dba0fdda474c48b52beabad.jpg",
+        "text": "$$\n\\operatorname { V a r } ( y ^ { i } ) = \\sum _ { j } \\mathbb { E } [ ( z ^ { j } ) ^ { 2 } ] \\operatorname { V a r } ( W _ { j } ^ { i } ) = \\sum _ { j } \\frac { 1 } { 2 } \\mathbb { E } [ ( x ^ { j } ) ^ { 2 } ] \\operatorname { V a r } ( W _ { j } ^ { i } ) = \\frac { 1 } { 2 } \\mathbb { d } _ { j } \\operatorname { V a r } ( W _ { j } ^ { i } ) \\operatorname { V a r } ( x ^ { j } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            217,
+            375,
+            779,
+            414
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This results in an extra factor of 2 in the variance formula. $W _ { j } ^ { i }$ have to be symmetric around 0 to enforce Xavier Assumption 3 as the activations and gradients propagate through the layers. He et al. (2015) argued that both the forward or backward version of the formula can be adopted, since the activations or gradients will only be scaled by a depth-independent factor. For convolutional layers, we have to further divide the variance by the size of the receptive field. ",
+        "bbox": [
+            173,
+            425,
+            825,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "‘Xavier init’ and ‘Kaiming init’ are terms that are sometimes used interchangeably. Where there might be confusion, we will refer to the forward version as fan-in init, the backward version as fan-out init, and the harmonic mean version as harmonic init. ",
+        "bbox": [
+            174,
+            503,
+            823,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 REVIEW OF CURRENT METHODS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            480,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the seminal Ha et al. (2016) paper, the authors identified two distinct classes of hypernetworks: dynamic (for recurrent networks) and static (for convolutional networks). They proposed Orthogonal init (Saxe et al., 2013) for the dynamic class, but omitted discussion of initialization for the static class. The static class has since proven to be the dominant variant, covering all kinds of non-recurrent networks (not just convolutional), and thus will be the central object of our investigation. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Through an extensive literature and code review, we found that hypernet practitioners mostly depend on the Adam optimizer, which is invariant to and normalizes the scale of gradients, for training and resort to one of four weight initialization methods: ",
+        "bbox": [
+            176,
+            683,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "M1 Xavier or Kaiming init (as found in Pawlowski et al. (2017); Balazevic et al. (2018); Serra\\` et al. (2019); von Oswald et al. (2019)).   \nM2 Small random values (as found in Krueger et al. (2017); Lorraine & Duvenaud (2018)).   \nM3 Kaiming init, but with the output layer scaled by $\\frac { 1 } { 1 0 }$ (as found in Ukai et al. (2018)).   \nM4 Kaiming init, but with the hypernet embedding set to be a suitably scaled constant (as found in Meyerson & Miikkulainen (2019)). ",
+        "bbox": [
+            200,
+            739,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "M1 uses classical neural network initialization methods to initialize hypernetworks. This fails to produce weights for the main network in the correct scale. Consider the following illustrative example of a one-layer linear hypernet generating a linear mainnet with $T + 1$ layers, given embeddings sampled from a standard normal distribution and weights sampled entry-wise from a zero-mean distribution. We leave the biases out for now, and assume the input data $x [ 1 ]$ is standardized. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            102,
+            777,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f60fe597b1f882336f2046154e1f9d49789c029c25e5a578258a6264cac8d4f6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\qquad x [ t + 1 ] ^ { i _ { t + 1 } } = W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } x [ t ] ^ { i _ { t } } , \\qquad W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } = H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } e [ t ] ^ { k _ { t } } , \\qquad 1 \\le t \\le T . } \\\\ & { \\qquad \\mathrm { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = \\mathrm { V a r } ( x [ 1 ] ^ { i _ { 1 } } ) \\displaystyle \\prod _ { t = 1 } ^ { T } \\mathrm { d } _ { i _ { t } } \\mathrm { V a r } ( W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } ) = \\mathrm { V a r } ( x [ 1 ] ^ { i _ { 1 } } ) \\displaystyle \\prod _ { t = 1 } ^ { T } \\mathrm { d } _ { i _ { t } } \\mathrm { d } _ { k _ { t } } \\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            127,
+            799,
+            195
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this case, if the variance of the weights in the hypernet $\\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } )$ is equal to the reciprocal of the fan-in ${ \\mathrm { d } } _ { k _ { t } }$ , then the variance of the activations $\\begin{array} { r } { \\operatorname { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = \\prod _ { t = 1 } ^ { T } \\mathbf { d } _ { i _ { t } } } \\end{array}$ explodes. If it is equal to the reciprocal of the fan-out $\\mathrm { d } _ { i _ { t } } \\mathrm { d } _ { i _ { t + 1 } }$ , then the activation variance $\\begin{array} { r } { \\operatorname { V a r } ( x [ T + 1 ] ^ { i _ { t + 1 } } ) = } \\end{array}$ $\\begin{array} { r } { \\prod _ { t = 1 } ^ { T } \\frac { \\mathrm { d } _ { k _ { t } } } { \\mathrm { d } _ { i _ { t } + 1 } } } \\end{array}$ dktd is likely to vanish, since the size of the embedding vector is typically small relatively to the width of the mainnet weight layer being generated. ",
+        "bbox": [
+            173,
+            205,
+            825,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where the fan-in is of a different scale than the fan-out, the harmonic mean has a scale close to that of the smaller number. Therefore, the fan-in, fan-out, and harmonic variants of Xavier and Kaiming init will all result in activations and gradients that scale exponentially with the depth of the mainnet. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "M2 and M3 introduce additional hyperparameters into the model, and the ad-hoc manner in which they work is reminiscent of pre deep learning neural network research, before the introduction of classical initialization methods like Xavier and Kaiming init. This ad-hoc manner is not only inelegant and consumes more compute, but will likely fail for deeper and more complex hypernetworks. ",
+        "bbox": [
+            173,
+            347,
+            825,
+            404
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "oses  and embeddings can seem to $e [ t ] ^ { k _ { t } }$ to a suitable constantnitialized with the sam $( \\mathsf { d } _ { i _ { t } } ^ { - 1 / 2 }$ in this case), such that bothance as Kaiming init. This $W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } }$ $H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } }$ ensures that the variance of the activations in the mainnet are preserved through the layers, but the restrictions on the embeddings might not be desirable in many applications. ",
+        "bbox": [
+            173,
+            410,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Luckily, the fix appears simple — set $\\begin{array} { r } { \\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) = \\frac { 1 } { \\mathsf { d } _ { i _ { t } } \\mathsf { d } _ { k _ { t } } } } \\end{array}$ . This results in the variance of the generated weights in the mainnet $\\begin{array} { r } { \\operatorname { V a r } ( W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } ) = \\frac { 1 } { \\mathrm { d } _ { i _ { t } } } } \\end{array}$ resembling conventional neural networks initialized with fan-in init. This suggests a general hypernet weight initialization strategy: initialize the weights of the hypernet such that the mainnet weights approximate classical neural network initialization. We elaborate on and generalize this intuition in Section 4. ",
+        "bbox": [
+            173,
+            479,
+            825,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 HYPERFAN INITIALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            436,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Most hypernetwork architectures use a linear output layer so that gradients can pass from the mainnet into the hypernet directly without any non-linearities. We make use of this fact in developing methods called hyperfan-in init and hyperfan-out init for hypernetwork weight initialization based on the principle of variance analysis. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 HYPERFAN-IN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            313,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition. Suppose a hypernetwork comprises a linear output layer. Then, the variance between the input and output activations of a linear layer in the mainnet $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ can be preserved using fan-in init in the hypernetwork with appropriately scaled output layers. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Case 1. The hypernet generates the weights but not the biases of the mainnet. The bias in the mainnet is initialized to zero. We can write the weight generation in the form $W _ { j } ^ { i } = H _ { j k } ^ { i } h ( e ) ^ { k } + \\beta _ { j } ^ { i }$ where $h$ computes all but the last layer of the hypernet and $( H , \\beta )$ form the output layer. We make the following Hyperfan Assumptions at initialization: (1) Xavier assumptions hold for all the layers in the hypernet. (2) The $H _ { j k } ^ { i }$ , $h ( e ) ^ { k } , \\beta _ { j } ^ { i } , x ^ { j }$ , and $b ^ { i }$ are all independent of each other. (3) $\\forall i , j , k : \\mathbb { E } [ H _ { j k } ^ { i } ] = 0 .$ . (4) $\\mathbb { E } [ x ^ { j } ] = 0$ . (5) $\\forall i : b ^ { i } = 0$ . ",
+        "bbox": [
+            173,
+            779,
+            825,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Use fan-in init to initialize the weights for $h$ . Then, $\\operatorname { V a r } ( h ( e ) ^ { k } ) = \\operatorname { V a r } ( e ^ { l } )$ . If we initialize $H$ with the formula $\\begin{array} { r } { \\mathrm { V a r } ( H _ { j k } ^ { i } ) = \\frac { 1 } { \\mathrm { d } _ { j } \\mathrm { d } _ { k } \\mathrm { V a r } ( e ^ { l } ) } } \\end{array}$ and $\\beta$ with zeros, we arrive at $\\begin{array} { r } { \\mathrm { V a r } ( W _ { j } ^ { i } ) = \\frac { 1 } { \\mathrm { d } _ { j } } } \\\\ { . } \\end{array}$ , which is the formula for fan-in init in the mainnet. The Hyperfan assumptions imply the Xavier assumptions hold in the mainnet, thus preserving the input and output activations. ",
+        "bbox": [
+            174,
+            877,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            622,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/680437dfa3ba33012db9a4fcababbce5e1691fe7d65ac9db35f8114ab284c43f.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\mathsf { V a r } ( y ^ { i } ) = \\sum _ { j } \\mathsf { V a r } ( W _ { j } ^ { i } ) \\mathsf { V a r } ( x ^ { j } ) = \\sum _ { j } \\sum _ { k } \\mathsf { V a r } ( H _ { j k } ^ { i } ) \\mathsf { V a r } ( h ( e ) ^ { k } ) \\mathsf { V a r } ( x ^ { j } ) } \\ ~ } \\\\ { { \\displaystyle = \\sum _ { j } \\sum _ { k } \\frac { 1 } { \\mathsf { d } _ { j } \\mathsf { d } _ { k } \\mathsf { V a r } ( e ^ { l } ) } \\mathsf { V a r } ( e ^ { l } ) \\mathsf { V a r } ( x ^ { j } ) = \\mathsf { V a r } ( x ^ { j } ) } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            121,
+            736,
+            198
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Case 2. The hypernet generates both the weights and biases of the mainnet. We can write the weight and bias generation in the form $W _ { j } ^ { i } \\ : = \\ : H _ { j k } ^ { i } h ( e [ 1 ] ) ^ { k } \\ : + \\ : \\beta _ { j } ^ { i }$ and $b ^ { i } = G _ { l } ^ { i } g ( e [ 2 ] ) ^ { l } + \\gamma ^ { i }$ respectively, where $h$ and $g$ compute all but the last layer of the hypernet, and $( H , \\beta )$ and $( G , \\gamma )$ form the output layers. We modify Hyperfan Assumption $2 \\ \\mathrm { s o }$ it includes $G _ { l } ^ { i }$ , $g ( e [ 2 ] ) ^ { l }$ , and $\\gamma ^ { i }$ , and further assume $\\mathrm { V a r } ( x ^ { j } ) = 1$ , which holds at initialization with the common practice of data standardization. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Use fan-in init to initialize the weights for $h$ and $g$ . Then, $\\mathrm { V a r } ( h ( e [ 1 ] ) ^ { k } ) ~ = ~ \\mathrm { V a r } ( e [ 1 ] ^ { m } )$ and $\\operatorname { V a r } ( g ( e [ 2 ] ) ^ { l } ) = \\operatorname { V a r } ( e [ 2 ] ^ { n } )$ . If we initialize $H$ with the formula $\\begin{array} { r } { \\mathrm { V a r } ( H _ { j k } ^ { i } ) = \\frac { 1 } { 2 \\mathrm { d } _ { j } \\mathrm { d } _ { k } \\mathrm { V a r } ( e [ 1 ] ^ { m } ) } } \\end{array}$ , $G$ with the formula $\\begin{array} { r } { \\operatorname { V a r } ( G _ { l } ^ { i } ) = \\frac { 1 } { 2 \\mathrm { d } _ { l } \\operatorname { V a r } ( e [ 2 ] ^ { n } ) } } \\end{array}$ , and $\\beta , \\gamma$ with zeros, then the input and output activations in the mainnet can be preserved. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            357
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6ea8de5d896e7b75c835440c51f4a5eb5c21a943b27d183b2934487047af55d7.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathrm { V a r } ( y ^ { i } ) = \\sum _ { j } \\big [ \\mathrm { V a r } ( W _ { j } ^ { i } ) \\mathrm { V a r } ( x ^ { j } ) \\big ] + \\mathrm { V a r } ( b ^ { i } ) } \\\\ { \\displaystyle = \\sum _ { j } \\Bigg [ \\sum _ { k } \\mathrm { V a r } ( H _ { j k } ^ { i } ) \\mathrm { V a r } ( h ( e [ 1 ] ) ^ { k } ) \\mathrm { V a r } ( x ^ { j } ) \\Bigg ] + \\sum _ { l } \\mathrm { V a r } ( G _ { l } ^ { i } ) \\mathrm { V a r } ( g ( e [ 2 ] ) ^ { l } ) } \\\\ { \\displaystyle = \\sum _ { j } \\Bigg [ \\sum _ { k } \\frac { 1 } { 2 \\mathrm { d } _ { j } \\mathrm { d } _ { k } \\mathrm { V a r } ( e [ 1 ] ^ { m } ) } \\mathrm { V a r } ( e [ 1 ] ^ { m } ) \\mathrm { V a r } ( x ^ { j } ) \\Bigg ] + \\sum _ { l } \\frac { 1 } { 2 \\mathrm { d } _ { l } \\mathrm { V a r } ( e [ 2 ] ^ { n } ) } \\mathrm { V a r } ( e [ 2 ] ^ { n } ) } \\\\ { \\displaystyle = \\frac { 1 } { 2 } \\mathrm { V a r } ( x ^ { j } ) + \\frac { 1 } { 2 } = \\mathrm { V a r } ( x ^ { j } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            361,
+            787,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If we initialize $G _ { j } ^ { i }$ to zeros, then its contribution to the variance will increase during training, causing exploding activations in the mainnet. Hence, we prefer to introduce a factor of $1 / 2$ to divide the variance between the weight and bias generation, where the variance of each component is allowed to either decrease or increase during training. This becomes a problem if the variance of the activations in the mainnet deviates too far away from 1, but we found that it works well in practice. ",
+        "bbox": [
+            173,
+            521,
+            826,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 HYPERFAN-OUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            606,
+            328,
+            619
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Case 1. The hypernet generates the weights but not the biases of the mainnet. A similar derivation can be done for the backward pass using analogous assumptions on gradients flowing ",
+        "bbox": [
+            173,
+            631,
+            823,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "in the mainnet: $\\begin{array} { r l r } & { \\displaystyle \\frac { \\partial L } { \\partial x [ t ] ^ { i _ { t } } } = \\frac { \\partial L } { \\partial x [ t + 1 ] ^ { i _ { t + 1 } } } W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } , } & \\\\ & { \\displaystyle \\frac { \\partial L } { \\partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } = \\frac { \\partial L } { \\partial x [ t + 1 ] ^ { i _ { t + 1 } } } x [ t ] ^ { i _ { t } } , \\frac { \\partial L } { \\partial h [ t ] ( e ) ^ { k _ { t } } } = \\frac { \\partial L } { \\partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } , } & \\\\ & { \\displaystyle \\frac { \\partial L } { \\partial b [ t ] ^ { i _ { t + 1 } } } = \\frac { \\partial L } { \\partial x [ t + 1 ] ^ { i _ { t + 1 } } } , \\frac { \\partial L } { \\partial g [ t ] ( e ) ^ { l _ { t } } } = \\frac { \\partial L } { \\partial b [ t ] ^ { i _ { t + 1 } } } G [ t ] _ { l _ { t } } ^ { i _ { t + 1 } } . } & \\end{array}$ through mainnet weights: and through mainnet biases: ",
+        "bbox": [
+            178,
+            662,
+            825,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If we initialize the output layer $H$ with the analogous hyperfan-out formula $\\mathrm { V a r } ( H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } ) ~ =$ 1di dk Var(ekt ) and the rest of the hypernet with fan-in init, then we can preserve input and output gradients on the mainnet: $\\begin{array} { r } { \\mathrm { V a r } ( \\frac { \\partial L } { \\partial x [ t ] ^ { i _ { t } } } ) = \\mathrm { V a r } ( \\frac { \\partial L } { \\partial x [ t + 1 ] ^ { i _ { t + 1 } } } ) } \\end{array}$ r( ∂L∂x[t+1]it+1 ). However, note that the gradients will shrink when flowing from the mainnet to the hypernet: Var( ∂L∂h[t](e)kt ) $\\begin{array} { r } { \\mathrm { V a r } ( \\frac { \\partial L } { \\partial h [ t ] ( e ) ^ { k _ { t } } } ) = \\frac { \\mathrm { d } _ { i _ { t } } } { \\mathrm { d } _ { k _ { t } } \\mathrm { V a r } ( e ^ { k _ { t } } ) } \\mathrm { V a r } ( \\frac { \\partial L } { \\partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } ) . } \\end{array}$ and scaled by a depth-independent factor due to the use of fan-in rather than fan-out init. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Case 2. The hypernet generates both the weights and biases of the mainnet. In the classical case, the forward version (fan-in init) and the backward version (fan-out init) are symmetrical. This remains true for hypernets if they only generated the weights of the mainnet. However, if they were to also generate the biases, then the symmetry no longer holds, since the biases do not affect the gradient flow in the mainnet but they do so for the hypernet (c.f. Equation 4). Nevertheless, we can initialize $G$ so that it helps hyperfan-out init preserve activation variance on the forward pass as much as possible (keeping the assumption that $\\bar { \\mathsf { V a r } } ( x ^ { j } ) = 1$ as before): ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be9d487d146383d1f761d46337d798aaaf99fc0adf53b55215e00ade1abfc684.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle \\mathsf { V a r } ( y ^ { i } ) = \\sum _ { j } \\left[ \\mathsf { V a r } ( W _ { j } ^ { i } x ^ { j } ) \\right] + \\mathsf { V a r } ( b ^ { i } ) } \\ ~ } \\\\ { { \\displaystyle \\qquad = \\mathsf { d } _ { j } \\mathsf { d } _ { k } \\mathsf { V a r } ( e [ 1 ] ^ { m } ) \\mathsf { V a r } ( H [ \\mathsf { h y p e r f a n } \\mathsf { - o u t } ] _ { j k } ^ { i } ) \\mathsf { V a r } ( x ^ { j } ) + \\mathsf { d } _ { l } \\mathsf { V a r } ( e [ 2 ] ^ { n } ) \\mathsf { V a r } ( G _ { l } ^ { i } ) } \\ ~ } \\\\ { { \\displaystyle \\qquad = \\mathsf { d } _ { j } \\mathsf { d } _ { k } \\mathsf { V a r } ( e [ 1 ] ^ { m } ) \\mathsf { V a r } ( H [ \\mathsf { h y p e r f a n } \\mathsf { - i n } ] _ { j k } ^ { i } ) \\mathsf { V a r } ( x ^ { j } ) } \\ ~ } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            178,
+            784,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Plugging in the formulae for Hyperfan-in and Hyperfan-out from above, we get ",
+        "bbox": [
+            194,
+            256,
+            718,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/53385e6fa802db2e7d8818fb8ea447c51baee3c70d4c49030eac172a0a612af7.jpg",
+        "text": "$$\n\\implies \\mathrm { V a r } ( G _ { l } ^ { i } ) = \\frac { ( 1 - \\frac { \\mathrm { d } _ { j } } { \\mathrm { d } _ { i } } ) } { \\mathrm { d } _ { l } \\mathrm { V a r } ( e [ 2 ] ^ { n } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            199,
+            273,
+            406,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We summarize the variance formulae for hyperfan-in and hyperfan-out init in Table 1. It is not uncommon to re-use the same hypernet to generate different parts of the mainnet, as was originally done in Ha et al. (2016). We discuss this case in more detail in Appendix Section A. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Hyperfan-in and Hyperfan-out Variance Formulae for $W _ { j } ^ { i } = H _ { j k } ^ { i } h ( e [ 1 ] ) ^ { k } + \\beta _ { j } ^ { i }$ . If $y ^ { i } =$ $\\mathrm { R e L U } ( W _ { j } ^ { i } x ^ { j } + b ^ { i } )$ , then $\\mathbb { 1 } _ { \\mathrm { R e L U } } = 1$ , else if $y ^ { i } = W _ { j } ^ { i } x ^ { j } + b ^ { i }$ , then $\\mathbb { 1 } _ { \\mathrm { R e L U } } = 0$ . If $b ^ { i } = G _ { l } ^ { i } g ( e [ 2 ] ) ^ { l } + \\gamma ^ { i }$ , then $\\mathbb { 1 } _ { \\mathrm { H B i a s } } ~ = ~ 1$ , else if $b ^ { i } \\ = \\ 0$ , then $\\mathbb { 1 } _ { \\mathrm { H B i a s } } ~ = ~ 0$ . We initialize $h$ and $g$ with fan-in init, and $\\beta _ { j } ^ { i } , \\gamma ^ { i } = 0$ . For convolutional layers, we have to further divide $\\mathrm { V a r } ( H _ { j k } ^ { i } )$ by the size of the receptive field. Uniform init: $X \\sim { \\mathcal { U } } ( - { \\sqrt { 3 \\operatorname { V a r } ( X ) } } , { \\sqrt { 3 \\operatorname { V a r } ( X ) } } )$ . Normal init: $X \\sim { \\mathcal { N } } ( 0 , \\operatorname { V a r } ( X ) )$ . ",
+        "bbox": [
+            173,
+            381,
+            826,
+            465
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fa0c151e320cbc93626d596f8a7cd1954b7c6ec87a214f817a51a02959450d3f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Initialization</td><td colspan=\"2\">Variance Formula</td><td>Initialization</td><td>Variance Formula</td></tr><tr><td></td><td></td><td>21ReLU</td><td></td><td>21ReLU</td></tr><tr><td>Hyperfan-in</td><td></td><td>Var(Hj）=r(e)</td><td>Hyperfan-outVar(Hjk） =</td><td>didkVar(e[1]m) dj</td></tr><tr><td>Hyperfan-in</td><td>Var(Gi）=</td><td>21ReLU 2dVar(e[2]n)</td><td>Hyperfan-outVar(G&#x27;) = max(</td><td>21ReLU(1- a ,0 dVar(e[2]n)</td></tr></table>",
+        "bbox": [
+            173,
+            478,
+            844,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            579,
+            326,
+            594
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluated our proposed methods on four sets of experiments involving different use cases of hypernetworks: feedforward networks, continual learning, convolutional networks, and Bayesian neural networks. In all cases, we optimize with vanilla SGD and sample from the uniform distribution according to the variance formula given by the init method. More experimental details can be found in Appendix Section B. ",
+        "bbox": [
+            173,
+            609,
+            825,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 FEEDFORWARD NETWORKS ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            490,
+            710
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As an illustrative first experiment, we train a feedforward network with five hidden layers (500 hidden units), a hyperbolic tangent activation function, and a softmax output layer, on MNIST across four different settings: (1) a classical network with Xavier init, (2) a hypernet with Xavier init that generates the weights of the mainnet, (3) a hypernet with hyperfan-in init that generates the weights of the mainnet, (4) and a hypernet with hyperfan-out init that generates the weights of the mainnet. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The use of hyperfan init methods on a hypernetwork reproduces mainnet weights similar to those that have been trained from Xavier init on a classical network, while the use of Xavier init on a hypernetwork causes exploding activations right at the beginning of training (see Figure 1). Observe in Figure 2 that when the hypernetwork is initialized in the proper scale, the magnitude of generated weights stabilizes quickly. This in turn leads to a more stable training regime, as seen in Figure 3. More visualizations of the activations and gradients of both the mainnet and hypernet can be viewed in Appendix Section B.1. Qualitatively similar observations were made when we replaced the activation function with ReLU and Xavier with Kaiming init, with Kaiming init leading to even bigger activations at initialization. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Suppose now the hypernet generates both the weights and biases of the mainnet instead of just the weights. We found that this architectural change leads the hyperfan init methods to take more time (but still less than Xavier init), to generate stable mainnet weights (c.f. Figure 25 in the Appendix). ",
+        "bbox": [
+            173,
+            103,
+            826,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/398fd064e8bbdeac3e97457e679647575721ae8effdd4e94ec5058070295c72a.jpg",
+        "image_caption": [
+            "Figure 1: Mainnet Activations before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            161,
+            820,
+            265
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd093f8ececa31349d2cd7ad774bc83cee15e6ff74e095421ef1db6d1572f81e.jpg",
+        "image_caption": [
+            "Figure 2: Evolution of Hypernet Output Layer Activations during Training on MNIST. Xavier init results in unstable mainnet weights throughout training, while hyperfan-in and hyperfan-out init result in mainnet weights that stabilize quickly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            327,
+            818,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea9b3ec23ac010201fcf92c1987fba5ad33a9cf0dfff2987d2e542771e759007.jpg",
+        "image_caption": [
+            "Figure 3: Loss and Test Accuracy Plots on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            569,
+            818,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 CONTINUAL LEARNING ON REGRESSION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            779,
+            547,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Continual learning solves the problem of learning tasks in sequence without forgetting prior tasks. von Oswald et al. (2019) used a hypernetwork to learn embeddings for each task as a way to efficiently regularize the training process to prevent catastrophic forgetting. We compare different initialization schemes on their hypernetwork implementation, which generates the weights and biases of a ReLU mainnet with two hidden layers to solve a sequence of three regression tasks. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4, we plot the training loss averaged over 15 different runs, with the shaded area showing the standard error. We observe that the hyperfan methods produce smaller training losses at initialization and during training, eventually converging to a smaller loss for each task. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/759225e1953b3e8dfdbc6e79da51ffa690f5bb84fb8fc447f07360f36118734f.jpg",
+        "image_caption": [
+            "Figure 4: Continual Learning Loss on a Sequence of Regression Tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            818,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 CONVOLUTIONAL NETWORKS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            529,
+            314
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ha et al. (2016) applied a hypernetwork on a convolutional network for image classification on CIFAR-10. We note that our initialization methods do not handle residual connections, which were in their chosen mainnet architecture and are important topics for future study. Instead, we implemented their hypernetwork architecture on a mainnet with the All Convolutional Net architecture (Springenberg et al., 2014) that is composed of convolutional layers and ReLU activation functions. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            395
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "After searching through a dense grid of learning rates, we failed to enable the fan-in version of Kaiming init to train even with very small learning rates. The fan-out version managed to begin delayed training, starting from around epoch 270 (see Figure 5). By contrast, both hyperfan-in and hyperfan-out init led to successful training immediately. This shows a good init can make it possible to successfully train models that would have otherwise been unamenable to training on a bad init. ",
+        "bbox": [
+            173,
+            402,
+            825,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7668061b86319ef7850b1d345783739865ecafb278107d807114648702168d09.jpg",
+        "image_caption": [
+            "Figure 5: Loss and Test Accuracy Plots on CIFAR-10. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            488,
+            818,
+            626
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 BAYESIAN NEURAL NETWORKS ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            544,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Bayesian neural networks improve model calibration and provide uncertainty estimation, which guard against the pitfalls of overconfident networks. Ukai et al. (2018) developed a Bayesian neural network by using a hypernetwork to simulate an expressive prior distribution. We trained a similar hypernetwork by applying Ukai et al. (2018)’s methods on ImageNet, but differed in our choice of MobileNet (Howard et al., 2017) as a mainnet architecture that does not have residual connections. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            777
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the work of Ukai et al. (2018), it was noticed that even with the use of batch normalization in the mainnet, classical initialization approaches still led to diverging losses (due to exploding activations, c.f. Section 3). We observe similar results in our experiment (see Figure 6) — the fan-in version of Kaiming init, which is the default initialization in popular deep learning libraries like PyTorch and Chainer, resulted in substantially higher initial losses and led to slower training than the hyperfan methods. We found that the observation still stands even when the last layer of the mainnet is not generated by the hypernet. This shows that while batch normalization helps, it is not the solution for a bad init that causes exploding activations. Our approach solves this problem in a principled way, and is preferable to the trial-and-error based heuristics that Ukai et al. (2018) had to resort to in order to train their model. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, the fan-out version of Kaiming init led to similar results as the hyperfan methods, suggesting that batch normalization might be sufficient to correct the bad initializations that result in vanishing activations. That being said, hypernet practitioners should not expect batch normalization to be the panacea for problems caused by bad initialization, especially in memory-constrained scenarios. In a Bayesian neural network application (especially in hypernet architectures without relaxed weight-sharing), the blowup in the number of parameters limits the use of big batch sizes, which is essential to the performance of batch normalization (Wu & He, 2018). For example, in this experiment, our hypernet model requires 32 times as many parameters as a classical MobileNet. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, the interaction between batch normalization and initialization is not well-understood, even in the classical case, and thus, our findings prompt an interesting direction for future research. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf7d8d08869fdeacf17d9b56a759f1ed04f371960aaa790693e39c9d9b31ee49.jpg",
+        "image_caption": [
+            "Figure 6: Loss and Test Accuracy Plots on ImageNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            276,
+            820,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In all our experiments, hyperfan-in and hyperfan-out both led to successful hypernetwork training with SGD. We did not find a good reason to prefer one over the other (similar to He et al. (2015)’s observation in the classical case for fan-in and fan-out init). ",
+        "bbox": [
+            173,
+            441,
+            825,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            318,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For a long time, the promise of deep nets to learn rich representations of the world was left unfulfilled due to the inability to train these models. The discovery of greedy layer-wise pre-training (Hinton et al., 2006; Bengio et al., 2007) and later, Xavier and Kaiming init, as weight initialization strategies to enable such training was a pivotal achievement that kickstarted the deep learning revolution. This underscores the importance of model initialization as a fundamental step in learning complex representations. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            618
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we developed the first principled weight initialization methods for hypernetworks, a rapidly growing branch of meta-learning. We hope our work will spur momentum towards the development of principled techniques for building and training hypernetworks, and eventually lead to significant progress in learning meta representations. Other non-hypernetwork methods of neural network generation (Stanley et al., 2009; Koutnik et al., 2010) can also be improved by considering whether their generated weights result in exploding activations and how to avoid that if so. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            709
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            731,
+            397,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This research was supported in part by the US Defense Advanced Research Project Agency (DARPA) Lifelong Learning Machines Program, grant HR0011-18-2-0020. We thank Dan Martin and Yawei Li for helpful discussions, and the ICLR reviewers for their constructive feedback. ",
+        "bbox": [
+            174,
+            761,
+            823,
+            804
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ivana Balazevic, Carl Allen, and Timothy M Hospedales. Hypernetwork knowledge graph embeddings. arXiv preprint arXiv:1808.07018, 2018. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio, Pascal Lamblin, Dan Popovici, and Hugo Larochelle. Greedy layer-wise training of deep networks. In Advances in neural information processing systems, pp. 153–160, 2007. ",
+        "bbox": [
+            171,
+            162,
+            823,
+            194
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Smash: one-shot model architecture search through hypernetworks. arXiv preprint arXiv:1708.05344, 2017. ",
+        "bbox": [
+            169,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lior Deutsch, Erik Nijkamp, and Yu Yang. A generative model for sampling high-performance and diverse weights for neural networks. arXiv preprint arXiv:1905.02898, 2019. ",
+        "bbox": [
+            169,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statistics, pp. 249–256, 2010. ",
+        "bbox": [
+            174,
+            277,
+            821,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew Dai, and Quoc V Le. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016. ",
+        "bbox": [
+            171,
+            329,
+            816,
+            345
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015. ",
+        "bbox": [
+            176,
+            354,
+            821,
+            398
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Henning, Johannes von Oswald, Joao Sacramento, Simone Carlo Surace, Jean-Pascal Pfis- ˜ ter, and Benjamin F Grewe. Approximating the predictive distribution via adversarially-trained hypernetworks. In Bayesian Deep Learning Workshop, NeurIPS (Spotlight), volume 2018, 2018. ",
+        "bbox": [
+            176,
+            406,
+            823,
+            450
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Simon Osindero, and Yee-Whye Teh. A fast learning algorithm for deep belief nets. Neural computation, 18(7):1527–1554, 2006. ",
+        "bbox": [
+            173,
+            458,
+            821,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017. ",
+        "bbox": [
+            173,
+            496,
+            825,
+            539
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            549,
+            823,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sylwester Klocek, Łukasz Maziarka, Maciej Wołczyk, Jacek Tabor, Marek Smieja, and Jakub ´ Nowak. Hypernetwork functional image representation. arXiv preprint arXiv:1902.10404, 2019. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Koutnik, Faustino Gomez, and Jurgen Schmidhuber. Evolving neural networks in compressed ¨ weight space. In Proceedings of the 12th annual conference on Genetic and evolutionary computation, pp. 619–626. ACM, 2010. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Agustinus Kristiadi and Asja Fischer. Predictive uncertainty quantification with compound density networks. arXiv preprint arXiv:1902.01080, 2019. ",
+        "bbox": [
+            169,
+            676,
+            823,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Krueger, Chin-Wei Huang, Riashat Islam, Ryan Turner, Alexandre Lacoste, and Aaron Courville. Bayesian hypernetworks. arXiv preprint arXiv:1710.04759, 2017. ",
+        "bbox": [
+            171,
+            714,
+            823,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Soren Laue, Matthias Mitterreiter, and Joachim Giesen. Computing higher order derivatives of ¨ matrix and tensor expressions. In Advances in Neural Information Processing Systems, pp. 2755– 2764, 2018. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            796
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zechun Liu, Haoyuan Mu, Xiangyu Zhang, Zichao Guo, Xin Yang, Tim Kwang-Ting Cheng, and Jian Sun. Metapruning: Meta learning for automatic neural network channel pruning. arXiv preprint arXiv:1903.10258, 2019. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Lorraine and David Duvenaud. Stochastic hyperparameter optimization through hypernetworks. arXiv preprint arXiv:1802.09419, 2018. ",
+        "bbox": [
+            173,
+            857,
+            820,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Elliot Meyerson and Risto Miikkulainen. Modular universal reparameterization: Deep multi-task learning across diverse domains. arXiv preprint arXiv:1906.00097, 2019. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zheyi Pan, Yuxuan Liang, Junbo Zhang, Xiuwen Yi, Yong Yu, and Yu Zheng. Hyperst-net: Hypernetworks for spatio-temporal forecasting. arXiv preprint arXiv:1809.10889, 2018. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nick Pawlowski, Andrew Brock, Matthew CH Lee, Martin Rajchl, and Ben Glocker. Implicit weight uncertainty in neural networks. arXiv preprint arXiv:1711.01297, 2017. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            171
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Neale Ratzlaff and Li Fuxin. Hypergan: A generative model for diverse, performant neural networks. arXiv preprint arXiv:1901.11058, 2019. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sashank J. Reddi, Satyen Kale, and Sanjiv Kumar. On the convergence of adam and beyond. In International Conference on Learning Representations, 2018. URL https://openreview. net/forum?id $=$ ryQu7f-RZ. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David E Rumelhart, Geoffrey E Hintont, and Ronald J Williams. Learning representations by backpropagating errors. NATURE, 323:9, 1986. ",
+        "bbox": [
+            169,
+            267,
+            823,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Saxe, James L McClelland, and Surya Ganguli. Exact solutions to the nonlinear dynamics of learning in deep linear neural networks. arXiv preprint arXiv:1312.6120, 2013. ",
+        "bbox": [
+            171,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Serra, Santiago Pascual, and Carlos Segura. Blow: a single-scale hyperconditioned flow for \\` non-parallel raw-audio voice conversion. arXiv preprint arXiv:1906.00794, 2019. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Falong Shen, Shuicheng Yan, and Gang Zeng. Meta networks for neural style transfer. arXiv preprint arXiv:1709.04111, 2017. ",
+        "bbox": [
+            173,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014. ",
+        "bbox": [
+            173,
+            419,
+            821,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O Stanley, David B D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artificial life, 15(2):185–212, 2009. ",
+        "bbox": [
+            173,
+            457,
+            820,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joseph Suarez. Language modeling with recurrent highway hypernetworks. In Advances in neural information processing systems, pp. 3267–3276, 2017. ",
+        "bbox": [
+            173,
+            494,
+            821,
+            523
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhun Sun, Mete Ozay, and Takayuki Okatani. Hypernetworks with statistical filtering for defending adversarial examples. arXiv preprint arXiv:1711.01791, 2017. ",
+        "bbox": [
+            173,
+            531,
+            821,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenya Ukai, Takashi Matsubara, and Kuniaki Uehara. Hypernetwork-based implicit posterior estimation and model averaging of cnn. In Asian Conference on Machine Learning, pp. 176–191, 2018. ",
+        "bbox": [
+            174,
+            569,
+            821,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Johannes von Oswald, Christian Henning, Joao Sacramento, and Benjamin F Grewe. Continual ˜ learning with hypernetworks. arXiv preprint arXiv:1906.00695, 2019. ",
+        "bbox": [
+            173,
+            621,
+            823,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nati Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, pp. 4148–4158, 2017. ",
+        "bbox": [
+            173,
+            659,
+            823,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuxin Wu and Kaiming He. Group normalization. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 3–19, 2018. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            741
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. arXiv preprint arXiv:1810.05749, 2018. ",
+        "bbox": [
+            173,
+            748,
+            823,
+            779
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hongyi Zhang, Yann N Dauphin, and Tengyu Ma. Fixup initialization: Residual learning without normalization. arXiv preprint arXiv:1901.09321, 2019. ",
+        "bbox": [
+            171,
+            786,
+            823,
+            815
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A RE-USING HYPERNET WEIGHTS",
+        "text_level": 1,
+        "bbox": [
+            178,
+            135,
+            478,
+            152
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 FOR MAINNET WEIGHTS OF THE SAME SIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            166,
+            531,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "For model compression or weight-sharing purposes, different parts of the mainnet might be generated by the same hypernet function. This will cause some assumptions of independence in our analysis to be invalid. Consider the example of the same hypernet being used to generate multiple different mainnet weight layers of the same size, i.e. $\\begin{array} { r } { H [ t ] _ { i _ { t } k } ^ { i _ { t + 1 } } = H [ t + 1 ] _ { i _ { t + 1 } k } ^ { i _ { t + 2 } } , \\mathsf { d } _ { i _ { t + 1 } } = \\mathsf { d } _ { i _ { t + 2 } } = \\mathsf { d } _ { i _ { t } } } \\end{array}$ . Then, $x [ t + 1 ] ^ { i _ { t + 1 } } = H [ t ] _ { i _ { t } k _ { t } } ^ { i _ { t + 1 } } e [ t ] ^ { k _ { t } } x [ t ] ^ { i _ { t } }$ t 6⊥⊥ $W [ t + 1 ] _ { i _ { t + 1 } } ^ { i _ { t + 2 } } = H [ t + 1 ] _ { i _ { t + 1 } k } ^ { i _ { t + 2 } } e [ t + 1 ] ^ { k _ { t + 1 } }$ ",
+        "bbox": [
+            173,
+            193,
+            825,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The relaxation of some of these independence assumptions does not always prove to be a big problem in practice, because the correlations introduced by repeated use of $H$ can be minimized with the use of flat distributions like the uniform distribution. It can even be helpful, since the re-use of the same hypernet for different layers causes the gradient flowing through the hypernet output layer to be the sum of the gradients from the weights of these layers: $\\begin{array} { r } { \\frac { \\partial L } { \\partial h ( e ) ^ { k } } = \\sum _ { t } \\frac { \\partial L } { \\partial W [ t ] _ { i _ { t } } ^ { i _ { t + 1 } } } H _ { i _ { t } k } ^ { i _ { t + 1 } } } \\end{array}$ H it+1i k , thus combating the shrinking effect. ",
+        "bbox": [
+            173,
+            280,
+            825,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 FOR MAINNET WEIGHTS OF DIFFERENT SIZES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            391,
+            544,
+            406
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Similar reasoning applies if the same hypernet was used to generate differently sized subsets of weights in the mainnet. However, we encourage avoiding this kind of hypernet architecture design if not otherwise essential, since it will complicate the initialization formulae listed in Table 1. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Consider Ha et al. (2016)’s hypernetwork architecture. Their two-layer hypernet generated weight chunks of size $( K , n , n )$ for a main convolutional network where $K = 1 6$ was found to be the highest common factor among the size of mainnet layers, and ${ n ^ { 2 } = 9 }$ was the size of the receptive field. We simplify the presentation by writing $i$ for $i _ { t }$ , $j$ for $j _ { t }$ , $k$ for $k _ { t , m }$ , and $l$ for $l _ { t , m }$ . ",
+        "bbox": [
+            173,
+            467,
+            825,
+            525
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fe0e0e974d388f7efec1fdb3541e4874f3b87c105f193f48367186669eb29798.jpg",
+        "text": "$$\n\\begin{array} { r l } & { W [ t ] _ { j } ^ { i } = \\left\\{ \\begin{array} { l l } { H _ { k } ^ { i ( \\mathrm { m o d } K ) } \\alpha [ t ] [ j + \\lfloor \\frac { i } { K } \\rfloor \\mathbf { d } _ { j } ] ^ { k } + \\beta ^ { i ( \\mathrm { m o d } K ) } } & { \\mathrm { i f ~ } i \\mathrm { i s ~ d i v i s i b l e ~ b y ~ } K } \\\\ { \\delta _ { j ( \\mathrm { m o d } K ) j ( \\mathrm { m o d } K ) } \\left[ H _ { k } ^ { j ( \\mathrm { m o d } K ) } \\alpha [ t ] [ i + \\lfloor \\frac { j } { K } \\rfloor \\mathbf { d } _ { i } ] ^ { k } + \\beta ^ { j ( \\mathrm { m o d } K ) } \\right] } & { \\mathrm { i f ~ } j \\mathrm { ~ i s ~ d i v i s i b l e ~ b y ~ } K } \\end{array} \\right. } \\\\ & { \\left. \\times [ t ] [ m _ { t } ] ^ { k } = G [ t ] [ m _ { t } ] _ { i } ^ { k } e [ t ] [ m _ { t } ] ^ { l } + \\gamma [ t ] [ m _ { t } ] ^ { k } \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            530,
+            828,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Because the output layer $( H , \\beta )$ in the hypernet was re-used to generate mainnet weight matrices of different sizes (i.e. in general, $i _ { t } \\neq i _ { t + 1 } , j _ { t } \\neq j _ { t + 1 } )$ , $G$ effectively becomes the output layer that we want to be considering for hyperfan-in and hyperfan-out initialization. ",
+        "bbox": [
+            174,
+            614,
+            823,
+            659
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hence, to achieve fan-in in the mainnet $\\begin{array} { r } { \\operatorname { V a r } ( W [ t ] _ { j } ^ { i } ) = \\frac { 1 } { \\mathsf { d } _ { j } } } \\end{array}$ , we have to use fan-in init for $H$ (i.e.   \n$\\begin{array} { r } { \\mathrm { V a r } ( H _ { k } ^ { i ( \\mathrm { m o d } K ) } ) ~ = ~ \\frac { 1 } { \\mathrm { d } _ { k } } ~ \\ne ~ \\frac { 1 } { \\mathrm { d } _ { j } \\mathrm { d } _ { k } \\mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } ) } \\end{array}$ , and hyperfan-in init for $G$ (i.e. $\\mathrm { V a r } ( G [ t ] [ m _ { t } ] _ { l } ^ { k } ) ~ =$   \ndj dlVar(e[t][mt]l) ). ",
+        "bbox": [
+            174,
+            662,
+            825,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Analogously, to achieve fan-out in the mainnet $\\begin{array} { r } { \\operatorname { V a r } ( W [ t ] _ { j } ^ { i } ) = \\frac { 1 } { \\mathrm { d } _ { i } } } \\end{array}$ , we have to use fan-in init for $H$ $\\begin{array} { r } { \\mathrm { V a r } ( H _ { k } ^ { i ( \\mathrm { m o d } K ) } ) = \\frac { 1 } { \\mathrm { d } _ { k } } \\ne \\frac { 1 } { \\mathrm { d } _ { i } \\mathrm { d } _ { k } \\mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } ) } \\end{array}$ , and hyperfan-out init for $G$ (i.e. $\\mathrm { V a r } ( G [ t ] [ m _ { t } ] _ { l } ^ { k } ) =$ ${ \\frac { 1 } { \\mathbf { d } _ { i } \\mathbf { d } _ { l } \\mathrm { V a r } ( e [ t ] [ m _ { t } ] ^ { l } ) } } \\big )$ ",
+        "bbox": [
+            173,
+            729,
+            825,
+            790
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B MORE EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            475,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B.1 FEEDFORWARD NETWORKS ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            491,
+            147
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The networks were trained on MNIST for 30 epochs with batch size 10 using a learning rate of 0.0005 for the hypernets and 0.01 for the classical network. The hypernets had one linear layer with embeddings of size 50 and different hidden layers in the mainnet were all generated by the same√ √ hypernet output layer with a different embedding, which was randomly sampled from $\\mathcal { U } ( - \\sqrt { 3 } , \\sqrt { 3 } )$ and fixed. We use the mean cross entropy loss for training, but the summed cross entropy loss for testing. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We show activation and gradient plots for two cases: (i) the hypernet generates only the weights of the mainnet, and (ii) the hypernet generates both the weights and biases of the mainnet. (i) covers Figures 3, 1, 7, 8, 9, 10, 11, 12, 2, 13, 14, 15, and 16. (ii) covers Figures 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, and 29. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The activations and gradients in our plots were calculated by averaging across a fixed held-out set of 300 examples drawn randomly from the test set. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figures 1, 8, 9, 11, 12, 13, 14, 16, 18, 20, 21, 23, 24, 26, 27, and 29, the y axis shows the number of activations/gradients, while the x axis shows the value of the activations/gradients. The value of activations/gradients from the hypernet output layer correspond to the value of mainnet weights. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            392
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figures 2, 7, 10, 15, 19, 22, 25, and 28, the y axis shows the mean value of the activations/gradients, while each increment on the $\\mathbf { X }$ axis corresponds to a measurement that was taken every 1000 training batches, with the bars denoting one standard deviation away from the mean. ",
+        "bbox": [
+            174,
+            398,
+            825,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/5ad9b55dd9ec7bf3f031f5abb5baf71586d95e11bf6dda303a2fcc03b381c706.jpg",
+        "image_caption": [
+            "B.1.1 HYPERNET GENERATES ONLY THE MAINNET WEIGHTS ",
+            "Figure 7: Evolution of Mainnet Activations during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            133,
+            818,
+            237
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c63046dbf51db8f2dc0237824fed4d2e9aebd99be2a2d30f9fe791d95f0f38e.jpg",
+        "image_caption": [
+            "Figure 8: Mainnet Activations at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            289,
+            820,
+            393
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/326add1208ab6c36e4724d5eea053231c59e15b9f30936bb032284c73f5af2bb.jpg",
+        "image_caption": [
+            "Figure 9: Mainnet Gradients before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            446,
+            821,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/62c1fcdd47b1e4a87d57c69401e1a251ab6d4fc89f19e55c41c4921fa24dca4e.jpg",
+        "image_caption": [
+            "Figure 10: Evolution of Mainnet Gradients during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            125,
+            820,
+            229
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ef62276365c6a0c0a174b30c782a72bb2e23804b837ef376545f079cbb821f1.jpg",
+        "image_caption": [
+            "Figure 11: Mainnet Gradients at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            311,
+            821,
+            415
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7715f3a0b91a444ba88326071c224b404a6302d576bdb348355eb9011fd6c948.jpg",
+        "image_caption": [
+            "Figure 12: Hypernet Output Layer Activations before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            500,
+            818,
+            638
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/de6647baea08df0e6d3ebd8dfdb512949ceafdab17c908b6f5ff4d0e448983c7.jpg",
+        "image_caption": [
+            "Figure 13: Hypernet Output Layer Activations at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            726,
+            820,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6b0f3ae1a7fddc0d383a19e0d0445576f01f540068faec6d4a6c71afda1f500.jpg",
+        "image_caption": [
+            "Figure 14: Hypernet Output Layer Gradients before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            150,
+            820,
+            290
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/ddce62a81a34c7bfabaff0c611766d3a51b109b03e4eea3bbe94fe6957d025a9.jpg",
+        "image_caption": [
+            "Figure 15: Evolution of Hypernet Output Layer Gradients during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            426,
+            818,
+            565
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/31d214815e89c9a16ecb28bb247c285b4888127c1d1b9b70894fd036688ffc2c.jpg",
+        "image_caption": [
+            "Figure 16: Hypernet Output Layer Gradients at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            702,
+            818,
+            842
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/4287f21cbf1a00d421681d5f87844e454e4d798c3735347082ac36369934b773.jpg",
+        "image_caption": [
+            "B.1.2 HYPERNET GENERATES BOTH MAINNET WEIGHTS AND BIASES ",
+            "Figure 17: Loss and Test Accuracy Plots on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            135,
+            818,
+            273
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/91418bf64ad3ce38e4e69a011d9af73b3d08369a30b71d5c5dc0e79b6f38f56e.jpg",
+        "image_caption": [
+            "Figure 18: Mainnet Activations before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            329,
+            818,
+            468
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7296457f25f277ee74aa414dfd250f2dfe3bd9e2ad19234a698be544a2f6641f.jpg",
+        "image_caption": [
+            "Figure 19: Evolution of Mainnet Activations during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            523,
+            818,
+            661
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3bc27149fd378f4be3413056eeaa1dd907f94731d15985ed741b1adda038d69.jpg",
+        "image_caption": [
+            "Figure 20: Mainnet Activations at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            117,
+            820,
+            256
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/1241190b9c8282900502bcd8123dbbe02db49a741730f50e53ed45dbf725a008.jpg",
+        "image_caption": [
+            "Figure 21: Mainnet Gradients before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            325,
+            820,
+            467
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/d30a1c5e6540632ec19307216bfcc9c1bf027ac147e02b35b7f6c10b484cd025.jpg",
+        "image_caption": [
+            "Figure 22: Evolution of Mainnet Gradients during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            535,
+            818,
+            675
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/a726295563a94ea8b0b6c15a1bb0ec85aea62f0bb7227989c0c62b4a6f27a90a.jpg",
+        "image_caption": [
+            "Figure 23: Mainnet Gradients at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            744,
+            821,
+            876
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/77323ddca1860a56057375f57ef03a72936016ba5cbce8c26fe00d5310213d3e.jpg",
+        "image_caption": [
+            "Figure 24: Hypernet Output Layer Activations before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            116,
+            818,
+            255
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/9d817c31284315aba6647c77ebb8a9afa3ecc3700c82c9ccfcb41bb42e22f858.jpg",
+        "image_caption": [
+            "Figure 25: Evolution of Hypernet Output Layer Activations during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            323,
+            818,
+            463
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/56026f4e97d7e379a614942b22a7ffc40a406a8bf33ec0a7c07b6df36e7215b0.jpg",
+        "image_caption": [
+            "Figure 26: Hypernet Output Layer Activations at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            529,
+            818,
+            670
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/51ae1852a9f6a32993ce3a7097bb9d1e61e776de968bde9f358e5b1c1632f1bf.jpg",
+        "image_caption": [
+            "Figure 27: Hypernet Output Layer Gradients before the Start of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            737,
+            821,
+            877
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e6c0ca464c04e4954fe6612ca993895012190b437d9a049140076f5769da66f.jpg",
+        "image_caption": [
+            "Figure 28: Evolution of Hypernet Output Layer Gradients during Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            220,
+            816,
+            358
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c88c933892305fb34cf49b49bb0626def6d0900b413b3fbe5338e4e64195d8d.jpg",
+        "image_caption": [
+            "Figure 29: Hypernet Output Layer Gradients at the End of Training on MNIST. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            635,
+            821,
+            773
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "B.1.3 REMARK ON THE COMBINATION OF FAN-IN AND FAN-OUT INIT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            671,
+            117
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Glorot & Bengio (2010) proposed to use the harmonic mean of the two different initialization formulae derived from the forward and backward pass. He et al. (2015) commented that either version suffices for convergence, and that it does not really matter given that the difference between the two will be a depth-independent factor. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            184
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "We experimented with the harmonic, geometric, and arithmetic means of the two different formulae in both the classical and the hypernet case. There was no indication of any significant benefit from taking any of the three different means in both cases. Thus, we confirm and concur with He et al. (2015)’s original observation that either the fan-in or the fan-out version suffices. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            246
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "B.2 CONTINUAL LEARNING ON REGRESSION TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            263,
+            550,
+            277
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "The mainnet is a feedforward network with two hidden layers (10 hidden units) and the ReLU activation function. The weights and biases of the mainnet are generated from a hypernet with two hidden layers (10 hidden units) and trainable embeddings of size 2 sampled from ${ \\dot { \\mathcal { U } } } ( - { \\sqrt { 3 } } , { \\sqrt { 3 } } )$ . We keep the same continual learning hyperparameter $\\beta _ { o u t p u t }$ value of 0.005 and pick the best learning rate for each initialization method from $\\{ 1 0 ^ { - 2 } , 1 0 ^ { - 3 } , 1 \\bar { 0 } ^ { - 4 } , 1 0 ^ { - 5 } \\}$ . Notably, Kaiming (fan-in) could only be trained from learning rate $1 0 ^ { - 5 }$ , with losses diverging soon after initialization using the other learning rates. Each task was trained for 6000 training iterations using batch size 32, with Figure 4 plotted from losses measured at every 100 iterations. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            404
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "B.3 CONVOLUTIONAL NETWORKS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            531,
+            435
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "The networks were trained on CIFAR-10 for 500 epochs starting with an initial learning rate of 0.0005 using batch size 100, and decaying with $\\gamma = 0 . 1$ at epochs 350 and 450. The hypernet is composed of two layers (50 hidden units) with separate embeddings and separate input layers but shared output layers. The weight generation happens in blocks of $( 9 6 , 3 , 3 )$ where $K = 9 6$ is the highest common factor between the different sizes of the convolutional layers in the mainnet and $n =$ 3 is the size of the convolutional filters (see Appendix Section A.2 for a more detailed explanation on the hypernet architecture). The embeddings are size 50 and fixed after random sampling from $\\mathcal { U } ( - \\sqrt { 3 } , \\sqrt { 3 } )$ . We use the mean cross entropy loss for training, but the summed cross entropy loss for testing. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            574
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "B.4 BAYESIAN NEURAL NETWORK ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            535,
+            604
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "text",
+        "text": "Ukai et al. (2018) showed that a Bayesian neural network can be developed by using a hypernetwork to express a prior distribution without substantial changes to the vanilla hypernetwork setting. Their methods simply require putting $\\mathcal { L } _ { 2 }$ -regularization on the model parameters and sampling from stochastic embeddings. We trained a linear hypernet to generate the weights of a MobileNet mainnet architecture (excluding the batch normalization layers), using the block-wise sampling strategy described in Ukai et al. (2018), with a factor of 0.0005 for the $\\mathcal { L } _ { 2 }$ -regularization. We initialize fixed embeddings of size 32 sampled from $\\mathcal { U } ( - \\sqrt { 3 } , \\sqrt { 3 } )$ , and sample additive stochastic noise coming from $\\mathcal { U } ( - \\mathrm { { \\bar { 0 } } } . 1 , 0 . 1 )$ at the beginning of every mini-batch training. The training was done on ImageNet with batch size 256 and learning rate 0.1 for 25 epochs, or equivalently, 125125 iterations. The testing was done with 10 Monte Carlo samples. We omit the test loss plots due to the computational expense of doing 10 forward passes after every mini-batch instead of every epoch. ",
+        "bbox": [
+            174,
+            616,
+            825,
+            772
+        ],
+        "page_idx": 20
+    }
+]

parse/train/JWRRBHFPKTJ/JWRRBHFPKTJ.md

@@ -0,0 +1,284 @@
+# SLAPS: Self-Supervision Improves Structure Learning for Graph Neural Networks
+
+Bahare Fatemi∗ University of British Columbia bfatemi@cs.ubc.ca
+
+Layla El Asri Borealis AI layla.elasri@borealisai.com
+
+Seyed Mehran Kazemi∗ Google Research mehrankazemi@google.com
+
+# Abstract
+
+Graph neural networks (GNNs) work well when the graph structure is provided. However, this structure may not always be available in real-world applications. One solution to this problem is to infer a task-specific latent structure and then apply a GNN to the inferred graph. Unfortunately, the space of possible graph structures grows super-exponentially with the number of nodes and so the taskspecific supervision may be insufficient for learning both the structure and the GNN parameters. In this work, we propose the Simultaneous Learning of Adjacency and GNN Parameters with Self-supervision, or SLAPS, a method that provides more supervision for inferring a graph structure through self-supervision. A comprehensive experimental study demonstrates that SLAPS scales to large graphs with hundreds of thousands of nodes and outperforms several models that have been proposed to learn a task-specific graph structure on established benchmarks.
+
+# 1 Introduction
+
+Graph representation learning has grown rapidly and found applications in domains where a natural graph of the data points is available [4, 25]. Graph neural networks (GNNs) [40] have been a key component to the success of the research in this area. Specifically, GNNs have shown promising results for semi-supervised classification when the available graph structure exhibits a high degree of homophily (i.e. connected nodes often belong to the same class) [57].
+
+We study the applicability of GNNs to (semi-supervised) classification problems where a graph structure is not readily available. The existing approaches for this problem either fix a similarity graph between the nodes or learn the GNN parameters and a graph structure simultaneously (see Related Work). In both cases, one main goal is to construct or learn a graph structure with a high degree of homophily with respect to the labels to aid the GNN classification. The latter approach is sometimes called latent graph learning and often results in higher predictive performance compared to the former approach (see, e.g., [12]).
+
+We identify a supervision starvation problem in latent graph learning approaches in which the edges between pairs of nodes that are far from labeled nodes receive insufficient supervision; this results in learning poor structures away from labeled nodes and hence poor generalization. We propose a solution for this problem by adopting a multi-task learning framework in which we supplement the classification task with a self-supervised task. The self-supervised task is based on the hypothesis that a graph structure that is suitable for predicting the node features is also suitable for predicting the node labels. It works by masking some input features (or adding noise to them) and training a separate GNN aiming at updating the adjacency matrix in such a way that it can recover the masked (or noisy) features. The task is generic and can be combined with several existing latent graph learning approaches.
+
+We develop a latent graph learning model, dubbed SLAPS, that adopts the proposed self-supervised task. We provide a comprehensive experimental study on nine datasets (thirteen variations) of various sizes and from various domains and perform thorough analyses to show the merit of SLAPS.
+
+Our main contributions include: 1) identifying a supervision starvation problem for latent graph learning, 2) proposing a solution for the identified problem through self-supervision, 3) developing SLAPS, a latent graph learning model that adopts the self-supervised solution, 4) providing comprehensive experimental results showing SLAPS substantially outperforms existing latent graph learning baselines from various categories on various benchmarks, and 5) providing an implementation for latent graph learning that scales to graphs with hundreds of thousands of nodes.
+
+# 2 Related work
+
+Existing methods that relate to this work can be grouped into the following categories. We discuss selected work from each category and refer the reader to [60] for a full survey.
+
+Similarity graph: One approach for inferring a graph structure is to select a similarity metric and set the edge weight between two nodes to be their similarity [39, 44, 3]. To obtain a sparse structure, one may create a kNN similarity graph, only connect pairs of nodes whose similarity surpasses some predefined threshold, or do sampling. As an example, in [14] a (fixed) kNN graph using the cosine similarity of the node features is created. In [47], this idea is extended by creating a fresh graph in each layer of the GNN based on the node embedding similarities in that layer. Instead of choosing a single similarity metric, in [15] several (potentially weak) measures of similarity are fused. The quality of the predictions of these methods depends heavily on the choice of the similarity metric(s).
+
+Fully connected graph: Another approach is to start with a fully connected graph and assign edge weights using the available meta-data or employ the GNN variants that provide weights for each edge via an attention mechanism [45, 53]. This approach has been used in computer vision [e.g., 43], natural language processing [e.g., 56], and few-shot learning [e.g., 13]. The complexity of this approach grows rapidly making it applicable only to small-sized graphs. Zhang et al. [54] propose to define local neighborhoods for each node and only assume that these local neighborhoods are fully connected. Their approach relies on an initial graph structure to define the local neighborhoods.
+
+Latent graph learning: Instead of a similarity graph based on the initial features, one may use a graph generator with learnable parameters. In [30], a fully connected graph is created based on a bilinear similarity function with learnable parameters. In [12], a Bernoulli distribution is learned for each possible edge and graph structures are created through sampling from these distributions. In [49], the input structure is updated to increase homophily based on the labels and model predictions. In [6], an iterative approach is proposed that iterates over projecting the nodes to a latent space and constructing an adjacency matrix from the latent representations multiple times. A common approach in this category is to learn a projection of the nodes to a latent space where node similarities correspond to edge weights or edge probabilities. In [48], the nodes are projected to a latent space by learning weights for each of the input features. In [38, 21, 8], a multi-layer perceptron is used for projection. In [52, 55], a GNN is used for projection; it uses the node features and an initial graph structure. In [26], different graph structures are created in different layers by using separate GNN projectors, where the input to the GNN projector in a layer is the projected values and the generated graph structure from the previous layer. In our experiments, we compare with several approaches from this category.
+
+Leveraging domain knowledge: In some applications, one may leverage domain knowledge to guide the model toward learning specific structures. For example, in [24], abstract syntax trees and regular languages are leveraged in learning graph structures of Python programs that aid reasoning for downstream tasks. In [23], the structure learning is guided for robustness to adversarial attacks through the domain knowledge that clean adjacency matrices are often sparse and low-rank and exhibit feature smoothness along the connected nodes. Other examples in this category include [19, 38]. In our paper, we experiment with general-purpose datasets without access to domain knowledge.
+
+Proposed method: Our model falls within the latent graph learning category. We supplement the training with a self-supervised objective to increase the amount of supervision in learning a structure. Our self-supervised task is inspired by, and similar to, the pre-training strategies for GNNs [17, 18, 22, 51, 58] (specifically, we adopt the multi-task learning framework of You et al. [51]), but it differs from this line of work as we use self-supervision for learning a graph structure whereas the above methods use it to learn better (and, in some cases, transferable) GNN parameters.
+
+# 3 Background and notation
+
+We use lowercase letters to denote scalars, bold lowercase letters to denote vectors and bold uppercase letters to denote matrices. $\pmb { I }$ represents an identity matrix. For a vector $\pmb { v }$ , we represent its $i ^ { \mathrm { { t h } } }$ element as ${ \mathbf { } } v _ { i }$ . For a matrix $M$ , we represent the $i ^ { \mathrm { { t h } } }$ row as $M _ { i }$ and the element at the $i ^ { \mathrm { { \bar { t h } } } }$ row and $j ^ { \mathrm { t h } }$ column as $M _ { i j }$ . For an attributed graph, we use $n , m$ and $f$ to represent the number of nodes, edges, and features respectively, and denote the graph as ${ \mathcal { G } } = \{ \gamma , A , X \}$ where $\mathcal { V } = \{ v _ { 1 } , \ldots , v _ { n } \}$ is a set of nodes, $\pmb { A } \in \mathbf { \mathbb { R } } ^ { n \times n }$ is an adjacency matrix with $\pmb { A } _ { i j }$ indicating the weight of the edge from $v _ { i }$ to $v _ { j }$ $( A _ { i j } = 0$ implies no edge), and $\ b { X } \in \mathbb { R } ^ { n \times f }$ is a matrix whose rows correspond to node features.
+
+Graph convolutional networks (GCNs) [27] are a powerful variant of GNNs. For a graph $\mathcal { G } =$ $\{ \gamma , A , X \}$ with a degree matrix $_ D$ , layer $l$ of the GCN architecture can be defined as $\pmb { H } ^ { ( l ) } =$ $\sigma ( \hat { A } H ^ { ( l - 1 ) } W ^ { ( l ) } )$ where $\hat { A }$ represents a normalized adjacency matrix, $\pmb { H } ^ { ( l - 1 ) } \in \mathbb { R } ^ { n \times d _ { l - 1 } }$ represents the node representations in layer ${ l - I }$ $\mathbf { { \cal H } } ^ { ( 0 ) } = { \cal X } )$ , $\pmb { W } ^ { ( l ) } \in \mathbb { R } ^ { d _ { l - 1 } \times d _ { l } }$ is a weight matrix, $\sigma$ is an activation function such as ReLU [34], and $\pmb { H } ^ { ( l ) } \in \mathbb { R } ^ { n \times d _ { l } }$ is the updated node embeddings. For undirected graphs where the adjacency is symmetric, $\hat { A } = D ^ { - \frac { 1 } { 2 } } \big ( \bar { A } + I ) D ^ { - \frac { 1 } { 2 } }$ corresponds to a row-and-column normalized adjacency with self-loops, and for directed graphs where the adjacency is not necessarily symmetric, $\hat { A } = \dot { D ^ { - 1 } } ( A + I )$ corresponds to a row normalized adjacency matrix with self-loops. Here, $_ { D }$ is a (diagonal) degree matrix for $( A + I )$ defined as $\begin{array} { r } { D _ { i i } = \bar { 1 } + \bar { \sum _ { j } } A _ { i j } } \end{array}$ .
+
+# 4 Proposed method: SLAPS
+
+SLAPS consists of four components: 1) generator, 2) adjacency processor, 3) classifier, and 4) self-supervision. Figure 1 illustrates these components. In the next three subsections, we explain the first three components. Then, we point out a supervision starvation problem for a model based only on these components. Then we describe the self-supervision component as a solution to the supervision starvation problem and the full SLAPS model.
+
+# 4.1 Generator
+
+The generator is a function $\mathsf { G } : \mathbb { R } ^ { n \times f }  \mathbb { R } ^ { n \times n }$ with parameters $\pmb { \theta } _ { \mathsf { G } }$ which takes the node features $\ b { X } \in \mathbb { R } ^ { n \times f }$ as input and produces a matrix $\tilde { \pmb { A } } \in \mathbb { R } ^ { n \times n }$ as output. We consider the following two generators and leave experimenting with more sophisticated graph generators (e.g., [50, 32, 31]) and models with tractable adjacency computations (e.g., [7]) as future work.
+
+Full parameterization (FP): For this generator, $\pmb { \theta } _ { \mathsf { G } } \in \mathbb { R } ^ { n \times n }$ and the generator function is defined as $\tilde { A } ^ { ^ { - } } = \mathsf { G } _ { F P } ( X ; \theta _ { \mathsf { G } } ) = \theta _ { \mathsf { G } }$ . That is, the generator ignores the input node features and directly optimizes the adjacency matrix. FP is similar to the generator in LDS [12] except that the generator of LDS treats each element of $\tilde { A }$ as the parameter of a Bernoulli distribution and samples graph structures from these distributions. FP is simple and flexible for learning any adjacency matrix but adds $n ^ { 2 }$ parameters which limits scalability and makes the model susceptible to overfitting.
+
+MLP-kNN: Here, $\pmb { \theta } _ { \mathsf { G } }$ corresponds to the weights of a multi-layer perceptron (MLP) and ${ \tilde { A } } =$ ${ \mathsf { G } } _ { \mathsf { M L P } } ( X ; \theta _ { \mathsf { G } } ) = { \mathsf { k N N } } ( { \mathsf { M L P } } ( X ) )$ , where ${ \mathsf { M L P } } : \mathbb { R } ^ { n \times f } \to \mathbb { R } ^ { n \times f ^ { \prime } }$ is an MLP that produces a matrix with updated node representations $X ^ { \prime }$ ; $\mathsf { k N N } : \mathbb { R } ^ { n \times f ^ { \prime } } \to \mathbb { R } ^ { n \times n }$ produces a sparse matrix. The implementation details for the kNN operation is provided in the supplementary material.
+
+Initialization and variants of MLP-kNN: Let $A ^ { k N N }$ represent an adjacency matrix created by applying a kNN function on the initial node features. One smart initialization for $\pmb { \theta } _ { \mathsf { G } }$ is to initialize it in a way that the generator initially generates $A ^ { k N N }$ (i.e. $\tilde { A } = A ^ { k N N }$ before training starts). This can be trivially done for the FP generator by initializing $\pmb { \theta } _ { \mathsf { G } }$ to $A ^ { k N N }$ . For MLP-kNN, we consider two variants. In one, hereafter referred to simply as MLP, we keep the input dimension the same throughout the layers. In the other, hereafter referred to as MLP-D, we consider MLPs with diagonal weight matrices (i.e., except the main diagonal, all other parameters in the weight matrices are zero). For both variants, we initialize the weight matrices in $\pmb { \theta } _ { \mathsf { G } }$ with the identity matrix to ensure that the output of the MLP is initially the same as its input and the kNN graph created on these outputs is equivalent to $A ^ { k N N }$ (alternatively, one may use other MLP variants but pre-train the weights to output $A ^ { k N N }$ before the main training starts.). MLP-D can be thought of as assigning different weights to different features and then computing node similarities.
+
+![](images/11250e292f2b1f217359d869c513b71a1ee256479d86baece0e3030b4c4b1eb7.jpg)  
+Figure 1: Overview of SLAPS. At the top, a generator receives the node features and produces a non-symmetric, non-normalized adjacency having (possibly) both positive and negative values (Section 4.1). The adjacency processor makes the values positive, symmetrizes and normalizes the adjacency (Section 4.2). The resulting adjacency and the node features go into $G N N _ { \mathrm { C } }$ which predicts the node classes (Section 4.3). At the bottom, some noise is added to the node features. The resulting noisy features and the generated adjacency go into $\mathsf { G N N } _ { \mathsf { D A E } }$ which then denoises the features (Section 4.5).
+
+# 4.2 Adjacency processor
+
+The output $\tilde { A }$ of the generator may have both positive and negative values, may be non-symmetric and non-normalized. We let $A \overset { \cdot } { = } \frac { 1 } { 2 } D ^ { - \frac { 1 } { 2 } } ( \bar { \mathsf { P } } ( \tilde { \pmb { A } } ) + \mathsf { P } ( \tilde { \pmb { A } } ) ^ { T } ) \bar { \mathbf { D } } ^ { - \frac { 1 } { 2 } }$ . Here $\mathsf { P }$ is a function with a non-negative range applied element-wise on its input – see supplementary material for details. The sub-expression $ { \frac { 1 } { 2 } } ( \mathsf { P } (  { \bar { \mathbf { A } } } ) + \mathsf { P } (  { \tilde { \mathbf { A } } } ) ^ { T } )$ makes the resulting matrix $\mathsf { \bar { P } } ( \tilde { A } )$ symmetric. To understand the reason for taking the mean of $\mathsf { P } ( \tilde { A } )$ and $\mathsf { P } ( \tilde { \mathbf { A } } ) ^ { T }$ , assume $\tilde { A }$ is generated by ${ \mathsf { G } } _ { { \mathsf { M L P } } }$ . If $v _ { j }$ is among the $k$ most similar nodes to $v _ { i }$ and vice versa, then the strength of the connection between $v _ { i }$ and $v _ { j }$ will remain the same. However, if, say, $v _ { j }$ is among the $k$ most similar nodes to $v _ { i }$ but $v _ { i }$ is not among the top $\mathrm { k }$ for $v _ { j }$ , then taking the average of the similarities reduces the strength of the connection between $v _ { i }$ and $v _ { j }$ . Finally, once we have a symmetric adjacency with non-negative values, we normalize $\frac 1 2 ( \mathsf { P } ( \tilde { \boldsymbol { A } } ) + \mathsf { P } ( \tilde { \boldsymbol { A } } ) ^ { T } )$ by computing its degree matrix $_ D$ and multiplying it from left and right to $D ^ { - { \frac { 1 } { 2 } } }$
+
+# 4.3 Classifier
+
+The classifier is a function ${ \mathsf { G N N } } _ { \mathsf { C } } : \mathbb { R } ^ { n \times f } \times \mathbb { R } ^ { n \times n }  \mathbb { R } ^ { n \times | { \mathcal { C } } | }$ with parameters $\theta _ { \mathsf { G N N } _ { \mathsf { C } } }$ . It takes the node features $\boldsymbol { X }$ and the generated adjacency $\pmb { A }$ as input and provides for each node the logits for each class. $\mathcal { C }$ corresponds to the classes and $| { \mathcal { C } } |$ corresponds to the number of classes. We use a twolayer GCN for which $\theta _ { \mathsf { G N N } _ { \mathsf { C } } } = \{ W ^ { ( 1 ) } , W ^ { ( 2 ) } \}$ and define our classifier as $\mathsf { G N N } _ { \mathsf { C } } ( A , X ; \theta _ { \mathsf { G N N } _ { \mathsf { C } } } ) =$ $A { \mathsf { R e L U } } ( A X W ^ { ( 1 ) } ) W ^ { ( 2 ) }$ but other GNN variants can be used as well (recall that $\pmb { A }$ is normalized). The training loss $\mathcal { L } _ { C }$ for the classification task is computed by taking the softmax of the logits to produce a probability distribution for each node and then computing the cross-entropy loss.
+
+# 4.4 Using only the first three components leads to supervision starvation
+
+One may create a model using only the three components described so far corresponding to the top part of Figure 1. As we will explain here, however, this model may suffer severely from supervision starvation. The same problem also applies to many existing approaches for latent graph learning, as they can be formulated as a combination of variants of these three components.
+
+Consider a scenario during training where two unlabeled nodes $v _ { i }$ and $v _ { j }$ are not directly connected to any labeled nodes according to the generated structure. Then, since a two-layer GCN makes predictions for the nodes based on their two-hop neighbors, the classification loss (i.e. $\mathcal { L } _ { C }$ ) is not affected by the edge between $v _ { i }$ and $v _ { j }$ and this edge receives no supervision2. Figure 2 provides an example of such a scenario. Let us call the edges that do not affect the loss function $\mathcal { L } _ { C }$ (and consequently do not receive supervision) as starved edges. These edges are problematic because although they may not affect the training loss, the predictions at the test time depend on these edges and if their values are learned without enough supervision, the model may make poor predictions at the test time. A natural question concerning the extent of the problem caused by such edges is the proportion of starved edges. The following theorem formally establishes the extent of the problem for Erdos-Rényi graphs [ ˝ 10]; in the supplementary, we extend this result to the Barabási–Albert model [1] and scale-free networks [2]. An Erd ˝os-Rényi graph with $n$ nodes and $m$ edges is a graph chosen uniformly at random from the collection of all graphs which have $n$ nodes and $m$ edges.
+
+![](images/e15f35860a8b9426e7d0e6406146068c9b8e5403003f5bfb4575f874203f385b.jpg)  
+Figure 2: Using a two-layer GCN, the predictions made for the labeled nodes are not affected by the dashed (starved) edge.
+
+Theorem 1 Let $\mathcal { G } ( n , m )$ be an Erd˝os-Rényi graph with n nodes and m edges. Assume we have labels for q nodes selected uniformly at random. The probability of an edge being a starved edge with a two-layer GCN is equal to $\begin{array} { r l } { ( 1 - \frac { q } { n } ) ( 1 - \frac { q } { n - 1 } ) \prod _ { i = 1 } ^ { 2 q } ( 1 - \frac { m - 1 } { { \binom { n } { 2 } } - i } ) } & { { } } \end{array}$ .
+
+We defer the proof to the supplementary material. To put the numbers from the theorem in perspective, let us consider three established benchmarks for semi-supervised node classification namely Cora, Citeseer, and Pubmed (the statistics for these datasets can be found in the Appendix). For an Erdos-Rényi graph with similar statistics as the Cora dataset (˝ $n = 2 7 0 8$ , $m = 5 4 2 9$ , $q = 1 4 0 .$ ), the probability of an edge being a starved edge is $5 9 . 4 \%$ according to the above theorem. For Citeseer and Pubmed, this number is $7 5 . 7 \%$ and $9 6 . { \bar { 7 } } \%$ respectively. While Theorem 1 is stated for Erdos-Rényi ˝ graphs, the identified problem also applies to natural graphs. For the original structures of Cora, Citeseer, and Pubmed, for example, $4 \bar { 8 } . \bar { 8 } \%$ , $6 5 . 2 \%$ , and $9 1 . 6 \%$ of the edges are starved edges.
+
+# 4.5 Self-supervision
+
+One possible solution to the supervision starvation problem is to define a prior graph structure and regularize the learned structure toward it. This leads the starved edges toward the prior structure as opposed to neglecting them. The choice of the prior is important as it determines the inductive bias incorporated into the model. We define a prior structure based on the following hypothesis:
+
+Hypothesis 1 A graph structure that is suitable for predicting the node features is also suitable for predicting the node labels.
+
+We first explain why the above hypothesis is reasonable for an extreme case that is easy to understand and then extend the explanation to the general case. Consider an extreme scenario where one of the node features is the same as the node labels. A graph structure that is suitable for predicting this feature exhibits homophily for it. Because of the equivalence between this feature and the labels, the graph structure also exhibits homophily for the labels, so it is also suitable for predicting the labels. In the general (non-extreme) case, there may not be a single feature that is equivalent to the labels but a subset of the features may be highly predictive of the labels. A graph structure that is suitable for predicting this subset exhibits homophily for the features in the subset. Because this subset is highly predictive of the labels, the structure also exhibits a high degree of homophily for the labels, so it is also suitable for predicting the node labels.
+
+Next, we explain how to design a suitable graph structure for predicting the features and how to regularize toward it. One could design such a structure manually (e.g., by handcrafting a graph that connects nodes based on the collective homophily between their individual features) and then penalize the difference between this prior graph and the learned graph. Alternatively, in this paper, we take a learning-based approach based on self-supervision where we not only use the learned graph structure for the classification task, but also for denoising the node features. The self-supervised task encourages the model to learn a structure that is suitable for predicting the node features. We describe this approach below and provide comparisons to the manual approach in the supplementary material.
+
+Our self-supervised task is based on denoising autoencoders [46]. Let $\mathsf { G N N } _ { \sf D A E } : \mathbb { R } ^ { n \times f } \times \mathbb { R } ^ { n \times n } $ $\mathbb { R } ^ { n \times f }$ be a GNN with parameters $\theta _ { \mathsf { G N N } _ { \mathsf { D A E } } }$ that takes node features and a generated adjacency as input and provides updated node features with the same dimension as output. We train $\mathsf { G N N } _ { \mathsf { D A E } }$ such that it receives a noisy version $\tilde { X }$ of the features $\boldsymbol { X }$ as input and produces the denoised features $\boldsymbol { X }$ as output. Let $i d x$ represent the indices corresponding to the elements of $\boldsymbol { X }$ to which we have added noise, and $X _ { i d x }$ represent the values at these indices. During training, we minimize:
+
+$$
+\mathcal { L } _ { D A E } = \mathsf { L } ( X _ { i d x } , \mathsf { G N N } _ { \mathsf { D A E } } ( \tilde { X } , A ; \theta _ { \mathsf { G N N } _ { \mathsf { D A E } } } ) _ { i d x } )
+$$
+
+where $\pmb { A }$ is the generated adjacency matrix and $\mathsf { L }$ is a loss function. For datasets where the features consist of binary vectors, $i d x$ consists of $r$ percent of the indices of $\boldsymbol { X }$ whose values are 1 and $r \eta$ percent of the indices whose values are 0, both selected uniformly at random in each epoch. Both $r$ and $\eta$ (corresponding to the negative ratio) are hyperparameters. In this case, we add noise by setting the 1s in the selected mask to 0s and L is the binary cross-entropy loss. For datasets where the input features are continuous numbers, $i d x$ consists of $r$ percent of the indices of $\boldsymbol { X }$ selected uniformly at random in each epoch. We add noise by either replacing the values at $i d x$ with 0 or by adding independent Gaussian noises to each of the features. In this case, L is the mean-squared error loss.
+
+Note that the self-supervised task in equation 1 is generic and can be added to different GNNs as well as latent graph learning models. It can be also combined with other techniques in the literature that encourage learning more homophilous structures or increase the amount of supervision. In our experiments, we test the combination of our self-supervised task with two such techniques namely self-training [29] and AdaEdge [5]. Self-training helps the model “see” more labeled nodes and AdaEdge helps iteratively create graph structure with higher degrees of homophily. We refer the reader to the supplementary material for descriptions of self-training and AdaEdge.
+
+# 4.6 SLAPS
+
+Our final model is trained to minimize $\mathcal { L } = \mathcal { L } _ { C } + \lambda \mathcal { L } _ { D A E }$ where $\mathcal { L } _ { C }$ is the classification loss, $\mathcal { L } _ { D A E }$ is the denoising autoencoder loss (see Equation 1), and $\lambda$ is a hyperparameter controlling the relative importance of the two losses.
+
+# 5 Experiments
+
+In this section, we report our key results. More empirical comparisons, experimental analyses, and ablation studies are presented in the supplementary material.
+
+Baselines: We compare our proposal to several baselines with different properties. The first baseline is a multi-layer perceptron (MLP) which does not take the graph structure into account. We also compare against MLP-GAM\* [42] which learns a fully connected graph structure and uses this structure to supplement the loss function of the MLP toward predicting similar labels for neighboring nodes. Our third baseline is label propagation (LP) [59], a well-known model for semi-supervised learning. Similar to [12], we also consider a baseline named kNN-GCN where we create a kNN graph based on the node feature similarities and feed this graph to a GCN; the graph structure remains fixed in this approach. We also compare with prominent existing latent graph learning models including LDS [12], GRCN [52], DGCNN [47], and IDGL [6]. In [6], another variant named IDGL-ANCH is also proposed that reduces time complexity through anchor-based approximation [33]. We compare against the base IDGL model because it does not sacrifice accuracy for time complexity, and because anchor-based approximation is model-agnostic and could be combined with other models too. We feed a kNN graph to the models requiring an initial graph structure. We also explore how adding self-training and AdaEdge impact the performance of kNN-GCN as well as SLAPS.
+
+Table 1: Results of SLAPS and the baselines on established node classification benchmarks. † indicates results have been taken from Franceschi et al. [12]. $\ddagger$ indicates results have been taken from Stretcu et al. [42]. Bold and underlined values indicate best and second-best mean performances respectively. OOM indicates out of memory. OOT indicates out of time (we allowed 24h for each run). NA indicates not applicable.   
+
+<table><tr><td>Model</td><td>Cora</td><td>Citeseer</td><td>Cora390</td><td>Citeseer370</td><td>Pubmed</td><td>ogbn-arxiv</td></tr><tr><td>MLP</td><td>56.1±1.6†</td><td>56.7±1.7†</td><td>65.8±0.4</td><td>67.1±0.5</td><td>71.4±0.0</td><td>54.7± 0.1</td></tr><tr><td>MLP-GAM*</td><td>70.7+</td><td>70.3</td><td></td><td></td><td>71.9t</td><td>一</td></tr><tr><td>LP</td><td>37.6 ± 0.0</td><td>23.2±0.0</td><td>36.2±0.0</td><td>29.1±0.0</td><td>41.3± 0.0</td><td>OOM</td></tr><tr><td>kNN-GCN</td><td>66.5 ±0.4†</td><td>68.3 ± 1.3†</td><td>72.5 ± 0.5</td><td>71.8 ±0.8</td><td>70.4± 0.4</td><td>49.1 ± 0.3</td></tr><tr><td>LDS</td><td></td><td></td><td>71.5± 0.8†</td><td>71.5 ± 1.1†</td><td>OOM</td><td>OOM</td></tr><tr><td>GRCN</td><td>67.4± 0.3</td><td>67.3±0.8</td><td>71.3 ± 0.9</td><td>70.9±0.7</td><td>67.3 ± 0.3</td><td>OOM</td></tr><tr><td>DGCNN</td><td>56.5 ± 1.2</td><td>55.1 ± 1.4</td><td>67.3± 0.7</td><td>66.6±0.8</td><td>70.1 ± 1.3</td><td>OOM</td></tr><tr><td>IDGL</td><td>70.9 ±0.6</td><td>68.2±0.6</td><td>73.4± 0.5</td><td>72.7±0.4</td><td>72.3 ± 0.4</td><td>OOM</td></tr><tr><td>kNN-GCN+ AdaEdge</td><td>67.7 ± 1.0</td><td>68.8 ±1.0</td><td>72.2 ±0.4</td><td>71.8 ±0.6</td><td>OOT</td><td>OOT</td></tr><tr><td>kNN-GCN + self-training</td><td>67.3 ± 0.3</td><td>69.8 ± 1.0</td><td>71.1 ± 0.3</td><td>72.4 ± 0.2</td><td>72.7 ± 0.1</td><td>NA</td></tr><tr><td>SLAPS (FP)</td><td>72.4 ± 0.4</td><td>70.7±0.4</td><td>76.6±0.4</td><td>73.1±0.6</td><td>OOM</td><td>OOM</td></tr><tr><td>SLAPS (MLP)</td><td>72.8 ± 0.8</td><td>70.5 ± 1.1</td><td>75.3 ± 1.0</td><td>73.0± 0.9</td><td>74.4±0.6</td><td>56.6±0.1</td></tr><tr><td>SLAPS (MLP-D)</td><td>73.4 ± 0.3</td><td>72.6 ± 0.6</td><td>75.1± 0.5</td><td>73.9 ± 0.4</td><td>73.1±0.7</td><td>52.9 ±0.1</td></tr><tr><td>SLAPS (MLP) + AdaEdge</td><td>72.8± 0.7</td><td>70.6 ± 1.5</td><td>75.2± 0.6</td><td>72.6±1.4</td><td>OOT</td><td>OOT</td></tr><tr><td>SLAPS (MLP) + self-training</td><td>74.2 ± 0.5</td><td>73.1 ± 1.0</td><td>75.5± 0.7</td><td>73.3 ± 0.6</td><td>74.3± 1.4</td><td>NA</td></tr></table>
+
+Datasets: We use three established benchmarks in the GNN literature namely Cora, Citeseer, and Pubmed [41] as well as the ogbn-arxiv dataset [16] that is orders of magnitude larger than the other three datasets and is more challenging due to the more realistic split of the data into train, validation, and test sets. For these datasets, we only feed the node features to the models and not their original graph structure. Following [12, 6], we also experiment with several classification (non-graph) datasets available in scikit-learn [36] including Wine, Cancer, Digits, and 20News. Furthermore, following [20], we also provide results on MNIST [28]. The dataset statistics can be found in the supplementary. For Cora and Citeseer, the LDS model uses the train data for learning the parameters of the classification GCN, half of the validation for learning the parameters of the adjacency matrix (in their bi-level optimization setup, these are considered as hyperparameters), and the other half of the validation set for early stopping and tuning the other hyperparameters. Besides experimenting with the original setups of these two datasets, we also consider a setup that is closer to that of LDS: we use the train set and half of the validation set for training and the other half of validation for early stopping and hyperparameter tuning. We name the modified versions Cora390 and Citeseer370 respectively where the number proceeding the dataset name shows the number of labels from which gradients are computed. We follow a similar procedure for the scikit-learn datasets.
+
+Implementation: We defer the implementation details and the best hyperparameter settings for our model on all the datasets to the supplementary material.
+
+# 5.1 Comparative results
+
+The results of SLAPS and the baselines on our benchmarks are reported in Tables 1 and 2. We start by analyzing the results in Table 1 first. Starting with the baselines, we see that learning a fully connected graph in MLP-GAM\* makes it outperform MLP. kNN-GCN significantly outperforms MLP on Cora and Citeseer but underperforms on Pubmed and ogbn-arxiv. Furthermore, both self-training and AdaEdge improve the performance of kNN-GCN. This shows the importance of the similarity metric and the graph structure that is fed into GCN; a low-quality structure can harm model performance. LDS outperforms MLP but the fully parameterized adjacency matrix of LDS results in memory issues for Pubmed and ogbn-arxiv. As for GRCN, it was shown in the original paper that GRCN can revise a good initial adjacency matrix and provide a substantial boost in performance. However, as evidenced by the results, if the initial graph structure is somewhat poor, GRCN’s performance becomes on par with kNN-GCN. IDGL is the best performing baseline.
+
+Table 2: Results on classification datasets. $\dagger$ indicates results have been taken from Franceschi et al. [12]. Bold and underlined values indicate best and second-best mean performances respectively.   
+
+<table><tr><td>Model</td><td>Wine</td><td>Cancer</td><td>Digits</td><td>20news</td></tr><tr><td>MLP</td><td>96.1±1.0</td><td>95.3±0.9</td><td>81.9±1.0</td><td>30.4±0.1</td></tr><tr><td>kNN-GCN</td><td>93.5±0.7</td><td>95.3±0.4</td><td>95.4±0.4</td><td>46.3±0.3</td></tr><tr><td>LDS</td><td>97.3 ±0.4†</td><td>94.4 ± 1.9†</td><td>92.5±0.7†</td><td>46.4 ± 1.6†</td></tr><tr><td>IDGL</td><td>97.0±0.7</td><td>94.2 ±2.3</td><td>92.5 ±1.3</td><td>48.5±0.6</td></tr><tr><td>SLAPS (FP)</td><td>96.6±0.4</td><td>94.6±0.3</td><td>94.4 ± 0.7</td><td>44.4±0.8</td></tr><tr><td>SLAPS (MLP)</td><td>96.3 ±1.0</td><td>96.0±0.8</td><td>92.5±0.7</td><td>50.4±0.7</td></tr><tr><td>SLAPS (MLP-D)</td><td>96.5±0.8</td><td>96.6±0.2</td><td>94.2 ± 0.1</td><td>49.8±0.9</td></tr></table>
+
+In addition to the aforementioned baselines, we also experimented with GCN, GAT, and Transformer (encoder only) architectures applied on fully connected graphs. GCN always learned to predict the majority class. This is because after one fully connected GCN layer, all nodes will have the same embedding and become indistinguishable. GAT also showed similar behavior. We believe this is because the attention weights are (almost) random at the beginning (due to random initialization of the model parameters) resulting in nodes becoming indistinguishable and GAT cannot escape from that state. The skip connections of Transformer helped avoid the problem observed for GCN and GAT and we were able to achieve better results $( \sim 4 0 \%$ accuracy on Cora). However, we observed severe overfitting, even with small models and with high dropout probabilities.
+
+SLAPS consistently outperforms the baselines in some cases by large margins. Among the generators, the winner is dataset-dependent with MLP-D mostly outperforming MLP on datasets with many features and MLP outperforming on datasets with small numbers of features. Using the software that was publicly released by the authors, the baselines that learn a graph structure fail on ogbn-arxiv; our implementation, on the other hand, scales to such large graphs3. Adding self-training helps further improve the results of SLAPS. Adding AdaEdge, however, does not seem effective, probably because the graph structure learned by SLAPS already exhibits a high degree of homophily (see Section 5.4).
+
+In Table 2, we only compared SLAPS with the best performing baselines from Table 1 (kNN-GCN, LDS and IDGL). We also included an MLP baseline for comparison. On three out of four datasets, SLAPS outperforms the LDS and IDGL baselines. For the Digits dataset, interestingly kNN-GCN outperforms the learning-based models. This could be because the initial kNN structure for this dataset is already a good structure. Among the datasets on which we can train SLAPS with the FP generator, 20news has the largest number of nodes (9,607 nodes). On this dataset, we observed that an FP generator suffers from overfitting and produces weaker results compared to other generators due to its large number of parameters.
+
+Jiang et al. [21] show that learning a latent graph structure of the input examples can help with
+
+semi-supervised image classification. In particular, they create three versions of the MNIST dataset each consisting of a randomly selected subset with 10,000 examples in total. The first version contains 1000 labels for training, the second contains 2000, and the third version contains 3000 labels for training. All three variants use an extra 1000 labels for validation. The other examples are used as test examples. Here, we conduct an experiment to measure the performance of SLAPS on these variants of the MNIST dataset. We compare against GLCN [21] as well as the baselines in the GLCN paper including manifold regularization [3], label propagation,
+
+Table 3: Results on the MNIST dataset. Bold values indicate best mean performances. Underlined values indicate second best mean performance. All the results for baseline have been taken from [20].   
+
+<table><tr><td>Model</td><td>MNIST1000</td><td>MNIST2000</td><td>MNIST3000</td></tr><tr><td>ManiReg LP DeepWalk</td><td>92.74± 0.3 79.28 ±0.9 94.55 ± 0.3</td><td>93.96±0.2 81.91±0.8 95.04± 0.3</td><td>94.62±0.2 83.45 ± 0.5 95.34± 0.3</td></tr><tr><td>GCN GAT</td><td>90.59 ± 0.3 92.11 ±0.4 94.28 ± 0.3</td><td>90.91± 0.2 92.64 ± 0.3 95.09 ± 0.2</td><td>91.01 ± 0.2 92.81 ± 0.3 95.46 ±0.2</td></tr><tr><td>GLCN SLAPS</td><td colspan="3">94.66± 0.2 95.35 ± 0.1 95.54± 0.0</td></tr></table>
+
+deep walk [37], graph convolutional networks (GCN), and graph attention networks (GAT).
+
+The results are reported in Table 3. From the results, it can be viewed that SLAPS outperforms GLCN and all the other baselines on the 3 variants. Compared to GLCN, on the three variants SLAPS reduces the error by $7 \% , 5 \%$ , and $2 \%$ respectively, showing that SLAPS can be more effective when the labeled set is small and providing more empirical evidence for Theorem 1.
+
+# 5.2 The effectiveness of self-supervision
+
+Learning a structure only using self-supervision: To provide more insight into the value provided by the self-supervision task and the generalizability of the adjacency learned through this task, we conduct experiments with a variant of SLAPS named $S L A P S _ { 2 s }$ that is trained in two stages. We first train the GNNDAE model by minimizing $\mathcal { L } _ { D A E }$ described in in Equation 1. Recall that $\mathcal { L } _ { D A E }$ depends on the parameters $\pmb { \theta } _ { \mathsf { G } }$ of the generator and the parameters $\theta _ { \mathsf { G N N } _ { \mathsf { D A E } } }$ of the denoising autoencoder. After every $t$ epochs of training, we fix the adjacency matrix, train a classifier with the fixed adjacency matrix, and measure classification accuracy on the validation set. We select the epoch that produces the adjacency providing the best validation accuracy for the classifier. Note that in $S L A P S _ { 2 s }$ , the adjacency matrix only receives gradients from the self-supervised task in Equation 1.
+
+![](images/7670a30bced9784814f16fbf60c6d6838f058afc569fd867c36471666b0e8906.jpg)  
+Figure 3: SLAPS vs $\mathrm { S L A P S } _ { 2 s }$ on Cora with different generators.
+
+Figure 3 shows the performance of SLAPS and $\mathrm { S L A P S } _ { 2 s }$ on Cora and compares them with kNNGCN. Although $\mathrm { S L A P S } _ { 2 s }$ does not use the node labels in learning an adjacency matrix, it outperforms kNN-GCN $8 . 4 \%$ improvement when using an FP generator). With an FP generator, $\mathrm { S L A P S } _ { 2 s }$ even achieves competitive performance with SLAPS; this is mainly because FP does not leverage the supervision provided by $\mathsf { G C N } _ { \mathsf { C } }$ toward learning generalizable patterns that can be used for nodes other than those in the training set. These results corroborate the effectiveness of the self-supervision task for learning an adjacency matrix. Besides, the results show that learning the adjacency using both self-supervision and the task-specific node labels results in higher predictive accuracy.
+
+The value of λ: Figure 4 shows the performance of SLAPS4 on Cora and Citeseer with different values of $\lambda$ . When $\lambda = 0$ , corresponding to removing self-supervision, the model performance is somewhat poor. As soon as $\lambda$ becomes positive, both models see a large boost in performance showing that self-supervision is crucial to the high performance of SLAPS. Increasing $\lambda$ further provides larger boosts until it becomes so large that the self-supervision loss dominates the classification loss and the performance deteriorates. Note that with $\lambda = 0$ , SLAPS with the MLP generator becomes a variant of the model proposed in [8], but with a different similarity function.
+
+Is self-supervision actually solving the supervision starvation problem? In Fig 4, we showed that self-supervision is key to the high performance of SLAPS. Here, we examine if this is because self-supervision indeed addresses the supervision starvation problem. For this purpose, we compare SLAPS with and without self-supervision on two groups of test nodes on Cora: 1) those that are not connected to any labeled nodes after training, and 2) those that are connected to at least one labeled node after training. The nodes in group one have a high chance of having starved edges. We observed that adding self-supervision provides $3 8 . 0 \%$ improvement for the first group and only $8 . 9 \%$ improvement for the latter. Since self-supervision mainly helps with nodes in group 1, this provides evidence that self-supervision is an effective solution to the supervision starvation problem.
+
+![](images/76589f76b89b7d9ccc11cbd765d95616b6c2fdd9b504c901c1bee98e69c2471f.jpg)  
+Figure 4: The performance of SLAPS with MLP graph generator as a function of $\lambda$ .
+
+The effect of the training set size: According to Theorem 1, a smaller $q$ (corresponding to the training set size) results in more starved edges in each epoch. To explore the effect of self-supervision as a function of $q$ , we compared SLAPS with and without supervision on Cora and Citeseer while reducing the number of labeled nodes per class from 20 to 5. We used the FP generator for this experiment. With 5 labeled nodes per class, adding self-supervision provides $\bar { 1 6 . 7 \% }$ and $2 2 . 0 \%$ improvements on Cora and Citeseer respectively, which is substantially higher than the corresponding numbers when using 20 labeled nodes per class $( 1 0 . 0 \%$ and $7 . 0 \%$ respectively). This provides empirical evidence for Theorem 1. Note that the results on Cora390 and Citeseer 370 datasets provide evidence that the self-supervised task is effective even when the label rate is high.
+
+# 5.3 Experiments with noisy graphs
+
+The performance of GNNs highly depends on the quality of the input graph structure and deteriorates when the graph structure is noisy [see 61, 9, 11]. Here, we verify whether selfsupervision is also helpful when a noisy structure is provided as input. Toward this goal, we experiment with Cora and Citeseer and provide noisy versions of the input graph as input. The provided noisy graph structure is used only for initialization; it is then further optimized by SLAPS. We perturb the graph structure by replacing $\rho$ percent of the edges in the original structure (selected uniformly at random) with random edges. Figure 5 shows the performance of SLAPS with and without self-supervision $\lambda = 0$ corresponds to no supervision). We also report the results of vanilla GCN on these perturbed graphs for comparison. It can be viewed that self-supervision consistently provides a boost in performance especially for higher values of $\rho$ .
+
+![](images/12cd5ec3eb9b5b405fa85b3dcbc13f5535f44a5bebd8117b328c83e5eece1c58.jpg)  
+Figure 5: Performance comparison when noisy graphs are provided as input ( $\dot { \rho }$ indicates the percentage of perturbations).
+
+# 5.4 Analyses of the learned adjacency
+
+Noisy graphs: Following the experiment in Section 5.3, we compared the learned and original structures by measuring the number of random edges added during perturbation but removed by the model and the number of edges removed during the perturbation but recovered by the model. For Cora, SLAPS removed $7 6 . 2 \%$ and $7 0 . 4 \%$ of the noisy edges and recovered $5 8 . 3 \%$ and $4 4 . 5 \%$ of the removed edges for $\rho \ = \ 2 5 \%$ and $\rho ~ = ~ 5 0 \%$ respectively while SLAPS with $\lambda = 0$ only removed $6 2 . 8 \%$ and $5 4 . 9 \%$ of the noisy edges and recovered $5 1 . 4 \%$ and $3 5 . 8 \%$ of the removed edges. This provides evidence on self-supervision being helpful for structure learning.
+
+Homophily: As explained earlier, a properly learned graph for semi-supervised classification with GNNs exhibits high homophily. To verify the quality of the learned adjacency with respect to homophily, for every pair of nodes in the test set, we compute the odds of the two nodes sharing the same label as a function of the normalized weight of the edge connecting them. Figure 6 represents the odds for different weight intervals (recall that $\pmb { A }$ is row and column normalized). For both Cora and Citeseer, nodes’ connected with higher edge weights are more likely to share the same label compared to nodes with lower or zero edge weights. Specifically, when $A _ { i j } \geq 0 . 1$ , $v _ { i }$ and $v _ { j }$ are almost 2.5 and 2.0 times more likely to share the same label on Cora and Citeseer respectively.
+
+![](images/4c6aa91f4d2a3918f530836850f5cdd2922db35c519b77c6725af6460fa24e6b.jpg)  
+Figure 6: The odds of two nodes in the test set sharing the same label as a function of the edge weights learned by SLAPS.
+
+# 6 Conclusion
+
+We proposed SLAPS: a model for learning the parameters of a graph neural network and a graph structure of the nodes connectivities simultaneously from data. We identified a supervision starvation problem that emerges for graph structure learning, especially when training data is scarce. We proposed a solution to the supervision starvation problem by supplementing the training objective with a well-motivated self-supervised task. We showed the effectiveness of our model through a comprehensive set of experiments and analyses.
+
+# 7 Funding Transparency Statement
+
+This work was fully funded by Borealis AI.
+
+References   
+[1] Réka Albert and Albert-László Barabási. Statistical mechanics of complex networks. Reviews of modern physics, 74(1):47, 2002.   
+[2] Albert-László Barabási and Réka Albert. Emergence of scaling in random networks. science, 286(5439):509–512, 1999.   
+[3] Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. JMLRR, 7(Nov):2399–2434, 2006.   
+[4] Ines Chami, Sami Abu-El-Haija, Bryan Perozzi, Christopher Ré, and Kevin Murphy. Machine learning on graphs: A model and comprehensive taxonomy. arXiv preprint arXiv:2005.03675, 2020.   
+[5] Deli Chen, Yankai Lin, Wei Li, Peng Li, Jie Zhou, and Xu Sun. Measuring and relieving the over-smoothing problem for graph neural networks from the topological view. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 3438–3445, 2020.   
+[6] Yu Chen, Lingfei Wu, and Mohammed J. Zaki. Deep iterative and adaptive learning for graph neural networks. In Neural Information Processing Systems (NeurIPS), 2020.   
+[7] Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   
+[8] Luca Cosmo, Anees Kazi, Seyed-Ahmad Ahmadi, Nassir Navab, and Michael Bronstein. Latent patient network learning for automatic diagnosis. arXiv preprint arXiv:2003.13620, 2020.   
+[9] Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. arXiv preprint arXiv:1806.02371, 2018.   
+[10] Paul Erdos and Alfred Rényi. On random graphs. ˝ Publicationes Mathematicae Debrecen, 6: 290–297, 1959.   
+[11] James Fox and Sivasankaran Rajamanickam. How robust are graph neural networks to structural noise? arXiv preprint arXiv:1912.10206, 2019.   
+[12] Luca Franceschi, Mathias Niepert, Massimiliano Pontil, and Xiao He. Learning discrete structures for graph neural networks. In ICML, 2019.   
+[13] Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. arXiv preprint arXiv:1711.04043, 2017.   
+[14] Spyros Gidaris and Nikos Komodakis. Generating classification weights with gnn denoising autoencoders for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 21–30, 2019.   
+[15] Jonathan Halcrow, Alexandru Mosoi, Sam Ruth, and Bryan Perozzi. Grale: Designing networks for graph learning. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2523–2532, 2020.   
+[16] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   
+[17] Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. In ICLR, 2020.   
+[18] Ziniu Hu, Yuxiao Dong, Kuansan Wang, Kai-Wei Chang, and Yizhou Sun. Gpt-gnn: Generative pre-training of graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1857–1867, 2020.   
+[19] Soobeom Jang, Seong-Eun Moon, and Jong-Seok Lee. Brain signal classification via learning connectivity structure. arXiv preprint arXiv:1905.11678, 2019.   
+[20] Bo Jiang, Ziyan Zhang, Doudou Lin, Jin Tang, and Bin Luo. Semi-supervised learning with graph learning-convolutional networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11313–11320, 2019.   
+[21] Bo Jiang, Ziyan Zhang, Doudou Lin, Jin Tang, and Bin Luo. Semi-supervised learning with graph learning-convolutional networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11313–11320, 2019.   
+[22] Wei Jin, Tyler Derr, Haochen Liu, Yiqi Wang, Suhang Wang, Zitao Liu, and Jiliang Tang. Self-supervised learning on graphs: Deep insights and new direction. arXiv preprint arXiv:2006.10141, 2020.   
+[23] Wei Jin, Yao Ma, Xiaorui Liu, Xianfeng Tang, Suhang Wang, and Jiliang Tang. Graph structure learning for robust graph neural networks. arXiv preprint arXiv:2005.10203, 2020.   
+[24] Daniel D Johnson, Hugo Larochelle, and Daniel Tarlow. Learning graph structure with a finite-state automaton layer. arXiv preprint arXiv:2007.04929, 2020.   
+[25] Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart. Representation learning for dynamic graphs: A survey. JMLR, 2020.   
+[26] Anees Kazi, Luca Cosmo, Nassir Navab, and Michael Bronstein. Differentiable graph module (dgm) for graph convolutional networks. arXiv preprint arXiv:2002.04999, 2020.   
+[27] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.   
+[28] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   
+[29] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In AAAI, 2018.   
+[30] Ruoyu Li, Sheng Wang, Feiyun Zhu, and Junzhou Huang. Adaptive graph convolutional neural networks. arXiv preprint arXiv:1801.03226, 2018.   
+[31] Renjie Liao, Yujia Li, Yang Song, Shenlong Wang, Charlie Nash, William L Hamilton, David Duvenaud, Raquel Urtasun, and Richard S Zemel. Efficient graph generation with graph recurrent attention networks. arXiv preprint arXiv:1910.00760, 2019.   
+[32] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. In NeurIPS, pages 13556–13566, 2019.   
+[33] Wei Liu, Junfeng He, and Shih-Fu Chang. Large graph construction for scalable semi-supervised learning. In ICML, 2010.   
+[34] Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Icml, 2010.   
+[35] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In ICLR, 2020.   
+[36] 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. JMLR, 12:2825–2830, 2011.   
+[37] 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.   
+[38] Shah Rukh Qasim, Jan Kieseler, Yutaro Iiyama, and Maurizio Pierini. Learning representations of irregular particle-detector geometry with distance-weighted graph networks. The European Physical Journal C, 79(7):1–11, 2019.   
+[39] Sam T Roweis and Lawrence K Saul. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500):2323–2326, 2000.   
+[40] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.   
+[41] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   
+[42] Otilia Stretcu, Krishnamurthy Viswanathan, Dana Movshovitz-Attias, Emmanouil Platanios, Sujith Ravi, and Andrew Tomkins. Graph agreement models for semi-supervised learning. In NeurIPS, pages 8713–8723, 2019.   
+[43] Mohammed Suhail and Leonid Sigal. Mixture-kernel graph attention network for situation recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 10363–10372, 2019.   
+[44] Joshua B Tenenbaum, Vin De Silva, and John C Langford. A global geometric framework for nonlinear dimensionality reduction. science, 290(5500):2319–2323, 2000.   
+[45] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2018.   
+[46] Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In ICML, pages 1096–1103, 2008.   
+[47] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog), 38(5):1–12, 2019.   
+[48] Xuan Wu, Lingxiao Zhao, and Leman Akoglu. A quest for structure: Jointly learning the graph structure and semi-supervised classification. In CIKM, pages 87–96, 2018.   
+[49] Liang Yang, Zesheng Kang, Xiaochun Cao, Di Jin, Bo Yang, and Yuanfang Guo. Topology optimization based graph convolutional network. In IJCAI, pages 4054–4061, 2019.   
+[50] Jiaxuan You, Rex Ying, Xiang Ren, William L Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. arXiv preprint arXiv:1802.08773, 2018.   
+[51] Yuning You, Tianlong Chen, Zhangyang Wang, and Yang Shen. When does self-supervision help graph convolutional networks? arXiv preprint arXiv:2006.09136, 2020.   
+[52] Donghan Yu, Ruohong Zhang, Zhengbao Jiang, Yuexin Wu, and Yiming Yang. Graph-revised convolutional network. In ECML PKDD, 2020.   
+[53] Jiani Zhang, Xingjian Shi, Junyuan Xie, Hao Ma, Irwin King, and Dit-Yan Yeung. Gaan: Gated attention networks for learning on large and spatiotemporal graphs. arXiv preprint arXiv:1803.07294, 2018.   
+[54] Jiawei Zhang, Haopeng Zhang, Congying Xia, and Li Sun. Graph-bert: Only attention is needed for learning graph representations. arXiv preprint arXiv:2001.05140, 2020.   
+[55] Tong Zhao, Yozen Liu, Leonardo Neves, Oliver Woodford, Meng Jiang, and Neil Shah. Data augmentation for graph neural networks. arXiv preprint arXiv:2006.06830, 2020.   
+[56] Hao Zhu, Yankai Lin, Zhiyuan Liu, Jie Fu, Tat-seng Chua, and Maosong Sun. Graph neural networks with generated parameters for relation extraction. arXiv preprint arXiv:1902.00756, 2019.   
+[57] Jiong Zhu, Yujun Yan, Lingxiao Zhao, Mark Heimann, Leman Akoglu, and Danai Koutra. Beyond homophily in graph neural networks: Current limitations and effective designs. Advances in Neural Information Processing Systems, 33, 2020.   
+[58] Qikui Zhu, Bo Du, and Pingkun Yan. Self-supervised training of graph convolutional networks. arXiv preprint arXiv:2006.02380, 2020.   
+[59] Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. 2002.   
+[60] Yanqiao Zhu, Weizhi Xu, Jinghao Zhang, Qiang Liu, Shu Wu, and Liang Wang. Deep graph structure learning for robust representations: A survey. arXiv preprint arXiv:2103.03036, 2021.   
+[61] Daniel Zügner, Amir Akbarnejad, and Stephan Günnemann. Adversarial attacks on neural networks for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2847–2856, 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]   
+(b) Did you describe the limitations of your work? [Yes] See supplementary material (the Limitations Section).   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(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] The full set of assumptions are given in Theorem 1.   
+(b) Did you include complete proofs of all theoretical results? [Yes] The proof is in the supplementary material.
+
+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)? [No] Due to copyright issues, we are not able to share an anonymous version of our code. However, the code will be publicly released upon the acceptance of the paper.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See the dataset paragraph in Section 5 and the dataset statistics table and best hyperparameters table 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 each experiment 10 times and report the mean and standard deviation.   
+(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 Implementation Details 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] (b) Did you mention the license of the assets? [No] The source websites specify the licenses. (c) Did you include any new assets either in the supplemental material or as a URL? [No]
+
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+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]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/JWRRBHFPKTJ/JWRRBHFPKTJ_content_list.json

@@ -0,0 +1,1308 @@
+[
+    {
+        "type": "text",
+        "text": "SLAPS: Self-Supervision Improves Structure Learning for Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            225,
+            122,
+            772,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bahare Fatemi∗ University of British Columbia bfatemi@cs.ubc.ca ",
+        "bbox": [
+            397,
+            226,
+            601,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Layla El Asri Borealis AI layla.elasri@borealisai.com ",
+        "bbox": [
+            243,
+            289,
+            478,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Seyed Mehran Kazemi∗ Google Research mehrankazemi@google.com ",
+        "bbox": [
+            553,
+            289,
+            754,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNNs) work well when the graph structure is provided. However, this structure may not always be available in real-world applications. One solution to this problem is to infer a task-specific latent structure and then apply a GNN to the inferred graph. Unfortunately, the space of possible graph structures grows super-exponentially with the number of nodes and so the taskspecific supervision may be insufficient for learning both the structure and the GNN parameters. In this work, we propose the Simultaneous Learning of Adjacency and GNN Parameters with Self-supervision, or SLAPS, a method that provides more supervision for inferring a graph structure through self-supervision. A comprehensive experimental study demonstrates that SLAPS scales to large graphs with hundreds of thousands of nodes and outperforms several models that have been proposed to learn a task-specific graph structure on established benchmarks. ",
+        "bbox": [
+            233,
+            400,
+            766,
+            565
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            310,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph representation learning has grown rapidly and found applications in domains where a natural graph of the data points is available [4, 25]. Graph neural networks (GNNs) [40] have been a key component to the success of the research in this area. Specifically, GNNs have shown promising results for semi-supervised classification when the available graph structure exhibits a high degree of homophily (i.e. connected nodes often belong to the same class) [57]. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            694
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We study the applicability of GNNs to (semi-supervised) classification problems where a graph structure is not readily available. The existing approaches for this problem either fix a similarity graph between the nodes or learn the GNN parameters and a graph structure simultaneously (see Related Work). In both cases, one main goal is to construct or learn a graph structure with a high degree of homophily with respect to the labels to aid the GNN classification. The latter approach is sometimes called latent graph learning and often results in higher predictive performance compared to the former approach (see, e.g., [12]). ",
+        "bbox": [
+            174,
+            700,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We identify a supervision starvation problem in latent graph learning approaches in which the edges between pairs of nodes that are far from labeled nodes receive insufficient supervision; this results in learning poor structures away from labeled nodes and hence poor generalization. We propose a solution for this problem by adopting a multi-task learning framework in which we supplement the classification task with a self-supervised task. The self-supervised task is based on the hypothesis that a graph structure that is suitable for predicting the node features is also suitable for predicting the node labels. It works by masking some input features (or adding noise to them) and training a separate GNN aiming at updating the adjacency matrix in such a way that it can recover the masked (or noisy) features. The task is generic and can be combined with several existing latent graph learning approaches. ",
+        "bbox": [
+            174,
+            804,
+            823,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We develop a latent graph learning model, dubbed SLAPS, that adopts the proposed self-supervised task. We provide a comprehensive experimental study on nine datasets (thirteen variations) of various sizes and from various domains and perform thorough analyses to show the merit of SLAPS. ",
+        "bbox": [
+            176,
+            166,
+            823,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions include: 1) identifying a supervision starvation problem for latent graph learning, 2) proposing a solution for the identified problem through self-supervision, 3) developing SLAPS, a latent graph learning model that adopts the self-supervised solution, 4) providing comprehensive experimental results showing SLAPS substantially outperforms existing latent graph learning baselines from various categories on various benchmarks, and 5) providing an implementation for latent graph learning that scales to graphs with hundreds of thousands of nodes. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            324,
+            316,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Existing methods that relate to this work can be grouped into the following categories. We discuss selected work from each category and refer the reader to [60] for a full survey. ",
+        "bbox": [
+            176,
+            359,
+            821,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Similarity graph: One approach for inferring a graph structure is to select a similarity metric and set the edge weight between two nodes to be their similarity [39, 44, 3]. To obtain a sparse structure, one may create a kNN similarity graph, only connect pairs of nodes whose similarity surpasses some predefined threshold, or do sampling. As an example, in [14] a (fixed) kNN graph using the cosine similarity of the node features is created. In [47], this idea is extended by creating a fresh graph in each layer of the GNN based on the node embedding similarities in that layer. Instead of choosing a single similarity metric, in [15] several (potentially weak) measures of similarity are fused. The quality of the predictions of these methods depends heavily on the choice of the similarity metric(s). ",
+        "bbox": [
+            174,
+            393,
+            825,
+            505
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Fully connected graph: Another approach is to start with a fully connected graph and assign edge weights using the available meta-data or employ the GNN variants that provide weights for each edge via an attention mechanism [45, 53]. This approach has been used in computer vision [e.g., 43], natural language processing [e.g., 56], and few-shot learning [e.g., 13]. The complexity of this approach grows rapidly making it applicable only to small-sized graphs. Zhang et al. [54] propose to define local neighborhoods for each node and only assume that these local neighborhoods are fully connected. Their approach relies on an initial graph structure to define the local neighborhoods. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Latent graph learning: Instead of a similarity graph based on the initial features, one may use a graph generator with learnable parameters. In [30], a fully connected graph is created based on a bilinear similarity function with learnable parameters. In [12], a Bernoulli distribution is learned for each possible edge and graph structures are created through sampling from these distributions. In [49], the input structure is updated to increase homophily based on the labels and model predictions. In [6], an iterative approach is proposed that iterates over projecting the nodes to a latent space and constructing an adjacency matrix from the latent representations multiple times. A common approach in this category is to learn a projection of the nodes to a latent space where node similarities correspond to edge weights or edge probabilities. In [48], the nodes are projected to a latent space by learning weights for each of the input features. In [38, 21, 8], a multi-layer perceptron is used for projection. In [52, 55], a GNN is used for projection; it uses the node features and an initial graph structure. In [26], different graph structures are created in different layers by using separate GNN projectors, where the input to the GNN projector in a layer is the projected values and the generated graph structure from the previous layer. In our experiments, we compare with several approaches from this category. ",
+        "bbox": [
+            174,
+            614,
+            825,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Leveraging domain knowledge: In some applications, one may leverage domain knowledge to guide the model toward learning specific structures. For example, in [24], abstract syntax trees and regular languages are leveraged in learning graph structures of Python programs that aid reasoning for downstream tasks. In [23], the structure learning is guided for robustness to adversarial attacks through the domain knowledge that clean adjacency matrices are often sparse and low-rank and exhibit feature smoothness along the connected nodes. Other examples in this category include [19, 38]. In our paper, we experiment with general-purpose datasets without access to domain knowledge. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposed method: Our model falls within the latent graph learning category. We supplement the training with a self-supervised objective to increase the amount of supervision in learning a structure. Our self-supervised task is inspired by, and similar to, the pre-training strategies for GNNs [17, 18, 22, 51, 58] (specifically, we adopt the multi-task learning framework of You et al. [51]), but it differs from this line of work as we use self-supervision for learning a graph structure whereas the above methods use it to learn better (and, in some cases, transferable) GNN parameters. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Background and notation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            227,
+            419,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use lowercase letters to denote scalars, bold lowercase letters to denote vectors and bold uppercase letters to denote matrices. $\\pmb { I }$ represents an identity matrix. For a vector $\\pmb { v }$ , we represent its $i ^ { \\mathrm { { t h } } }$ element as ${ \\mathbf { } } v _ { i }$ . For a matrix $M$ , we represent the $i ^ { \\mathrm { { t h } } }$ row as $M _ { i }$ and the element at the $i ^ { \\mathrm { { \\bar { t h } } } }$ row and $j ^ { \\mathrm { t h } }$ column as $M _ { i j }$ . For an attributed graph, we use $n , m$ and $f$ to represent the number of nodes, edges, and features respectively, and denote the graph as ${ \\mathcal { G } } = \\{ \\gamma , A , X \\}$ where $\\mathcal { V } = \\{ v _ { 1 } , \\ldots , v _ { n } \\}$ is a set of nodes, $\\pmb { A } \\in \\mathbf { \\mathbb { R } } ^ { n \\times n }$ is an adjacency matrix with $\\pmb { A } _ { i j }$ indicating the weight of the edge from $v _ { i }$ to $v _ { j }$ $( A _ { i j } = 0$ implies no edge), and $\\ b { X } \\in \\mathbb { R } ^ { n \\times f }$ is a matrix whose rows correspond to node features. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            357
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph convolutional networks (GCNs) [27] are a powerful variant of GNNs. For a graph $\\mathcal { G } =$ $\\{ \\gamma , A , X \\}$ with a degree matrix $_ D$ , layer $l$ of the GCN architecture can be defined as $\\pmb { H } ^ { ( l ) } =$ $\\sigma ( \\hat { A } H ^ { ( l - 1 ) } W ^ { ( l ) } )$ where $\\hat { A }$ represents a normalized adjacency matrix, $\\pmb { H } ^ { ( l - 1 ) } \\in \\mathbb { R } ^ { n \\times d _ { l - 1 } }$ represents the node representations in layer ${ l - I }$ $\\mathbf { { \\cal H } } ^ { ( 0 ) } = { \\cal X } )$ , $\\pmb { W } ^ { ( l ) } \\in \\mathbb { R } ^ { d _ { l - 1 } \\times d _ { l } }$ is a weight matrix, $\\sigma$ is an activation function such as ReLU [34], and $\\pmb { H } ^ { ( l ) } \\in \\mathbb { R } ^ { n \\times d _ { l } }$ is the updated node embeddings. For undirected graphs where the adjacency is symmetric, $\\hat { A } = D ^ { - \\frac { 1 } { 2 } } \\big ( \\bar { A } + I ) D ^ { - \\frac { 1 } { 2 } }$ corresponds to a row-and-column normalized adjacency with self-loops, and for directed graphs where the adjacency is not necessarily symmetric, $\\hat { A } = \\dot { D ^ { - 1 } } ( A + I )$ corresponds to a row normalized adjacency matrix with self-loops. Here, $_ { D }$ is a (diagonal) degree matrix for $( A + I )$ defined as $\\begin{array} { r } { D _ { i i } = \\bar { 1 } + \\bar { \\sum _ { j } } A _ { i j } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            362,
+            826,
+            500
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 Proposed method: SLAPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            517,
+            424,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SLAPS consists of four components: 1) generator, 2) adjacency processor, 3) classifier, and 4) self-supervision. Figure 1 illustrates these components. In the next three subsections, we explain the first three components. Then, we point out a supervision starvation problem for a model based only on these components. Then we describe the self-supervision component as a solution to the supervision starvation problem and the full SLAPS model. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 Generator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            285,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The generator is a function $\\mathsf { G } : \\mathbb { R } ^ { n \\times f }  \\mathbb { R } ^ { n \\times n }$ with parameters $\\pmb { \\theta } _ { \\mathsf { G } }$ which takes the node features $\\ b { X } \\in \\mathbb { R } ^ { n \\times f }$ as input and produces a matrix $\\tilde { \\pmb { A } } \\in \\mathbb { R } ^ { n \\times n }$ as output. We consider the following two generators and leave experimenting with more sophisticated graph generators (e.g., [50, 32, 31]) and models with tractable adjacency computations (e.g., [7]) as future work. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            715
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Full parameterization (FP): For this generator, $\\pmb { \\theta } _ { \\mathsf { G } } \\in \\mathbb { R } ^ { n \\times n }$ and the generator function is defined as $\\tilde { A } ^ { ^ { - } } = \\mathsf { G } _ { F P } ( X ; \\theta _ { \\mathsf { G } } ) = \\theta _ { \\mathsf { G } }$ . That is, the generator ignores the input node features and directly optimizes the adjacency matrix. FP is similar to the generator in LDS [12] except that the generator of LDS treats each element of $\\tilde { A }$ as the parameter of a Bernoulli distribution and samples graph structures from these distributions. FP is simple and flexible for learning any adjacency matrix but adds $n ^ { 2 }$ parameters which limits scalability and makes the model susceptible to overfitting. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "MLP-kNN: Here, $\\pmb { \\theta } _ { \\mathsf { G } }$ corresponds to the weights of a multi-layer perceptron (MLP) and ${ \\tilde { A } } =$ ${ \\mathsf { G } } _ { \\mathsf { M L P } } ( X ; \\theta _ { \\mathsf { G } } ) = { \\mathsf { k N N } } ( { \\mathsf { M L P } } ( X ) )$ , where ${ \\mathsf { M L P } } : \\mathbb { R } ^ { n \\times f } \\to \\mathbb { R } ^ { n \\times f ^ { \\prime } }$ is an MLP that produces a matrix with updated node representations $X ^ { \\prime }$ ; $\\mathsf { k N N } : \\mathbb { R } ^ { n \\times f ^ { \\prime } } \\to \\mathbb { R } ^ { n \\times n }$ produces a sparse matrix. The implementation details for the kNN operation is provided in the supplementary material. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            877
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Initialization and variants of MLP-kNN: Let $A ^ { k N N }$ represent an adjacency matrix created by applying a kNN function on the initial node features. One smart initialization for $\\pmb { \\theta } _ { \\mathsf { G } }$ is to initialize it in a way that the generator initially generates $A ^ { k N N }$ (i.e. $\\tilde { A } = A ^ { k N N }$ before training starts). This can be trivially done for the FP generator by initializing $\\pmb { \\theta } _ { \\mathsf { G } }$ to $A ^ { k N N }$ . For MLP-kNN, we consider two variants. In one, hereafter referred to simply as MLP, we keep the input dimension the same throughout the layers. In the other, hereafter referred to as MLP-D, we consider MLPs with diagonal weight matrices (i.e., except the main diagonal, all other parameters in the weight matrices are zero). For both variants, we initialize the weight matrices in $\\pmb { \\theta } _ { \\mathsf { G } }$ with the identity matrix to ensure that the output of the MLP is initially the same as its input and the kNN graph created on these outputs is equivalent to $A ^ { k N N }$ (alternatively, one may use other MLP variants but pre-train the weights to output $A ^ { k N N }$ before the main training starts.). MLP-D can be thought of as assigning different weights to different features and then computing node similarities. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/11250e292f2b1f217359d869c513b71a1ee256479d86baece0e3030b4c4b1eb7.jpg",
+        "image_caption": [
+            "Figure 1: Overview of SLAPS. At the top, a generator receives the node features and produces a non-symmetric, non-normalized adjacency having (possibly) both positive and negative values (Section 4.1). The adjacency processor makes the values positive, symmetrizes and normalizes the adjacency (Section 4.2). The resulting adjacency and the node features go into $G N N _ { \\mathrm { C } }$ which predicts the node classes (Section 4.3). At the bottom, some noise is added to the node features. The resulting noisy features and the generated adjacency go into $\\mathsf { G N N } _ { \\mathsf { D A E } }$ which then denoises the features (Section 4.5). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            88,
+            797,
+            260
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            402,
+            825,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 Adjacency processor ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            571,
+            356,
+            587
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The output $\\tilde { A }$ of the generator may have both positive and negative values, may be non-symmetric and non-normalized. We let $A \\overset { \\cdot } { = } \\frac { 1 } { 2 } D ^ { - \\frac { 1 } { 2 } } ( \\bar { \\mathsf { P } } ( \\tilde { \\pmb { A } } ) + \\mathsf { P } ( \\tilde { \\pmb { A } } ) ^ { T } ) \\bar { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } }$ . Here $\\mathsf { P }$ is a function with a non-negative range applied element-wise on its input – see supplementary material for details. The sub-expression $ { \\frac { 1 } { 2 } } ( \\mathsf { P } (  { \\bar { \\mathbf { A } } } ) + \\mathsf { P } (  { \\tilde { \\mathbf { A } } } ) ^ { T } )$ makes the resulting matrix $\\mathsf { \\bar { P } } ( \\tilde { A } )$ symmetric. To understand the reason for taking the mean of $\\mathsf { P } ( \\tilde { A } )$ and $\\mathsf { P } ( \\tilde { \\mathbf { A } } ) ^ { T }$ , assume $\\tilde { A }$ is generated by ${ \\mathsf { G } } _ { { \\mathsf { M L P } } }$ . If $v _ { j }$ is among the $k$ most similar nodes to $v _ { i }$ and vice versa, then the strength of the connection between $v _ { i }$ and $v _ { j }$ will remain the same. However, if, say, $v _ { j }$ is among the $k$ most similar nodes to $v _ { i }$ but $v _ { i }$ is not among the top $\\mathrm { k }$ for $v _ { j }$ , then taking the average of the similarities reduces the strength of the connection between $v _ { i }$ and $v _ { j }$ . Finally, once we have a symmetric adjacency with non-negative values, we normalize $\\frac 1 2 ( \\mathsf { P } ( \\tilde { \\boldsymbol { A } } ) + \\mathsf { P } ( \\tilde { \\boldsymbol { A } } ) ^ { T } )$ by computing its degree matrix $_ D$ and multiplying it from left and right to $D ^ { - { \\frac { 1 } { 2 } } }$ ",
+        "bbox": [
+            173,
+            603,
+            825,
+            753
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 Classifier ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            277,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The classifier is a function ${ \\mathsf { G N N } } _ { \\mathsf { C } } : \\mathbb { R } ^ { n \\times f } \\times \\mathbb { R } ^ { n \\times n }  \\mathbb { R } ^ { n \\times | { \\mathcal { C } } | }$ with parameters $\\theta _ { \\mathsf { G N N } _ { \\mathsf { C } } }$ . It takes the node features $\\boldsymbol { X }$ and the generated adjacency $\\pmb { A }$ as input and provides for each node the logits for each class. $\\mathcal { C }$ corresponds to the classes and $| { \\mathcal { C } } |$ corresponds to the number of classes. We use a twolayer GCN for which $\\theta _ { \\mathsf { G N N } _ { \\mathsf { C } } } = \\{ W ^ { ( 1 ) } , W ^ { ( 2 ) } \\}$ and define our classifier as $\\mathsf { G N N } _ { \\mathsf { C } } ( A , X ; \\theta _ { \\mathsf { G N N } _ { \\mathsf { C } } } ) =$ $A { \\mathsf { R e L U } } ( A X W ^ { ( 1 ) } ) W ^ { ( 2 ) }$ but other GNN variants can be used as well (recall that $\\pmb { A }$ is normalized). The training loss $\\mathcal { L } _ { C }$ for the classification task is computed by taking the softmax of the logits to produce a probability distribution for each node and then computing the cross-entropy loss. ",
+        "bbox": [
+            174,
+            809,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.4 Using only the first three components leads to supervision starvation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            686,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One may create a model using only the three components described so far corresponding to the top part of Figure 1. As we will explain here, however, this model may suffer severely from supervision starvation. The same problem also applies to many existing approaches for latent graph learning, as they can be formulated as a combination of variants of these three components. ",
+        "bbox": [
+            174,
+            116,
+            825,
+            171
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Consider a scenario during training where two unlabeled nodes $v _ { i }$ and $v _ { j }$ are not directly connected to any labeled nodes according to the generated structure. Then, since a two-layer GCN makes predictions for the nodes based on their two-hop neighbors, the classification loss (i.e. $\\mathcal { L } _ { C }$ ) is not affected by the edge between $v _ { i }$ and $v _ { j }$ and this edge receives no supervision2. Figure 2 provides an example of such a scenario. Let us call the edges that do not affect the loss function $\\mathcal { L } _ { C }$ (and consequently do not receive supervision) as starved edges. These edges are problematic because although they may not affect the training loss, the predictions at the test time depend on these edges and if their values are learned without enough supervision, the model may make poor predictions at the test time. A natural question concerning the extent of the problem caused by such edges is the proportion of starved edges. The following theorem formally establishes the extent of the problem for Erdos-Rényi graphs [ ˝ 10]; in the supplementary, we extend this result to the Barabási–Albert model [1] and scale-free networks [2]. An Erd ˝os-Rényi graph with $n$ nodes and $m$ edges is a graph chosen uniformly at random from the collection of all graphs which have $n$ nodes and $m$ edges. ",
+        "bbox": [
+            176,
+            179,
+            820,
+            220
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            220,
+            594,
+            415
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e15f35860a8b9426e7d0e6406146068c9b8e5403003f5bfb4575f874203f385b.jpg",
+        "image_caption": [
+            "Figure 2: Using a two-layer GCN, the predictions made for the labeled nodes are not affected by the dashed (starved) edge. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            612,
+            236,
+            823,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            415,
+            797,
+            429
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 Let $\\mathcal { G } ( n , m )$ be an Erd˝os-Rényi graph with n nodes and m edges. Assume we have labels for q nodes selected uniformly at random. The probability of an edge being a starved edge with a two-layer GCN is equal to $\\begin{array} { r l } { ( 1 - \\frac { q } { n } ) ( 1 - \\frac { q } { n - 1 } ) \\prod _ { i = 1 } ^ { 2 q } ( 1 - \\frac { m - 1 } { { \\binom { n } { 2 } } - i } ) } & { { } } \\end{array}$ . ",
+        "bbox": [
+            174,
+            440,
+            825,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We defer the proof to the supplementary material. To put the numbers from the theorem in perspective, let us consider three established benchmarks for semi-supervised node classification namely Cora, Citeseer, and Pubmed (the statistics for these datasets can be found in the Appendix). For an Erdos-Rényi graph with similar statistics as the Cora dataset (˝ $n = 2 7 0 8$ , $m = 5 4 2 9$ , $q = 1 4 0 .$ ), the probability of an edge being a starved edge is $5 9 . 4 \\%$ according to the above theorem. For Citeseer and Pubmed, this number is $7 5 . 7 \\%$ and $9 6 . { \\bar { 7 } } \\%$ respectively. While Theorem 1 is stated for Erdos-Rényi ˝ graphs, the identified problem also applies to natural graphs. For the original structures of Cora, Citeseer, and Pubmed, for example, $4 \\bar { 8 } . \\bar { 8 } \\%$ , $6 5 . 2 \\%$ , and $9 1 . 6 \\%$ of the edges are starved edges. ",
+        "bbox": [
+            173,
+            503,
+            826,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.5 Self-supervision ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            323,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One possible solution to the supervision starvation problem is to define a prior graph structure and regularize the learned structure toward it. This leads the starved edges toward the prior structure as opposed to neglecting them. The choice of the prior is important as it determines the inductive bias incorporated into the model. We define a prior structure based on the following hypothesis: ",
+        "bbox": [
+            174,
+            656,
+            825,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hypothesis 1 A graph structure that is suitable for predicting the node features is also suitable for predicting the node labels. ",
+        "bbox": [
+            176,
+            724,
+            823,
+            752
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first explain why the above hypothesis is reasonable for an extreme case that is easy to understand and then extend the explanation to the general case. Consider an extreme scenario where one of the node features is the same as the node labels. A graph structure that is suitable for predicting this feature exhibits homophily for it. Because of the equivalence between this feature and the labels, the graph structure also exhibits homophily for the labels, so it is also suitable for predicting the labels. In the general (non-extreme) case, there may not be a single feature that is equivalent to the labels but a subset of the features may be highly predictive of the labels. A graph structure that is suitable for predicting this subset exhibits homophily for the features in the subset. Because this subset is highly predictive of the labels, the structure also exhibits a high degree of homophily for the labels, so it is also suitable for predicting the node labels. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, we explain how to design a suitable graph structure for predicting the features and how to regularize toward it. One could design such a structure manually (e.g., by handcrafting a graph that connects nodes based on the collective homophily between their individual features) and then penalize the difference between this prior graph and the learned graph. Alternatively, in this paper, we take a learning-based approach based on self-supervision where we not only use the learned graph structure for the classification task, but also for denoising the node features. The self-supervised task encourages the model to learn a structure that is suitable for predicting the node features. We describe this approach below and provide comparisons to the manual approach in the supplementary material. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            237
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our self-supervised task is based on denoising autoencoders [46]. Let $\\mathsf { G N N } _ { \\sf D A E } : \\mathbb { R } ^ { n \\times f } \\times \\mathbb { R } ^ { n \\times n } $ $\\mathbb { R } ^ { n \\times f }$ be a GNN with parameters $\\theta _ { \\mathsf { G N N } _ { \\mathsf { D A E } } }$ that takes node features and a generated adjacency as input and provides updated node features with the same dimension as output. We train $\\mathsf { G N N } _ { \\mathsf { D A E } }$ such that it receives a noisy version $\\tilde { X }$ of the features $\\boldsymbol { X }$ as input and produces the denoised features $\\boldsymbol { X }$ as output. Let $i d x$ represent the indices corresponding to the elements of $\\boldsymbol { X }$ to which we have added noise, and $X _ { i d x }$ represent the values at these indices. During training, we minimize: ",
+        "bbox": [
+            174,
+            242,
+            825,
+            328
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60f1a472293ed69ef6b3597c803fb2549481aabe2b7473f096f576cf44c39c2f.jpg",
+        "text": "$$\n\\mathcal { L } _ { D A E } = \\mathsf { L } ( X _ { i d x } , \\mathsf { G N N } _ { \\mathsf { D A E } } ( \\tilde { X } , A ; \\theta _ { \\mathsf { G N N } _ { \\mathsf { D A E } } } ) _ { i d x } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            335,
+            658,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { A }$ is the generated adjacency matrix and $\\mathsf { L }$ is a loss function. For datasets where the features consist of binary vectors, $i d x$ consists of $r$ percent of the indices of $\\boldsymbol { X }$ whose values are 1 and $r \\eta$ percent of the indices whose values are 0, both selected uniformly at random in each epoch. Both $r$ and $\\eta$ (corresponding to the negative ratio) are hyperparameters. In this case, we add noise by setting the 1s in the selected mask to 0s and L is the binary cross-entropy loss. For datasets where the input features are continuous numbers, $i d x$ consists of $r$ percent of the indices of $\\boldsymbol { X }$ selected uniformly at random in each epoch. We add noise by either replacing the values at $i d x$ with 0 or by adding independent Gaussian noises to each of the features. In this case, L is the mean-squared error loss. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that the self-supervised task in equation 1 is generic and can be added to different GNNs as well as latent graph learning models. It can be also combined with other techniques in the literature that encourage learning more homophilous structures or increase the amount of supervision. In our experiments, we test the combination of our self-supervised task with two such techniques namely self-training [29] and AdaEdge [5]. Self-training helps the model “see” more labeled nodes and AdaEdge helps iteratively create graph structure with higher degrees of homophily. We refer the reader to the supplementary material for descriptions of self-training and AdaEdge. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            575
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.6 SLAPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            264,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our final model is trained to minimize $\\mathcal { L } = \\mathcal { L } _ { C } + \\lambda \\mathcal { L } _ { D A E }$ where $\\mathcal { L } _ { C }$ is the classification loss, $\\mathcal { L } _ { D A E }$ is the denoising autoencoder loss (see Equation 1), and $\\lambda$ is a hyperparameter controlling the relative importance of the two losses. ",
+        "bbox": [
+            176,
+            617,
+            823,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            679,
+            312,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we report our key results. More empirical comparisons, experimental analyses, and ablation studies are presented in the supplementary material. ",
+        "bbox": [
+            174,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines: We compare our proposal to several baselines with different properties. The first baseline is a multi-layer perceptron (MLP) which does not take the graph structure into account. We also compare against MLP-GAM\\* [42] which learns a fully connected graph structure and uses this structure to supplement the loss function of the MLP toward predicting similar labels for neighboring nodes. Our third baseline is label propagation (LP) [59], a well-known model for semi-supervised learning. Similar to [12], we also consider a baseline named kNN-GCN where we create a kNN graph based on the node feature similarities and feed this graph to a GCN; the graph structure remains fixed in this approach. We also compare with prominent existing latent graph learning models including LDS [12], GRCN [52], DGCNN [47], and IDGL [6]. In [6], another variant named IDGL-ANCH is also proposed that reduces time complexity through anchor-based approximation [33]. We compare against the base IDGL model because it does not sacrifice accuracy for time complexity, and because anchor-based approximation is model-agnostic and could be combined with other models too. We feed a kNN graph to the models requiring an initial graph structure. We also explore how adding self-training and AdaEdge impact the performance of kNN-GCN as well as SLAPS. ",
+        "bbox": [
+            173,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c9da0f53fdf439f9ef1d8ed77a8ce78f372d4699e42b2af81c54b8e8a6c64a4d.jpg",
+        "table_caption": [
+            "Table 1: Results of SLAPS and the baselines on established node classification benchmarks. † indicates results have been taken from Franceschi et al. [12]. $\\ddagger$ indicates results have been taken from Stretcu et al. [42]. Bold and underlined values indicate best and second-best mean performances respectively. OOM indicates out of memory. OOT indicates out of time (we allowed 24h for each run). NA indicates not applicable. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Cora</td><td>Citeseer</td><td>Cora390</td><td>Citeseer370</td><td>Pubmed</td><td>ogbn-arxiv</td></tr><tr><td>MLP</td><td>56.1±1.6†</td><td>56.7±1.7†</td><td>65.8±0.4</td><td>67.1±0.5</td><td>71.4±0.0</td><td>54.7± 0.1</td></tr><tr><td>MLP-GAM*</td><td>70.7+</td><td>70.3</td><td></td><td></td><td>71.9t</td><td>一</td></tr><tr><td>LP</td><td>37.6 ± 0.0</td><td>23.2±0.0</td><td>36.2±0.0</td><td>29.1±0.0</td><td>41.3± 0.0</td><td>OOM</td></tr><tr><td>kNN-GCN</td><td>66.5 ±0.4†</td><td>68.3 ± 1.3†</td><td>72.5 ± 0.5</td><td>71.8 ±0.8</td><td>70.4± 0.4</td><td>49.1 ± 0.3</td></tr><tr><td>LDS</td><td></td><td></td><td>71.5± 0.8†</td><td>71.5 ± 1.1†</td><td>OOM</td><td>OOM</td></tr><tr><td>GRCN</td><td>67.4± 0.3</td><td>67.3±0.8</td><td>71.3 ± 0.9</td><td>70.9±0.7</td><td>67.3 ± 0.3</td><td>OOM</td></tr><tr><td>DGCNN</td><td>56.5 ± 1.2</td><td>55.1 ± 1.4</td><td>67.3± 0.7</td><td>66.6±0.8</td><td>70.1 ± 1.3</td><td>OOM</td></tr><tr><td>IDGL</td><td>70.9 ±0.6</td><td>68.2±0.6</td><td>73.4± 0.5</td><td>72.7±0.4</td><td>72.3 ± 0.4</td><td>OOM</td></tr><tr><td>kNN-GCN+ AdaEdge</td><td>67.7 ± 1.0</td><td>68.8 ±1.0</td><td>72.2 ±0.4</td><td>71.8 ±0.6</td><td>OOT</td><td>OOT</td></tr><tr><td>kNN-GCN + self-training</td><td>67.3 ± 0.3</td><td>69.8 ± 1.0</td><td>71.1 ± 0.3</td><td>72.4 ± 0.2</td><td>72.7 ± 0.1</td><td>NA</td></tr><tr><td>SLAPS (FP)</td><td>72.4 ± 0.4</td><td>70.7±0.4</td><td>76.6±0.4</td><td>73.1±0.6</td><td>OOM</td><td>OOM</td></tr><tr><td>SLAPS (MLP)</td><td>72.8 ± 0.8</td><td>70.5 ± 1.1</td><td>75.3 ± 1.0</td><td>73.0± 0.9</td><td>74.4±0.6</td><td>56.6±0.1</td></tr><tr><td>SLAPS (MLP-D)</td><td>73.4 ± 0.3</td><td>72.6 ± 0.6</td><td>75.1± 0.5</td><td>73.9 ± 0.4</td><td>73.1±0.7</td><td>52.9 ±0.1</td></tr><tr><td>SLAPS (MLP) + AdaEdge</td><td>72.8± 0.7</td><td>70.6 ± 1.5</td><td>75.2± 0.6</td><td>72.6±1.4</td><td>OOT</td><td>OOT</td></tr><tr><td>SLAPS (MLP) + self-training</td><td>74.2 ± 0.5</td><td>73.1 ± 1.0</td><td>75.5± 0.7</td><td>73.3 ± 0.6</td><td>74.3± 1.4</td><td>NA</td></tr></table>",
+        "bbox": [
+            173,
+            172,
+            821,
+            376
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            415,
+            821,
+            443
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Datasets: We use three established benchmarks in the GNN literature namely Cora, Citeseer, and Pubmed [41] as well as the ogbn-arxiv dataset [16] that is orders of magnitude larger than the other three datasets and is more challenging due to the more realistic split of the data into train, validation, and test sets. For these datasets, we only feed the node features to the models and not their original graph structure. Following [12, 6], we also experiment with several classification (non-graph) datasets available in scikit-learn [36] including Wine, Cancer, Digits, and 20News. Furthermore, following [20], we also provide results on MNIST [28]. The dataset statistics can be found in the supplementary. For Cora and Citeseer, the LDS model uses the train data for learning the parameters of the classification GCN, half of the validation for learning the parameters of the adjacency matrix (in their bi-level optimization setup, these are considered as hyperparameters), and the other half of the validation set for early stopping and tuning the other hyperparameters. Besides experimenting with the original setups of these two datasets, we also consider a setup that is closer to that of LDS: we use the train set and half of the validation set for training and the other half of validation for early stopping and hyperparameter tuning. We name the modified versions Cora390 and Citeseer370 respectively where the number proceeding the dataset name shows the number of labels from which gradients are computed. We follow a similar procedure for the scikit-learn datasets. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Implementation: We defer the implementation details and the best hyperparameter settings for our model on all the datasets to the supplementary material. ",
+        "bbox": [
+            173,
+            676,
+            821,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparative results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            354,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results of SLAPS and the baselines on our benchmarks are reported in Tables 1 and 2. We start by analyzing the results in Table 1 first. Starting with the baselines, we see that learning a fully connected graph in MLP-GAM\\* makes it outperform MLP. kNN-GCN significantly outperforms MLP on Cora and Citeseer but underperforms on Pubmed and ogbn-arxiv. Furthermore, both self-training and AdaEdge improve the performance of kNN-GCN. This shows the importance of the similarity metric and the graph structure that is fed into GCN; a low-quality structure can harm model performance. LDS outperforms MLP but the fully parameterized adjacency matrix of LDS results in memory issues for Pubmed and ogbn-arxiv. As for GRCN, it was shown in the original paper that GRCN can revise a good initial adjacency matrix and provide a substantial boost in performance. However, as evidenced by the results, if the initial graph structure is somewhat poor, GRCN’s performance becomes on par with kNN-GCN. IDGL is the best performing baseline. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7654738f0d2e70f4d69422db1b5a26fa874157337ebd1b6cea5cf9f25a86823b.jpg",
+        "table_caption": [
+            "Table 2: Results on classification datasets. $\\dagger$ indicates results have been taken from Franceschi et al. [12]. Bold and underlined values indicate best and second-best mean performances respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Wine</td><td>Cancer</td><td>Digits</td><td>20news</td></tr><tr><td>MLP</td><td>96.1±1.0</td><td>95.3±0.9</td><td>81.9±1.0</td><td>30.4±0.1</td></tr><tr><td>kNN-GCN</td><td>93.5±0.7</td><td>95.3±0.4</td><td>95.4±0.4</td><td>46.3±0.3</td></tr><tr><td>LDS</td><td>97.3 ±0.4†</td><td>94.4 ± 1.9†</td><td>92.5±0.7†</td><td>46.4 ± 1.6†</td></tr><tr><td>IDGL</td><td>97.0±0.7</td><td>94.2 ±2.3</td><td>92.5 ±1.3</td><td>48.5±0.6</td></tr><tr><td>SLAPS (FP)</td><td>96.6±0.4</td><td>94.6±0.3</td><td>94.4 ± 0.7</td><td>44.4±0.8</td></tr><tr><td>SLAPS (MLP)</td><td>96.3 ±1.0</td><td>96.0±0.8</td><td>92.5±0.7</td><td>50.4±0.7</td></tr><tr><td>SLAPS (MLP-D)</td><td>96.5±0.8</td><td>96.6±0.2</td><td>94.2 ± 0.1</td><td>49.8±0.9</td></tr></table>",
+        "bbox": [
+            281,
+            130,
+            717,
+            218
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In addition to the aforementioned baselines, we also experimented with GCN, GAT, and Transformer (encoder only) architectures applied on fully connected graphs. GCN always learned to predict the majority class. This is because after one fully connected GCN layer, all nodes will have the same embedding and become indistinguishable. GAT also showed similar behavior. We believe this is because the attention weights are (almost) random at the beginning (due to random initialization of the model parameters) resulting in nodes becoming indistinguishable and GAT cannot escape from that state. The skip connections of Transformer helped avoid the problem observed for GCN and GAT and we were able to achieve better results $( \\sim 4 0 \\%$ accuracy on Cora). However, we observed severe overfitting, even with small models and with high dropout probabilities. ",
+        "bbox": [
+            173,
+            253,
+            825,
+            380
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SLAPS consistently outperforms the baselines in some cases by large margins. Among the generators, the winner is dataset-dependent with MLP-D mostly outperforming MLP on datasets with many features and MLP outperforming on datasets with small numbers of features. Using the software that was publicly released by the authors, the baselines that learn a graph structure fail on ogbn-arxiv; our implementation, on the other hand, scales to such large graphs3. Adding self-training helps further improve the results of SLAPS. Adding AdaEdge, however, does not seem effective, probably because the graph structure learned by SLAPS already exhibits a high degree of homophily (see Section 5.4). ",
+        "bbox": [
+            174,
+            386,
+            825,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 2, we only compared SLAPS with the best performing baselines from Table 1 (kNN-GCN, LDS and IDGL). We also included an MLP baseline for comparison. On three out of four datasets, SLAPS outperforms the LDS and IDGL baselines. For the Digits dataset, interestingly kNN-GCN outperforms the learning-based models. This could be because the initial kNN structure for this dataset is already a good structure. Among the datasets on which we can train SLAPS with the FP generator, 20news has the largest number of nodes (9,607 nodes). On this dataset, we observed that an FP generator suffers from overfitting and produces weaker results compared to other generators due to its large number of parameters. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Jiang et al. [21] show that learning a latent graph structure of the input examples can help with ",
+        "bbox": [
+            174,
+            606,
+            821,
+            621
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "semi-supervised image classification. In particular, they create three versions of the MNIST dataset each consisting of a randomly selected subset with 10,000 examples in total. The first version contains 1000 labels for training, the second contains 2000, and the third version contains 3000 labels for training. All three variants use an extra 1000 labels for validation. The other examples are used as test examples. Here, we conduct an experiment to measure the performance of SLAPS on these variants of the MNIST dataset. We compare against GLCN [21] as well as the baselines in the GLCN paper including manifold regularization [3], label propagation, ",
+        "bbox": [
+            174,
+            607,
+            465,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3243666c275530ef181fe09cf47b12e99e1607439021d0de042fa88d7e45de1.jpg",
+        "table_caption": [
+            "Table 3: Results on the MNIST dataset. Bold values indicate best mean performances. Underlined values indicate second best mean performance. All the results for baseline have been taken from [20]. "
+        ],
+        "table_footnote": [
+            "deep walk [37], graph convolutional networks (GCN), and graph attention networks (GAT). "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>MNIST1000</td><td>MNIST2000</td><td>MNIST3000</td></tr><tr><td>ManiReg LP DeepWalk</td><td>92.74± 0.3 79.28 ±0.9 94.55 ± 0.3</td><td>93.96±0.2 81.91±0.8 95.04± 0.3</td><td>94.62±0.2 83.45 ± 0.5 95.34± 0.3</td></tr><tr><td>GCN GAT</td><td>90.59 ± 0.3 92.11 ±0.4 94.28 ± 0.3</td><td>90.91± 0.2 92.64 ± 0.3 95.09 ± 0.2</td><td>91.01 ± 0.2 92.81 ± 0.3 95.46 ±0.2</td></tr><tr><td>GLCN SLAPS</td><td colspan=\"3\">94.66± 0.2 95.35 ± 0.1 95.54± 0.0</td></tr></table>",
+        "bbox": [
+            477,
+            699,
+            821,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results are reported in Table 3. From the results, it can be viewed that SLAPS outperforms GLCN and all the other baselines on the 3 variants. Compared to GLCN, on the three variants SLAPS reduces the error by $7 \\% , 5 \\%$ , and $2 \\%$ respectively, showing that SLAPS can be more effective when the labeled set is small and providing more empirical evidence for Theorem 1. ",
+        "bbox": [
+            176,
+            847,
+            828,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 The effectiveness of self-supervision ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            138,
+            460,
+            152
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learning a structure only using self-supervision: To provide more insight into the value provided by the self-supervision task and the generalizability of the adjacency learned through this task, we conduct experiments with a variant of SLAPS named $S L A P S _ { 2 s }$ that is trained in two stages. We first train the GNNDAE model by minimizing $\\mathcal { L } _ { D A E }$ described in in Equation 1. Recall that $\\mathcal { L } _ { D A E }$ depends on the parameters $\\pmb { \\theta } _ { \\mathsf { G } }$ of the generator and the parameters $\\theta _ { \\mathsf { G N N } _ { \\mathsf { D A E } } }$ of the denoising autoencoder. After every $t$ epochs of training, we fix the adjacency matrix, train a classifier with the fixed adjacency matrix, and measure classification accuracy on the validation set. We select the epoch that produces the adjacency providing the best validation accuracy for the classifier. Note that in $S L A P S _ { 2 s }$ , the adjacency matrix only receives gradients from the self-supervised task in Equation 1. ",
+        "bbox": [
+            174,
+            165,
+            583,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/7670a30bced9784814f16fbf60c6d6838f058afc569fd867c36471666b0e8906.jpg",
+        "image_caption": [
+            "Figure 3: SLAPS vs $\\mathrm { S L A P S } _ { 2 s }$ on Cora with different generators. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            601,
+            186,
+            816,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows the performance of SLAPS and $\\mathrm { S L A P S } _ { 2 s }$ on Cora and compares them with kNNGCN. Although $\\mathrm { S L A P S } _ { 2 s }$ does not use the node labels in learning an adjacency matrix, it outperforms kNN-GCN $8 . 4 \\%$ improvement when using an FP generator). With an FP generator, $\\mathrm { S L A P S } _ { 2 s }$ even achieves competitive performance with SLAPS; this is mainly because FP does not leverage the supervision provided by $\\mathsf { G C N } _ { \\mathsf { C } }$ toward learning generalizable patterns that can be used for nodes other than those in the training set. These results corroborate the effectiveness of the self-supervision task for learning an adjacency matrix. Besides, the results show that learning the adjacency using both self-supervision and the task-specific node labels results in higher predictive accuracy. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The value of λ: Figure 4 shows the performance of SLAPS4 on Cora and Citeseer with different values of $\\lambda$ . When $\\lambda = 0$ , corresponding to removing self-supervision, the model performance is somewhat poor. As soon as $\\lambda$ becomes positive, both models see a large boost in performance showing that self-supervision is crucial to the high performance of SLAPS. Increasing $\\lambda$ further provides larger boosts until it becomes so large that the self-supervision loss dominates the classification loss and the performance deteriorates. Note that with $\\lambda = 0$ , SLAPS with the MLP generator becomes a variant of the model proposed in [8], but with a different similarity function. ",
+        "bbox": [
+            174,
+            496,
+            583,
+            648
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Is self-supervision actually solving the supervision starvation problem? In Fig 4, we showed that self-supervision is key to the high performance of SLAPS. Here, we examine if this is because self-supervision indeed addresses the supervision starvation problem. For this purpose, we compare SLAPS with and without self-supervision on two groups of test nodes on Cora: 1) those that are not connected to any labeled nodes after training, and 2) those that are connected to at least one labeled node after training. The nodes in group one have a high chance of having starved edges. We observed that adding self-supervision provides $3 8 . 0 \\%$ improvement for the first group and only $8 . 9 \\%$ improvement for the latter. Since self-supervision mainly helps with nodes in group 1, this provides evidence that self-supervision is an effective solution to the supervision starvation problem. ",
+        "bbox": [
+            174,
+            655,
+            581,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/76589f76b89b7d9ccc11cbd765d95616b6c2fdd9b504c901c1bee98e69c2471f.jpg",
+        "image_caption": [
+            "Figure 4: The performance of SLAPS with MLP graph generator as a function of $\\lambda$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            517,
+            813,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            724,
+            825,
+            806
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The effect of the training set size: According to Theorem 1, a smaller $q$ (corresponding to the training set size) results in more starved edges in each epoch. To explore the effect of self-supervision as a function of $q$ , we compared SLAPS with and without supervision on Cora and Citeseer while reducing the number of labeled nodes per class from 20 to 5. We used the FP generator for this experiment. With 5 labeled nodes per class, adding self-supervision provides $\\bar { 1 6 . 7 \\% }$ and $2 2 . 0 \\%$ improvements on Cora and Citeseer respectively, which is substantially higher than the corresponding numbers when using 20 labeled nodes per class $( 1 0 . 0 \\%$ and $7 . 0 \\%$ respectively). This provides empirical evidence for Theorem 1. Note that the results on Cora390 and Citeseer 370 datasets provide evidence that the self-supervised task is effective even when the label rate is high. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 Experiments with noisy graphs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            166,
+            428,
+            181
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The performance of GNNs highly depends on the quality of the input graph structure and deteriorates when the graph structure is noisy [see 61, 9, 11]. Here, we verify whether selfsupervision is also helpful when a noisy structure is provided as input. Toward this goal, we experiment with Cora and Citeseer and provide noisy versions of the input graph as input. The provided noisy graph structure is used only for initialization; it is then further optimized by SLAPS. We perturb the graph structure by replacing $\\rho$ percent of the edges in the original structure (selected uniformly at random) with random edges. Figure 5 shows the performance of SLAPS with and without self-supervision $\\lambda = 0$ corresponds to no supervision). We also report the results of vanilla GCN on these perturbed graphs for comparison. It can be viewed that self-supervision consistently provides a boost in performance especially for higher values of $\\rho$ . ",
+        "bbox": [
+            174,
+            194,
+            583,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/12cd5ec3eb9b5b405fa85b3dcbc13f5535f44a5bebd8117b328c83e5eece1c58.jpg",
+        "image_caption": [
+            "Figure 5: Performance comparison when noisy graphs are provided as input ( $\\dot { \\rho }$ indicates the percentage of perturbations). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            217,
+            815,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.4 Analyses of the learned adjacency ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            434,
+            446,
+            449
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Noisy graphs: Following the experiment in Section 5.3, we compared the learned and original structures by measuring the number of random edges added during perturbation but removed by the model and the number of edges removed during the perturbation but recovered by the model. For Cora, SLAPS removed $7 6 . 2 \\%$ and $7 0 . 4 \\%$ of the noisy edges and recovered $5 8 . 3 \\%$ and $4 4 . 5 \\%$ of the removed edges for $\\rho \\ = \\ 2 5 \\%$ and $\\rho ~ = ~ 5 0 \\%$ respectively while SLAPS with $\\lambda = 0$ only removed $6 2 . 8 \\%$ and $5 4 . 9 \\%$ of the noisy edges and recovered $5 1 . 4 \\%$ and $3 5 . 8 \\%$ of the removed edges. This provides evidence on self-supervision being helpful for structure learning. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            530,
+            581,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Homophily: As explained earlier, a properly learned graph for semi-supervised classification with GNNs exhibits high homophily. To verify the quality of the learned adjacency with respect to homophily, for every pair of nodes in the test set, we compute the odds of the two nodes sharing the same label as a function of the normalized weight of the edge connecting them. Figure 6 represents the odds for different weight intervals (recall that $\\pmb { A }$ is row and column normalized). For both Cora and Citeseer, nodes’ connected with higher edge weights are more likely to share the same label compared to nodes with lower or zero edge weights. Specifically, when $A _ { i j } \\geq 0 . 1$ , $v _ { i }$ and $v _ { j }$ are almost 2.5 and 2.0 times more likely to share the same label on Cora and Citeseer respectively. ",
+        "bbox": [
+            174,
+            592,
+            581,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c6aa91f4d2a3918f530836850f5cdd2922db35c519b77c6725af6460fa24e6b.jpg",
+        "image_caption": [
+            "Figure 6: The odds of two nodes in the test set sharing the same label as a function of the edge weights learned by SLAPS. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            601,
+            551,
+            813,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            299,
+            811
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We proposed SLAPS: a model for learning the parameters of a graph neural network and a graph structure of the nodes connectivities simultaneously from data. We identified a supervision starvation problem that emerges for graph structure learning, especially when training data is scarce. We proposed a solution to the supervision starvation problem by supplementing the training objective with a well-motivated self-supervised task. We showed the effectiveness of our model through a comprehensive set of experiments and analyses. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Funding Transparency Statement ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            486,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was fully funded by Borealis AI. ",
+        "bbox": [
+            176,
+            121,
+            457,
+            135
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Réka Albert and Albert-László Barabási. Statistical mechanics of complex networks. Reviews of modern physics, 74(1):47, 2002.   \n[2] Albert-László Barabási and Réka Albert. Emergence of scaling in random networks. science, 286(5439):509–512, 1999.   \n[3] Mikhail Belkin, Partha Niyogi, and Vikas Sindhwani. Manifold regularization: A geometric framework for learning from labeled and unlabeled examples. JMLRR, 7(Nov):2399–2434, 2006.   \n[4] Ines Chami, Sami Abu-El-Haija, Bryan Perozzi, Christopher Ré, and Kevin Murphy. Machine learning on graphs: A model and comprehensive taxonomy. arXiv preprint arXiv:2005.03675, 2020.   \n[5] Deli Chen, Yankai Lin, Wei Li, Peng Li, Jie Zhou, and Xu Sun. Measuring and relieving the over-smoothing problem for graph neural networks from the topological view. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 3438–3445, 2020.   \n[6] Yu Chen, Lingfei Wu, and Mohammed J. Zaki. Deep iterative and adaptive learning for graph neural networks. In Neural Information Processing Systems (NeurIPS), 2020.   \n[7] Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   \n[8] Luca Cosmo, Anees Kazi, Seyed-Ahmad Ahmadi, Nassir Navab, and Michael Bronstein. Latent patient network learning for automatic diagnosis. arXiv preprint arXiv:2003.13620, 2020.   \n[9] Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. arXiv preprint arXiv:1806.02371, 2018.   \n[10] Paul Erdos and Alfred Rényi. On random graphs. ˝ Publicationes Mathematicae Debrecen, 6: 290–297, 1959.   \n[11] James Fox and Sivasankaran Rajamanickam. How robust are graph neural networks to structural noise? arXiv preprint arXiv:1912.10206, 2019.   \n[12] Luca Franceschi, Mathias Niepert, Massimiliano Pontil, and Xiao He. Learning discrete structures for graph neural networks. In ICML, 2019.   \n[13] Victor Garcia and Joan Bruna. Few-shot learning with graph neural networks. arXiv preprint arXiv:1711.04043, 2017.   \n[14] Spyros Gidaris and Nikos Komodakis. Generating classification weights with gnn denoising autoencoders for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 21–30, 2019.   \n[15] Jonathan Halcrow, Alexandru Mosoi, Sam Ruth, and Bryan Perozzi. Grale: Designing networks for graph learning. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2523–2532, 2020.   \n[16] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   \n[17] Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. In ICLR, 2020.   \n[18] Ziniu Hu, Yuxiao Dong, Kuansan Wang, Kai-Wei Chang, and Yizhou Sun. Gpt-gnn: Generative pre-training of graph neural networks. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1857–1867, 2020.   \n[19] Soobeom Jang, Seong-Eun Moon, and Jong-Seok Lee. Brain signal classification via learning connectivity structure. arXiv preprint arXiv:1905.11678, 2019.   \n[20] Bo Jiang, Ziyan Zhang, Doudou Lin, Jin Tang, and Bin Luo. Semi-supervised learning with graph learning-convolutional networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11313–11320, 2019.   \n[21] Bo Jiang, Ziyan Zhang, Doudou Lin, Jin Tang, and Bin Luo. Semi-supervised learning with graph learning-convolutional networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11313–11320, 2019.   \n[22] Wei Jin, Tyler Derr, Haochen Liu, Yiqi Wang, Suhang Wang, Zitao Liu, and Jiliang Tang. Self-supervised learning on graphs: Deep insights and new direction. arXiv preprint arXiv:2006.10141, 2020.   \n[23] Wei Jin, Yao Ma, Xiaorui Liu, Xianfeng Tang, Suhang Wang, and Jiliang Tang. Graph structure learning for robust graph neural networks. arXiv preprint arXiv:2005.10203, 2020.   \n[24] Daniel D Johnson, Hugo Larochelle, and Daniel Tarlow. Learning graph structure with a finite-state automaton layer. arXiv preprint arXiv:2007.04929, 2020.   \n[25] Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart. Representation learning for dynamic graphs: A survey. JMLR, 2020.   \n[26] Anees Kazi, Luca Cosmo, Nassir Navab, and Michael Bronstein. Differentiable graph module (dgm) for graph convolutional networks. arXiv preprint arXiv:2002.04999, 2020.   \n[27] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.   \n[28] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, 2, 2010.   \n[29] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In AAAI, 2018.   \n[30] Ruoyu Li, Sheng Wang, Feiyun Zhu, and Junzhou Huang. Adaptive graph convolutional neural networks. arXiv preprint arXiv:1801.03226, 2018.   \n[31] Renjie Liao, Yujia Li, Yang Song, Shenlong Wang, Charlie Nash, William L Hamilton, David Duvenaud, Raquel Urtasun, and Richard S Zemel. Efficient graph generation with graph recurrent attention networks. arXiv preprint arXiv:1910.00760, 2019.   \n[32] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. In NeurIPS, pages 13556–13566, 2019.   \n[33] Wei Liu, Junfeng He, and Shih-Fu Chang. Large graph construction for scalable semi-supervised learning. In ICML, 2010.   \n[34] Vinod Nair and Geoffrey E Hinton. Rectified linear units improve restricted boltzmann machines. In Icml, 2010.   \n[35] Kenta Oono and Taiji Suzuki. Graph neural networks exponentially lose expressive power for node classification. In ICLR, 2020.   \n[36] 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. JMLR, 12:2825–2830, 2011.   \n[37] 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[38] Shah Rukh Qasim, Jan Kieseler, Yutaro Iiyama, and Maurizio Pierini. Learning representations of irregular particle-detector geometry with distance-weighted graph networks. The European Physical Journal C, 79(7):1–11, 2019.   \n[39] Sam T Roweis and Lawrence K Saul. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500):2323–2326, 2000.   \n[40] Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.   \n[41] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   \n[42] Otilia Stretcu, Krishnamurthy Viswanathan, Dana Movshovitz-Attias, Emmanouil Platanios, Sujith Ravi, and Andrew Tomkins. Graph agreement models for semi-supervised learning. In NeurIPS, pages 8713–8723, 2019.   \n[43] Mohammed Suhail and Leonid Sigal. Mixture-kernel graph attention network for situation recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 10363–10372, 2019.   \n[44] Joshua B Tenenbaum, Vin De Silva, and John C Langford. A global geometric framework for nonlinear dimensionality reduction. science, 290(5500):2319–2323, 2000.   \n[45] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. In ICLR, 2018.   \n[46] Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In ICML, pages 1096–1103, 2008.   \n[47] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog), 38(5):1–12, 2019.   \n[48] Xuan Wu, Lingxiao Zhao, and Leman Akoglu. A quest for structure: Jointly learning the graph structure and semi-supervised classification. In CIKM, pages 87–96, 2018.   \n[49] Liang Yang, Zesheng Kang, Xiaochun Cao, Di Jin, Bo Yang, and Yuanfang Guo. Topology optimization based graph convolutional network. In IJCAI, pages 4054–4061, 2019.   \n[50] Jiaxuan You, Rex Ying, Xiang Ren, William L Hamilton, and Jure Leskovec. Graphrnn: Generating realistic graphs with deep auto-regressive models. arXiv preprint arXiv:1802.08773, 2018.   \n[51] Yuning You, Tianlong Chen, Zhangyang Wang, and Yang Shen. When does self-supervision help graph convolutional networks? arXiv preprint arXiv:2006.09136, 2020.   \n[52] Donghan Yu, Ruohong Zhang, Zhengbao Jiang, Yuexin Wu, and Yiming Yang. Graph-revised convolutional network. In ECML PKDD, 2020.   \n[53] Jiani Zhang, Xingjian Shi, Junyuan Xie, Hao Ma, Irwin King, and Dit-Yan Yeung. Gaan: Gated attention networks for learning on large and spatiotemporal graphs. arXiv preprint arXiv:1803.07294, 2018.   \n[54] Jiawei Zhang, Haopeng Zhang, Congying Xia, and Li Sun. Graph-bert: Only attention is needed for learning graph representations. arXiv preprint arXiv:2001.05140, 2020.   \n[55] Tong Zhao, Yozen Liu, Leonardo Neves, Oliver Woodford, Meng Jiang, and Neil Shah. Data augmentation for graph neural networks. arXiv preprint arXiv:2006.06830, 2020.   \n[56] Hao Zhu, Yankai Lin, Zhiyuan Liu, Jie Fu, Tat-seng Chua, and Maosong Sun. Graph neural networks with generated parameters for relation extraction. arXiv preprint arXiv:1902.00756, 2019.   \n[57] Jiong Zhu, Yujun Yan, Lingxiao Zhao, Mark Heimann, Leman Akoglu, and Danai Koutra. Beyond homophily in graph neural networks: Current limitations and effective designs. Advances in Neural Information Processing Systems, 33, 2020.   \n[58] Qikui Zhu, Bo Du, and Pingkun Yan. Self-supervised training of graph convolutional networks. arXiv preprint arXiv:2006.02380, 2020.   \n[59] Xiaojin Zhu and Zoubin Ghahramani. Learning from labeled and unlabeled data with label propagation. 2002.   \n[60] Yanqiao Zhu, Weizhi Xu, Jinghao Zhang, Qiang Liu, Shu Wu, and Liang Wang. Deep graph structure learning for robust representations: A survey. arXiv preprint arXiv:2103.03036, 2021.   \n[61] Daniel Zügner, Amir Akbarnejad, and Stephan Günnemann. Adversarial attacks on neural networks for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 2847–2856, 2018. ",
+        "bbox": [
+            174,
+            148,
+            826,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            65,
+            828,
+            919
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            88,
+            828,
+            353
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            380,
+            254,
+            396
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            407,
+            339,
+            421
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See supplementary material (the Limitations Section).   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            426,
+            825,
+            532
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            536,
+            493,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] The full set of assumptions are given in Theorem 1.   \n(b) Did you include complete proofs of all theoretical results? [Yes] The proof is in the supplementary material. ",
+        "bbox": [
+            238,
+            555,
+            825,
+            614
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            619,
+            393,
+            633
+        ],
+        "page_idx": 13
+    },
+    {
+        "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)? [No] Due to copyright issues, we are not able to share an anonymous version of our code. However, the code will be publicly released upon the acceptance of the paper.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See the dataset paragraph in Section 5 and the dataset statistics table and best hyperparameters table 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 each experiment 10 times and report the mean and standard deviation.   \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 Implementation Details in the supplementary material. ",
+        "bbox": [
+            238,
+            638,
+            825,
+            825
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            832,
+            825,
+            845
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] (b) Did you mention the license of the assets? [No] The source websites specify the licenses. (c) Did you include any new assets either in the supplemental material or as a URL? [No] ",
+        "bbox": [
+            238,
+            849,
+            823,
+            912
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            92,
+            825,
+            150
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            154,
+            707,
+            169
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            172,
+            825,
+            262
+        ],
+        "page_idx": 14
+    }
+]

parse/train/OMNB1G5xzd4/OMNB1G5xzd4.md

@@ -0,0 +1,398 @@
+# MODEL-BASED OFFLINE PLANNING
+
+Arthur Argenson aarg@google.com Google Research
+
+Gabriel Dulac-Arnold dulacarnold@google.com Google Research
+
+# ABSTRACT
+
+Offline learning is a key part of making reinforcement learning (RL) useable in real systems. Offline RL looks at scenarios where there is data from a system’s operation, but no direct access to the system when learning a policy. Recent work on training RL policies from offline data has shown results both with model-free policies learned directly from the data, or with planning on top of learnt models of the data. Model-free policies tend to be more performant, but are more opaque, harder to command externally, and less easy to integrate into larger systems. We propose an offline learner that generates a model that can be used to control the system directly through planning. This allows us to have easily controllable policies directly from data, without ever interacting with the system. We show the performance of our algorithm, Model-Based Offline Planning (MBOP) on a series of robotics-inspired tasks, and demonstrate its ability to leverage planning to respect environmental constraints. We are able to find near-optimal polices for certain simulated systems from as little as 50 seconds of real-time system interaction, and create zero-shot goal-conditioned policies on a series of environments.
+
+# 1 INTRODUCTION
+
+Learnt policies for robotic and industrial systems have the potential to both increase existing systems’ efficiency $\&$ robustness, as well as open possibilities for systems previously considered too complex to control. Learnt policies also afford the possibility for non-experts to program controllers for systems that would currently require weeks of specialized work. Currently, however, most approaches for learning controllers require significant interactive time with a system to be able to converge to a performant policy. This is often either undesirable or impossible due to operating cost, safety issues, or system availability. Fortunately, many systems are designed to log sufficient data about their state and control choices to create a dataset of operator commands and resulting system states. In these cases, controllers could be learned offline, using algorithms that produce a good controller using only these logs, without ever interacting with the system. In this paper we propose such an algorithm, which we call Model-Based Offline Planning (MBOP), which is able to learn policies directly from logs of a semi-performant controller without interacting with the corresponding environment. It is able to leverage these logs to generate a more performant policy than the one used to generate the logs, which can subsequently be goal-conditioned or constrained dynamically during system operation.
+
+Learning from logs of a system is often called ‘Offline Reinforcement Learning’ (Wu et al., 2019; Peng et al., 2019; Fujimoto et al., 2019; Wang et al., 2020) and both model-free (Wu et al., 2019; Wang et al., 2020; Fujimoto et al., 2019; Peng et al., 2019) and model-based (Yu et al., 2020; Kidambi et al., 2020) approaches have been proposed to learn policies in this setting. Current modelbased approaches, MOPO (Yu et al., 2020) and MoREL (Kidambi et al., 2020), learn a model to train a model-free policy in a Dyna-like (Sutton & Barto, 2018) manner. Our proposed approach, MBOP, is a model-based approach that leverages Model-Predictive Control (MPC) (Rault et al., 1978) and extends the MPPI (Williams et al., 2017b) trajectory optimizer to provide a goal or reward-conditioned policy using real-time planning. It combines three main elements: a learnt world model, a learnt behavior-cloning policy, and a learnt fixed-horizon value-function.
+
+MBOP’s key advantages are its data-efficiency and adaptability. MBOP is able to learn policies that perform better than the demonstration data from as little as 100 seconds of simulated system time (equivalent to 5000 steps). A single trained MBOP policy can be conditioned with a reward function, a goal state, as well as state-based constraints, all of which can be non-stationary, allowing for easy control by a human operator or a hierarchical system. Given these two key advantages, we believe it to be a good candidate for real-world use in control systems with offline data.
+
+We contextualize MBOP relative to existing work in Section 2, and describe MBOP in Section 3. In Section 4.2, we demonstrate MBOP’s performance on standard benchmark performance tasks for offline RL, and in Section 4.3 we demonstrate MBOP’s performance in zero-shot adaptation to varying task goals and constraints. In Section 4.4 we perform an ablation analysis and consider combined contributions of MBOP’s various elements.
+
+# 2 RELATED WORKS
+
+Model-Based approaches with neural networks have shown promising results in recent years. Guided Policy Search (Levine & Koltun, 2013) leverages differential dynamic programming as a trajectory optimizer on locally linear models, and caches the resulting piece-wise policy in a neural network. Williams et al. (2017b) show that a simple model-based controller can quickly learn to drive a vehicle on a dirt track, the BADGR robot (Kahn et al., 2020) also uses Model-Predictive Path Integral (MPPI) (Williams et al., 2017a) with a learned model to learn to navigate to novel locations, Yang et al. (2020) show good results learning legged locomotion policies using MPC with learned models, and (Ebert et al., 2018) demonstrate flexible robot arm controllers leveraging learned models with image-based goals. Silver et al. (2016) have shown the power of additional explicit planning in various board games including Go. More recently planning-based algorithms such as PlaNet (Hafner et al., 2019b) have shown strong results in pixel-based continuous control tasks by leveraging latent variational RNNs. Simpler approaches such as PDDM (Nagabandi et al., 2020) or PETS (Chua et al., 2018) have shown good results using full state information both in simulation and on real robots. MBOP is strongly influenced by PDDM (Nagabandi et al., 2020) (itself an extension on PETS (Chua et al., 2018)), in particular with the use of ensembles and how they are leveraged during planning. PDDM was not designed for offline use, and MBOP adds a value function composition as well as a policy prior during planning to increase data efficiency and strengthen the set of priors for offline learning. It leverages the same trajectory re-weighting approach used in PDDM and takes advantage of its beta-mixture of the $T$ trajectory buffer.
+
+Both MoREL (Kidambi et al., 2020) and MOPO (Yu et al., 2020) leverage model-based approaches for offline learning. This is similar to approaches used in MBPO (Janner et al., 2019) and DREAMER (Hafner et al., 2019a), both of which leverage a learnt model to learn a model-free controller. MoREL and MOPO, however, due to their offline nature, train their model-free learner by using a surrogate MDP which penalizes for underlying model uncertainty. They do not use the models for direct planning on the problem, thus making the final policy task-specific. MOPO demonstrate the ability of their algorithm to alter the reward function and re-train a new policy according to this reward, but cannot leverage the final policy to dynamically adapt to an arbitrary goal or constrained objective. Matsushima et al. (2020) use a model-based policy for deployment efficient RL. Their use case is a mix between offline and online RL, where they consider that there is a limited number of deployments. They share a similarity in the sense that they also use a behaviorcloning policy $\pi _ { \beta }$ to guide trajectories in a learned ensemble model, but perform policy improvement steps on a parametrized policy initialized from $\pi _ { \beta }$ using a behavior-regularized objective function. Similarly to MoREL and MOPO their approach learns a parameterized policy for acting in the real system.
+
+The use of a value function to extend the planning horizon of a planning-based policy has been previously proposed by Lowrey et al. (2018) with the POLO algorithm. POLO uses a ground-truth model (e.g. physics simulator) with MPPI/MPC for trajectory optimization. POLO additionally learns an approximate value-function through interaction with the environment which is then appended to optimized trajectories to improve return estimation. Aside from the fact that MBOP uses an entirely approximate & learned model, it uses a similar idea but with a fixed-horizon value function to avoid bootstrapping, and separate heads of the ensemble during trajectory optimization. BC-trained policies as sampling priors have been looked at by POPLIN (Wang & Ba, 2019). POPLIN does not use value bootstrapping, and re-samples an ensemble head at each timestep during rollouts, which likely provides less consistent variations in simulated plans. They show strong results relative to a series of model-based and model-free approaches, but do not manage to perform on the Gym Walker environment. Additionally, they are overall much less data efficient than MBOP and do not demonstrate performance in the offline setting.
+
+Task-time adaptation using model-based approaches has been considered previously in the modelbased literature. Lu et al. (2019) look at mixing model-free and model-based approaches using notions of uncertainty to allow for adaptive controllers for non-stationary problems. Rajeswaran et al. (2020) use a game-theoretic framework to describe two adaptive learners that are both more sample efficient than common MBRL algorithms, as well as being more robust to non-stationary goals and system dynamics. MBOP is able to perform zero-shot adaptation to non-stationary goals and constraints, but does not provide a mechanism for dealing with non-stationary dynamics. If brought into the on-line settings, approaches from these algorithms such as concentrating on recent data, could however be leveraged to allow for this.
+
+Previous approaches all look at various elements present in MBOP but none consider the full combination of a BC prior on the trajectory optimizer with a value-function initialization, especially in the case of full offline learning. Along with this high-level design, many implementation details such as consistent ensemble sampling during rollouts, or averaging returns over ensemble heads, appear to be important for a stable controller from our experience.
+
+# 3 MODEL-BASED OFFLINE PLANNING
+
+Our proposed algorithm, MBOP (Model-Based Offline Planning), is a model-based RL algorithm able to produce performant policies entirely from logs of a less-performant policy, without ever interacting with the actual environment. MBOP learns a world model and leverages a particle-based trajectory optimizer and model-predictive control (MPC) to produce a control action conditioned on the current state. It can be seen as an extension of PDDM (Nagabandi et al., 2020), with a behaviorcloned policy used as a prior on action sampling, and a fixed-horizon value function used to extend the planning horizon.
+
+In this following sections, we introduce the Markov Decision Process (MDP) formalism, briefly explain planning-based approaches, discuss offline learning, and then introduce the elements of MBOP before describing the algorithm in full.
+
+# 3.1 MARKOV DECISION PROCESS
+
+Let us model our tasks as a Markov Decision Process (MDP), which can be defined as a tuple $( S , \mathcal { A } , p , r , \gamma )$ , where an agent is in a state $s _ { t } ~ \in ~ S$ and takes an action $a _ { t } ~ \in ~ { \cal A }$ at timestep $t$ . When in state $s _ { t }$ and taking an action $a _ { t }$ , an agent will arrive in a new state $s _ { t + 1 }$ with probability $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ , and receive a reward $r ( s _ { t } , a _ { t } , s _ { t + 1 } )$ . The cumulative reward over a full episode is called the return $R$ and can be truncated to a specific horizon as $R _ { H }$ . Generally reinforcement learning and control aim to provide an optimal policy function $\pi ^ { s } : { \mathcal { S } }  A $ which will provide an action $a _ { t }$ in state $s _ { t }$ which will lead to the highest long-term return: $\pi ^ { * } ( s _ { t } ) =$ arg $\begin{array} { r l } { \operatorname* { i m a x } _ { a \in \mathcal { A } } \sum _ { t = 1 } ^ { \infty } \gamma ^ { t } r \big ( s _ { t } , \pi ^ { * } ( s _ { t } ) \big ) } & { { } } \end{array}$ , where $\gamma$ is a time-wise discounting factor that we fix to $\gamma = 1$ , and therefore only consider finite-horizon returns.
+
+# 3.2 PLANNING WITH LEARNED MODELS
+
+A large body of the contemporary work with MDPs involves Reinforcement Learning (RL) Sutton & Barto (2018) with model-free policies Mnih et al. (2015); Lillicrap et al. (2015); Schulman et al. (2017); Abdolmaleki et al. (2018). These approaches learn some form of policy network which provides its approximation of the best action $a _ { t }$ for a given state $s _ { t }$ often as a single forward-pass of the network. MBOP and other model-based approaches Deisenroth & Rasmussen (2011); Chua et al. (2018); Williams et al. (2017b); Hafner et al. (2019b); Lowrey et al. (2018); Nagabandi et al. (2020) are very different. They learn an approximate model of their environment and then use a planning algorithm to find a high-return trajectory through this model, which is then applied to the environment 1. This is interesting because the final policy can be more easily adapted to new tasks, be made to respect constraints, or offer some level of explainability. When bringing learned controllers to industrial systems, many of these aspects are highly desireable, even to the expense of raw performance.
+
+# 3.3 OFFLINE LEARNING
+
+Most previous work in both reinforcement learning and planning with learned models has assumed repeated interactions with the target environment. This assumption allows the system to gather increased data along trajectories that are more likely, and more importantly to provides counterfactuals, able to contradict prediction errors in the learned policy, which is fundamental to policy improvement. In the case of offline learning, we consider that the environment is not available during the learning phase, but rather that we are given a dataset $\mathcal { D }$ of interactions with the environment, representing a series of timestep tuples $\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \right)$ . The goal is to provide a performant policy $\pi$ given this particular dataset $\mathcal { D }$ . Existing RL algorithms do not easily port over to the offline learning setup, for a varied set of reasons well-covered in Levine et al. (2020). In our work, we use the real environment to benchmark the performance of the produced policy. It is important to point out that oftentimes there is nevertheless a need to evaluate the performance of a given policy $\pi$ without providing access to the final system, which is the concern of Off Policy Evaluation (OPE) Precup (2000); Nachum et al. (2019) and Offline Hyperparameter Selection(OHS) Paine et al. (2020) which are outside the scope of our contribution.
+
+# 3.4 LEARNING DYNAMICS, ACTION PRIORS, AND VALUES
+
+MBOP uses three parameterized function approximators for its planning algorithm. These are:
+
+1. $f _ { m } : \mathcal { S } \times \mathcal { A } \to \mathcal { S } \times \mathbb { R }$ , a single-timestep model of environment dynamics such that $\left( { \hat { r } } _ { t } , { \hat { s } } _ { t + 1 } \right) \ = \ f _ { m } ( s _ { t } , a _ { t } )$ . This is the model used by the planning algorithm to roll out potential action trajectories. We will use $f _ { m } ( s _ { t } , a _ { t } ) _ { s }$ to denote the state prediction and $f _ { m } ( s _ { t } , a _ { t } ) _ { r }$ for the reward prediction. 2. $f _ { b } : S \times \mathcal { A }  \mathcal { A }$ , a behavior-cloned policy network which produces $a _ { t } = f _ { b } ( s _ { t } , a _ { t - 1 } )$ , and is used by the planning algorithm as a prior to guide trajectory sampling. 3. $f _ { R } : \mathcal { S } \times \mathcal { A }  \mathbb { R }$ is a truncated value function, which provides the expected return over a fixed horizon $R _ { H }$ of taking a specific action $a$ in a state $s$ , as $\hat { R } _ { H } = f _ { R } ( s _ { t } , a _ { t - 1 } )$ .
+
+Each one is a bootstrap ensemble (Lakshminarayanan et al., 2017) of $K$ feed-forward neural networks, thus $f _ { m }$ is composed of $f _ { m } ^ { i } \forall i \in [ 1 , K ]$ , where each $f _ { m } ^ { i }$ is trained with a different weight initialization but from the same dataset $\mathcal { D }$ . This approach has been shown to work well empirically to stabilize planning (Nagabandi et al., 2020; Chua et al., 2018). Each of the ensemble member networks is optimized to minimize the $L _ { 2 }$ loss on the predicted values in the dataset $\mathcal { D }$ in a standard supervised manner.
+
+# 3.5 MBOP-PO L I C Y
+
+MBOP uses Model-Predictive Control (Rault et al., 1978) to provide actions for each new state as $a _ { t } = \pi ( s _ { t } )$ . MPC works by running a fixed-horizon planning algorithm at every timestep, which returns a trajectory $T$ of length $H$ . MPC selects the first action from this trajectory and returns it as $a _ { t }$ . This fixed-horizon planning algorithm is effectively a black box to MPC, although in our case we have the MPC loop carry around a global trajectory buffer $T$ . A high-level view of the policy loop using MPC is provided in Algorithm 1.
+
+The MBOP-Policy loop is straightforward, and only needs to keep around $T$ at each timestep.   
+MPC is well-known to be a surprisingly simple yet effective method for planning-based control.   
+Finding a good trajectory is however more complicated, as we will see in the next section.
+
+# 3.6 MBOP-TR A J O P T
+
+MBOP-Trajopt extends ideas used by PDDM (Nagabandi et al., 2020) by adding a policy prior (provided by $f _ { b }$ ) and value prediction (provided by $f _ { R } { \mathrm { . } }$ ). The full algorithm is described in Algorithm
+
+# Algorithm 1 High-Level MBOP-Policy
+
+1: Let $\mathcal { D }$ be a dataset of $E$ episodes   
+2: Train $f _ { m }$ , $f _ { b } , f _ { R }$ on $\mathcal { D }$   
+3: Initialize planned trajectory: $T ^ { 0 } = [ 0 _ { 0 } , \cdots , 0 _ { H - 1 } ]$ .   
+4: for $t = 1 . . \infty$ do   
+5: Observe $s _ { t }$   
+6: T t = MBOP-Trajopt(T t−1, st, fm, fb, fr)   
+7: at = T t0   
+8: end for
+
+# Algorithm 2 MBOP-Trajopt
+
+1: procedure MBOP-TR A J O P $\mathrm { \Delta } _ { \mathrm { T } } ( s , T , f _ { m } , f _ { b } , f _ { R } , H , N , \sigma ^ { 2 } , \beta , \kappa )$   
+2: Set RN = \~0N . This holds our N trajectory returns.   
+3: Set AN,H = \~0N,H . This holds our N action trajectories of length $_ \mathrm { H }$ .   
+4:   
+5: for $n = 1 . . N$ do . Sample $N$ trajectories over horizon $H$ .   
+6: l = n mod K . Use consistent ensemble head throughout trajectory.   
+7: $s _ { 1 } = s$ , $a _ { 0 } = T _ { 0 }$ , $R = 0$   
+8: for t = 1..H do   
+9: $\begin{array} { r l } & { \quad \epsilon \sim \mathcal { N } ( 0 , \sigma ^ { 2 } ) } \\ & { \quad a _ { t } = f _ { b } ^ { l } \big ( s _ { t } , a _ { t - 1 } \big ) + \epsilon } \\ & { \quad \mathbf { A } _ { n , t } = \big ( 1 - \beta \big ) a _ { t } + \beta T _ { i = \operatorname* { m i n } ( t , H - 1 ) } } \\ & { \quad s _ { t + 1 } = f _ { m } ^ { l } \big ( s _ { t } , \mathbf { A } _ { n , t } \big ) _ { s } } \\ & { \quad R = R + \frac { 1 } { K } \sum _ { i = 1 } ^ { K } f _ { m } ^ { i } \big ( s _ { t } , \mathbf { A } _ { n , t } \big ) _ { r } } \end{array}$   
+10: . Sample current action using BC policy.   
+11: . Beta-mixture with previous trajectory $T$ .   
+12: . Sample next state from environment model.   
+13: . Take average reward over all ensemble members.   
+14: end for   
+15: Rn = R + 1K PKi=1 f iR(sH+1, An,H ) . Append predicted return and store.   
+16: 17: end for N T 0t P n= PNn=1 1 eκRn An,t+1 , eκRn ∀t ∈ [0, H − 1] . Generate return-weighted average trajectory.   
+18: return T 0
+
+2. In essence, MBOP-Trajopt is an iterative guided-shooting trajectory optimizer with refinement. MBOP-Trajopt rolls out $N$ trajectories of length $H$ using $f _ { m }$ as an environment model. As $f _ { m }$ is actually an ensemble with $K$ members, we denote the $l ^ { \mathrm { t h } }$ ensemble member as $f _ { m } ^ { l }$ . Line 6 of Alg. 2 allows the nth trajectory to always use the same lth ensemble member for both the BC policy and model steps. This use of consistent ensemble members for trajectory rollouts is inspired by PDDM. We point out that $f _ { m }$ models return both state transitions and reward, and so we denote the state component as $f _ { m } ( s _ { t } , a _ { t } ) _ { s }$ and the reward component as $f _ { m } ( s _ { t } , a _ { t } ) _ { r }$ .
+
+The policy prior $f _ { b } ^ { l }$ is used to sample an action which is then averaged with the corresponding action from the previous trajectory generated by MBOP-Trajopt. By maintaining $T$ from one MPC step to another we maintain a trajectory prior that allows us to amortize trajectory optimization over time. The $\beta$ parameter can be interpreted as a form of learning rate defining how quickly the current optimal trajectory should change with new rollout information (Wagener et al., 2019). We did not find any empirical advantage to the time-correlated noise in Nagabandi et al. (2020), instead opting for i.i.d. noise.
+
+As opposed to the BC policy and environment model, reward model is calculated using the average over all ensemble members to calculate the expected return $R _ { n }$ for trajectory $n$ . At the end of a trajectory, we append the predicted return for the final state and action by averaging over all members of $f _ { R }$ . The decision to take an average of returns vs using the ensemble heads was also inspired by the approach used in Nagabandi et al. (2020).
+
+Once we have a set of trajectories and their associated return, we generate an average action for timestep $t$ by re-weighting the actions of each trajectory according their exponentiated return, as in Nagabandi et al. (2020) and Williams et al. (2017b) (Alg 3, Line 17).
+
+![](images/c6ea42475869dea97c3c210dbafa0a46bbd24c399ae1ce8667438bd75a45a034.jpg)  
+Figure 1: Performance of MBOP on various RLU and D4RL datasets. For each of the above tasks we have sub-sampled subsets of the original dataset to obtain the desired number of data points. The subsets are the same throughout the paper. The box plots describe the first quartile of the dataset, with the whiskers extending out to the full distribution, with outliers plotted individually, using the standard Seaborn (more info here).
+
+Section 4 demonstrates how the combination of these elements makes our planning algorithm capable of generating improved trajectories over the behavior trajectories from $\mathcal { D }$ , especially in low-data regimes. In higher-data regimes, variants of MBOP without the BC prior can also be used for goal & constraint-based control. Further work will consider the addition of goal-conditioned $f _ { b }$ and $f _ { R }$ to allow for more data-efficient goal and constraint-based control.
+
+# 4 EXPERIMENTAL RESULTS
+
+We look at two operating scenarios to demonstrate MBOP performance and flexibility. First we consider the standard offline settings where the evaluation environment and task are identical to the behavior policy’s. We show that MBOP is able to perform well with very little data. We then look at MBOP’s ability to provide controllers that can naturally transfer to novel tasks with the same system dynamics. We use both goal-conditioned tasks (that ignore the original reward function) and constrained tasks (that require optimising for the original reward under some state constraint) to demonstrate the MBOP’s transfer abilities. Accompanying videos are available here: https: //youtu.be/nxGGHdZOFts.
+
+# 4.1 METHODOLOGY
+
+We use standard datasets from the RL Unplugged (RLU) (Gulcehre et al., 2020) and D4RL (Fu et al., 2020) papers. For both RLU and D4RL, policies are trained from offline datasets and then evaluated on the corresponding environment. For datasets with high variance in performance, we discard episodes that are below a certain threshold for the training of $f _ { b }$ and $f _ { R }$ . This is only done on the Quadruped and Walker tasks from RLU, and only provides a slight performance boost – performance on unfiltered data for these two tasks can be found in the Appendix’s 5.6. The unfiltered data is always used for training $f _ { s }$ . We perform a grid-search to find optimal parameters for each dataset, but for most tasks these parameters are mostly uniform. The full set of parameters for each experiment can be found in the Appendix Sec. 5.2. For experiments on RLU, we generated additional smaller datasets to increase the difficulty of the problem. On all plots we also report the performance of the behavior policy used to generate the data (directly from the episode returns in the datasets) and label it as the DATA policy. All non-standard datasets will be available publicly.
+
+Table 1: Results for MBOP on D4RL tasks compare to MOPO (Yu et al., 2020) and MBPO (Janner et al., 2019), with values taken from the MOPO paper (Yu et al., 2020). As in Fu et al. (2020), we normalize the scores according to a converged SAC policy, reported in their appendix. Scores are reported averaged over 5 random seeds, with 20 episode runs per seed. $\pm$ is one standard deviation and represents variance due to seed and episode. We have inserted our BC prior as the BC baseline, and have set performance to 0.0 when it is negative. We include the performance of behavior cloning (BC) from the batch data for comparison. We bold the highest mean.   
+
+<table><tr><td>Dataset type |</td><td>Environment</td><td>BC (Ours)</td><td>MBOP (Ours)</td><td>MOPO</td><td>MBPO</td></tr><tr><td rowspan="3">random random</td><td>halfcheetah</td><td>0.0±0.0</td><td>6.3 ± 4.0</td><td>31.9 ±2.8</td><td>30.7 ± 3.9</td></tr><tr><td>hopper</td><td>9.0±0.2</td><td>10.8 ± 0.3</td><td>13.3 ±1.6</td><td>4.5 ± 6.0</td></tr><tr><td>walker2d</td><td>0.1±0.0</td><td>8.1 ± 5.5</td><td>13.0 ± 2.6</td><td>8.6 ± 8.1</td></tr><tr><td rowspan="3">medium medium medium</td><td>halfcheetah</td><td>35.0 ± 2.5</td><td>44.6 ±0.8</td><td>40.2 ± 2.7</td><td>28.3± 22.7</td></tr><tr><td>hopper</td><td>48.1 ± 26.2</td><td>48.8 ± 26.8</td><td>26.5 ± 3.7</td><td>4.9 ± 3.3</td></tr><tr><td>walker2d</td><td>15.4 ± 24.7</td><td>41.0 ± 29.4</td><td>14.0 ± 10.1</td><td>12.7 ± 7.6</td></tr><tr><td rowspan="3">mixed mixed mixed</td><td>halfcheetah</td><td>0.0±0.0</td><td>42.3 ± 0.9</td><td>54.0 ± 2.6</td><td>47.3 ± 12.6</td></tr><tr><td>hopper</td><td>9.5 ± 6.9</td><td>12.4± 5.8</td><td>92.5 ± 6.3</td><td>49.8 ± 30.4</td></tr><tr><td>walker2d</td><td>11.5 ± 7.3</td><td>9.7 ± 5.3</td><td>42.7 ± 8.3</td><td>22.2 ± 12.7</td></tr><tr><td rowspan="3">med-expert med-expert med-expert</td><td>halfcheetah</td><td>90.8± 26.9</td><td>105.9 ± 17.8</td><td>57.9 ± 24.8</td><td>9.7 ± 9.5</td></tr><tr><td>hopper</td><td>15±8.7</td><td>55.1 ± 44.3</td><td>51.7 ± 42.9</td><td>56.0 ± 34.5</td></tr><tr><td>walker2d</td><td>65.5 ± 40.2</td><td>70.2 ± 36.2</td><td>55.0 ± 19.1</td><td>7.6 ± 3.7</td></tr></table>
+
+For RLU the datasets are generated using a $70 \%$ performant MPO (Abdolmaleki et al., 2018) policy on the original task, and smaller versions of the datasets are a fixed set of randomly sampled contiguous episodes (Dulac-Arnold et al., 2020; Gulcehre et al., 2020). D4RL has 4 behavior policies, ranging from random behavior to expert demonstrations, and are fully described in Fu et al. (2020). On all datasets, training is performed on $90 \%$ of data and $10 \%$ is used for validation.
+
+# 4.2 PERFORMANCE ON RL-UNPLUGGED & D4RL
+
+For experiments on RLU we consider the unperturbed RWRL cartpole-swingup, walker and quadruped tasks (Tassa et al., 2018; Dulac-Arnold et al., 2020). For D4RL we consider the halfcheetah, hopper, walker2d and Adroit tasks (Brockman et al., 2016; Rajeswaran et al., 2017). Results for the RLU tasks as well as Adroit are presented in Figure 1. On the remaining D4RL tasks, results are compared to those presented by MOPO Yu et al. (2020) in Table 1 for four different data regimes (medium, medium-expert, medium-replay, random). For all experiments we report MBOP performance as well as the performance of a behavior cloning (BC) policy. The BC policy is simply the policy prior $f _ { b }$ , with the control action as the average ensemble output. We use this baseline to demonstrate the advantages brought about by planning beyond simple cloning.
+
+For the RLU datasets (Fig. 1), we observe that MBOP is able to find a near-optimal policy on most dataset sizes in Cartpole and Quadruped with as little as 5000 steps, which corresponds to 5 episodes, or approximately 50 seconds on Cartpole and 100 seconds on Quadruped. On the Walker datasets MBOP requires 23 episodes (approx. 10 minutes) before it finds a reasonable policy, and with sufficient data converges to a score of 900 which is near optimal. On most tasks, MBOP is able to generate a policy significantly better than the behavior data as well as the the BC prior.
+
+For the Adroit task, we show that MBOP is able to outperform the behavior policy after training on a dataset of 50k data points generated by an expert policy (Fig. 1d). For other D4RL datasets, we compare to the performance of MOPO (Yu et al., 2020). We show that on the medium and medium-expert data regimes MBOP outperforms MOPO, sometimes significantly. However on higher-variance datasets such as random and mixed MBOP is not as performant. This is likely due to the reliance on policy-conditioned priors, which we hope to render more flexible in future work (for instance using multi-modal stochastic models). There are nevertheless many tasks where a human operator is running a systems in a relatively consistent yet sub-optimal manner, and one may want to either replicate or improve upon the operator’s control policy. In such scenarios, MBOP would likely be able to not only replicate but improve upon the operator’s control strategy.
+
+# 4.3 ZERO-SHOT TASK ADAPTATION
+
+![](images/92386dd1e89210db39b5223b7bd56c9a461c58595ccf73da873b31dc0541d4bf.jpg)  
+(a) Visualized trajectories for constrained Cartpole.
+
+RLU Quadruped - Mean Heading on Goal-Conditioned Quadruped
+
+![](images/5c001c9b25d34ca76b74d4b5a1ad9a1bac7b04f3c00d7463b2d756c27fb96289.jpg)  
+MBOP trajectories on Cartpole with and without constraint.   
+Figure 2: The above figures describe performance of MBOP on constrained $\&$ goal-conditioned tasks. Fig. 2a illustrates a sequences of frames from the RLU Cartpole task with constrained and unconstrained MBOP controllers. In the constrained cases MBOP prevents the cart from crossing the middle of the rail (dotted red line) and contains it to one side. Fig. 2b displays cart trajectories for constrained and unconstrained versions of the same controller. MBOP can maintain a performant policy (above 750) while respecting these constraints. Fig. 2c displays goal-conditioned performance on the RLU Quadruped. We ignore the original reward function and optimize directly for trajectories that maximize a particular velocity vector. Although influence from $f _ { B }$ and $f _ { R }$ biases the controller to maintain forward direction, we can still exert significant goal-directed influence on the policy.
+
+![](images/b5f632fb241e84e9a562fdfbba075ac34a2882c0b6b64e345acd2dc0d1211520.jpg)  
+(c) RLU Goal-Directed Quadruped
+
+One of the main advantages of using planning-based methods in the offline scenario is that they are easy to adapt to new objective functions. In the case of MBOP these would be novel objectives different from those optimized by the behavior policy that generates the offline data. We can easily take these new objectives into account by computing a secondary objective return as follows: $\mathbf { R } _ { \mathrm { ~ } n } ^ { \prime } =$ $\textstyle \sum _ { t } f _ { o b j } ( s _ { t } )$ where $f _ { o b j }$ is a user-provided function that computes a scalar objective reward given a state. We can then adapt the trajectory update rule to take into account the secondary objective:
+
+$$
+T _ { t } = \frac { \sum _ { n = 1 } ^ { N } e ^ { \kappa \mathbf { R } _ { n } + \kappa _ { 0 b j } \mathbf { R } ^ { \prime } { } _ { n } } \mathbf { A } _ { n , t } } { \sum _ { n = 1 } ^ { N } e ^ { \kappa \mathbf { R } _ { n } + \kappa _ { o b j } \mathbf { R } ^ { \prime } { } _ { n } } } , \forall t \in [ 1 , H ] .
+$$
+
+To demonstrate this, we run MBOP on two types of modified objectives: goal-conditioned control, and constrained control. In goal-conditioned control, we ignore the original reward function $\kappa = 0$ ) and define a new goal (such as a velocity vector) and optimize trajectories relative to that goal. In constrained operation, we add a state-based constraint which we penalize during planning, while maintaining the original objective and find a reasonable combination of $\kappa$ and $\kappa _ { \mathrm { o b j } }$ .
+
+We define three tasks: position-constrained Cartpole, where we penalize the cart’s position to encourage it to stay either on the right or left side of the track; heading-conditioned Quadruped, where we provide a target heading to the policy (Forward, Backwards, Right & Left); and finally height-constrained Walker, where we penalize the policy for bringing the torso height above a certain threshold. Results on Cartpole & Quadruped are presented in Figure 2.
+
+We show that MBOP successfully integrates constraints that were not initially in the dataset and is able to perform well on objectives that are different from the objective of the behavior policy.
+
+Walker performs similarly, obtaining nearly $80 \%$ constraint satisfaction while maintaining a reward of 730. More analysis is available in the Appendix Sec. 5.5.
+
+# 4.4 ALGORITHMIC INVESTIGATIONS
+
+Ablations To better understand the benefits of MBOP’s various elements, we perform three ablations: MBOP-NOPP which replaces $f _ { b }$ with a Gaussian prior, MBOP-NOVF which removes $f _ { R }$ ’s estimated returns, and PDDM which removes both, thus recovering the PDDM controller. We show performance of these four ablations on the Walker dataset in Fig. 3a. A full set of ablations is available in the appendix Figures $4 \ \& \ 5$ . Overall we see that the full combination of BC prior, value function and environment model are important for optimal performance. We also see that the PDDM approach is generally below either of the MBOP-NOPP and MBOP-NOVF ablations. Finally, we note that the BC prior when used alone can perform well on certain environments, but on others it stagnates at behavior policy’s performance.
+
+Execution Speed A frequent concern with planning-based methods is their slower response time prohibiting practical use. We calculate the average control frequency of MBOP on the RLU Walker task using a single Intel(R) Xeon(R) W-2135 CPU $\textcircled { a } ~ 3 . 7 0 \mathrm { G H z }$ core and a Nvidia $1 0 8 0 \mathrm { T I }$ and find that MBOP can operate at frequencies ranging from $1 0 6 \ : \mathrm { H z }$ for $h = 4$ to $4 0 \ \mathrm { H z }$ for a $h = 4 0$ , with BC operating at $3 6 2 \mathrm { H z }$ . Additional values are presented in Appendix Sec. 5.4.
+
+# Hyperparameter Stability
+
+We perform a grid sweep over the $\kappa$ (trajectory re-weighting) and $H$ (planning horizon) on the three RLU environments and visualize the effects on return in Fig. 3b. We observe that overall MBOP maintains consistent performance scores for wide ranges of hyperparameter values, only really degrading near extreme values. Additional analysis is present in the Appendix’s Section 5.5.
+
+![](images/cd1d840787a31f80af2f7a80955f36dda1f4a5dd90f0a018c15b24e1e0e21be4.jpg)
+
+(a) MBOP ablations’ performance on RLU Walker Dataset. We observe that MBOP is consistently more performant than its ablations.
+
+# 5 CONCLUSION
+
+Planning-based methods provide significantly more flexibility for external systems to interact with the learned controller. Bringing them into the offline data regime opens the door to their use on more real-world systems for which online training is not an option.
+
+MBOP provides an easy to implement, dataefficient, stable, and flexible algorithm for pol
+
+![](images/9f47cb73b2072aebc6037dc887f7b2e7deb8fd00430561e0fb441d4805250d0d.jpg)  
+(b) MBOP sensitivity to Kappa $( \kappa )$ and Horizon $( H )$ .
+
+icy generation. It is easy to implement because the learning components are simple supervised learners, it is data-efficient thanks to its use of multiple complementary estimators, and it is flexible due to its use of on-line planning which allows it to dynamically react to changing goals, costs and environmental constraints.
+
+We show that MBOP can perform competitively in various data regimes, and can provide easily adaptable policies for more complex goal-conditioned or constrained tasks, even if the original data does not provide prior experience. Although MBOP’s performance is degraded when offline data is multi-modal or downright random, we believe there are a large number of scenarios where the current operating policy (be it human or automated) is reasonably consistent, but could benefit from being automated and improved upon. In these scenarios we believe that MBOP could be readily applicable. Future work intends to ameliorate performance by investigating the use of goal-conditioned policy priors and value estimates, as well as looking at effective ways to perform offline model selection and evaluation. We sincerely hope that MBOP can be useful as an out-of-the-box algorithm for learning stable and configurable control policies for real systems.
+
+# REFERENCES
+
+Abbas Abdolmaleki, Jost Tobias Springenberg, Yuval Tassa, Remi Munos, Nicolas Heess, and Martin Riedmiller. Maximum a posteriori policy optimisation. arXiv preprint arXiv:1806.06920, 2018.
+
+Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
+
+Kurtland Chua, Roberto Calandra, Rowan McAllister, and Sergey Levine. Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Advances in Neural Information Processing Systems, pp. 4754–4765, 2018.
+
+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, 2011.
+
+Gabriel Dulac-Arnold, Nir Levine, Daniel J Mankowitz, Jerry Li, Cosmin Paduraru, Sven Gowal, and Todd Hester. An empirical investigation of the challenges of real-world reinforcement learning. arXiv preprint arXiv:2003.11881, 2020.
+
+Frederik Ebert, Chelsea Finn, Sudeep Dasari, Annie Xie, Alex Lee, and Sergey Levine. Visual foresight: Model-based deep reinforcement learning for vision-based robotic control. arXiv preprint arXiv:1812.00568, 2018.
+
+Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020.
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. In International Conference on Machine Learning, pp. 2052–2062, 2019.
+
+Caglar Gulcehre, Ziyu Wang, Alexander Novikov, Tom Le Paine, Sergio Gomez Colmenarejo, Kon- ´ rad Zolna, Rishabh Agarwal, Josh Merel, Daniel Mankowitz, Cosmin Paduraru, et al. Rl unplugged: Benchmarks for offline reinforcement learning. arXiv preprint arXiv:2006.13888, 2020.
+
+Danijar Hafner, Timothy Lillicrap, Jimmy Ba, and Mohammad Norouzi. Dream to control: Learning behaviors by latent imagination. arXiv preprint arXiv:1912.01603, 2019a.
+
+Danijar Hafner, Timothy Lillicrap, Ian Fischer, Ruben Villegas, David Ha, Honglak Lee, and James Davidson. Learning latent dynamics for planning from pixels. In International Conference on Machine Learning, pp. 2555–2565, 2019b.
+
+Michael Janner, Justin Fu, Marvin Zhang, and Sergey Levine. When to trust your model: Modelbased policy optimization. In Advances in Neural Information Processing Systems, pp. 12519– 12530, 2019.
+
+Gregory Kahn, Pieter Abbeel, and Sergey Levine. Badgr: An autonomous self-supervised learningbased navigation system. arXiv preprint arXiv:2002.05700, 2020.
+
+Rahul Kidambi, Aravind Rajeswaran, Praneeth Netrapalli, and Thorsten Joachims. Morel: Modelbased offline reinforcement learning. arXiv preprint arXiv:2005.05951, 2020.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In Advances in neural information processing systems, pp. 6402–6413, 2017.
+
+Sergey Levine and Vladlen Koltun. Guided policy search. In International Conference on Machine Learning, pp. 1–9, 2013.
+
+Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.
+
+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.
+
+Kendall Lowrey, Aravind Rajeswaran, Sham Kakade, Emanuel Todorov, and Igor Mordatch. Plan online, learn offline: Efficient learning and exploration via model-based control. arXiv preprint arXiv:1811.01848, 2018.
+
+Kevin Lu, Igor Mordatch, and Pieter Abbeel. Adaptive online planning for continual lifelong learning. arXiv preprint arXiv:1912.01188, 2019.
+
+Tatsuya Matsushima, Hiroki Furuta, Yutaka Matsuo, Ofir Nachum, and Shixiang Gu. Deploymentefficient reinforcement learning via model-based offline optimization. arXiv preprint arXiv:2006.03647, 2020.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. nature, 518(7540):529–533, 2015.
+
+Ofir Nachum, Yinlam Chow, Bo Dai, and Lihong Li. Dualdice: Behavior-agnostic estimation of discounted stationary distribution corrections. In Advances in Neural Information Processing Systems, pp. 2318–2328, 2019.
+
+Anusha Nagabandi, Kurt Konolige, Sergey Levine, and Vikash Kumar. Deep dynamics models for learning dexterous manipulation. In Conference on Robot Learning, pp. 1101–1112, 2020.
+
+Tom Le Paine, Cosmin Paduraru, Andrea Michi, Caglar Gulcehre, Konrad Zolna, Alexander Novikov, Ziyu Wang, and Nando de Freitas. Hyperparameter selection for offline reinforcement learning. arXiv preprint arXiv:2007.09055, 2020.
+
+Xue Bin Peng, Aviral Kumar, Grace Zhang, and Sergey Levine. Advantage-weighted regression: Simple and scalable off-policy reinforcement learning. arXiv preprint arXiv:1910.00177, 2019.
+
+Doina Precup. Eligibility traces for off-policy policy evaluation. Computer Science Department Faculty Publication Series, pp. 80, 2000.
+
+Aravind Rajeswaran, Vikash Kumar, Abhishek Gupta, Giulia Vezzani, John Schulman, Emanuel Todorov, and Sergey Levine. Learning complex dexterous manipulation with deep reinforcement learning and demonstrations. arXiv preprint arXiv:1709.10087, 2017.
+
+Aravind Rajeswaran, Igor Mordatch, and Vikash Kumar. A game theoretic framework for model based reinforcement learning. arXiv preprint arXiv:2004.07804, 2020.
+
+J Rault, A Richalet, JL Testud, and J Papon. Model predictive heuristic control: application to industrial processes. Automatica, 14(5):413–428, 1978.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+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.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, et al. Deepmind control suite. arXiv preprint arXiv:1801.00690, 2018.
+
+Nolan Wagener, Ching-An Cheng, Jacob Sacks, and Byron Boots. An online learning approach to model predictive control. arXiv preprint arXiv:1902.08967, 2019.
+
+Tingwu Wang and Jimmy Ba. Exploring model-based planning with policy networks. arXiv preprint arXiv:1906.08649, 2019.
+
+Ziyu Wang, Alexander Novikov, Konrad Zolna, Josh S Merel, Jost Tobias Springenberg, Scott E Reed, Bobak Shahriari, Noah Siegel, Caglar Gulcehre, Nicolas Heess, et al. Critic regularized regression. Advances in Neural Information Processing Systems, 33, 2020.
+
+Grady Williams, Andrew Aldrich, and Evangelos Theodorou. Model predictive path integral control using covariance variable importance sampling. arXiv preprint arXiv:1509.01149, 2015.
+
+Grady Williams, Andrew Aldrich, and Evangelos A Theodorou. Model predictive path integral control: From theory to parallel computation. Journal of Guidance, Control, and Dynamics, 40 (2):344–357, 2017a.
+
+Grady Williams, Nolan Wagener, Brian Goldfain, Paul Drews, James M Rehg, Byron Boots, and Evangelos A Theodorou. Information theoretic mpc for model-based reinforcement learning. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 1714–1721. IEEE, 2017b.
+
+Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning. CoRR, abs/1911.11361, 2019. URL http://arxiv.org/abs/1911.11361.
+
+Yuxiang Yang, Ken Caluwaerts, Atil Iscen, Tingnan Zhang, Jie Tan, and Vikas Sindhwani. Data efficient reinforcement learning for legged robots. In Conference on Robot Learning, pp. 1–10, 2020.
+
+Tianhe Yu, Garrett Thomas, Lantao Yu, Stefano Ermon, James Zou, Sergey Levine, Chelsea Finn, and Tengyu Ma. Mopo: Model-based offline policy optimization. arXiv preprint arXiv:2005.13239, 2020.
+
+# APPENDIX
+
+# 5.1 MBOP PERTINENCE TO ROBOTICS
+
+MBOP provides a general model-based approach for offline learning. We have considered only physics-bound tasks in this paper as the underlying methods (MPC, MPPI) are known to work well on real systems (Nagabandi et al., 2020; Williams et al., 2015; Kahn et al., 2020). Although this paper does not implement MBOP on actual robots, this is upcoming work, and we believe that by having shown MBOP’s performance over 6 different environments (cartpole, walker, quadruped, Adroit, halfcheetah, hopper) involving under-actuated control, locomotion, and manipulation, MBOP’s potential for applicability on a real systems is promising. More specifically, we believe MBOP provides a couple key contributions specifically interesting to the robotics community:
+
+• Ability to learn entirely offline without a simulator.   
+• Ability to constrain policy operation.   
+• Ability to completely rephrase the policy’s goal according to an arbitrary cost function.
+
+These aspects make MBOP a unique contribution that potentially opens a series of interesting research questions around zero-shot adaptation, leveraging behavior priors, using sub-optimal models, leveraging uncertainty, and more generally exploring the additional control opportunities provided by model-based methods that are much more difficult with model-free learnt controllers.
+
+As mentioned above it is our intent to quickly try out MBOP on various robotic systems. If results are available by the time of CoRL 2020 they will be presented as well.
+
+# 5.2 PERFORMANCE OF MBOP ABLATIONS AND ASSOCIATED HYPERPARAMETERS
+
+We present mean evaluation performance and associated hyper parameters for runs of MBOP and its ablations in a set of tables. For RLU: Table 2 for Cartpole, 3 for Quadruped, 4 for Walker. For D4RL:
+
+Table 2: RLU Cartpole Performance   
+
+<table><tr><td>#Points</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>5000</td><td>CLONING</td><td>-</td><td>-</td><td>=</td><td>-</td><td>-</td><td>229.2</td><td>71.7</td></tr><tr><td>5000</td><td>MBOP</td><td>64</td><td>100</td><td>2.34</td><td>0.8</td><td>0.2</td><td>803.1</td><td>117.7</td></tr><tr><td>5000</td><td>MBOP-NOPP</td><td>128</td><td>100</td><td>0.23</td><td>0.8</td><td>0.2</td><td>605.8</td><td>223.6</td></tr><tr><td>5000</td><td>MBOP-NOVF</td><td>128</td><td>100</td><td>1.17</td><td>0.8</td><td>0.2</td><td>715.2</td><td>183.7</td></tr><tr><td>5000</td><td>PDDM</td><td>128</td><td>100</td><td>0.7</td><td>0.8</td><td>0.2</td><td>726.6</td><td>131.8</td></tr><tr><td>25000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>350.7</td><td>168.2</td></tr><tr><td>25000</td><td>MBOP</td><td>64</td><td>100</td><td>0.5</td><td>0.8</td><td>0.2</td><td>792.0</td><td>90.4</td></tr><tr><td>25000</td><td>MBOP-NOPP</td><td>64</td><td>100</td><td>2.3</td><td>0.1</td><td>0.2</td><td>463.6</td><td>284.0</td></tr><tr><td>25000</td><td>MBOP-NOVF</td><td>128</td><td>100</td><td>0.7</td><td>0.8</td><td>0.2</td><td>776.5</td><td>128.7</td></tr><tr><td>25000</td><td>PDDM</td><td>128</td><td>100</td><td>0.7</td><td>0.4</td><td>0.2</td><td>720.2</td><td>69.3</td></tr><tr><td>100000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>567.4</td><td>123.6</td></tr><tr><td>100000</td><td>MBOP</td><td>64</td><td>100</td><td>2.3</td><td>0.8</td><td>0.2</td><td>834.4</td><td>28.6</td></tr><tr><td>100000</td><td>MBOP-NOPP</td><td>64</td><td>100</td><td>1.4</td><td>0.2</td><td>0.2</td><td>832.1</td><td>51.1</td></tr><tr><td>100000</td><td>MBOP-NOVF</td><td>128</td><td>100</td><td>1.2</td><td>1.6</td><td>0.2</td><td>733.6</td><td>150.3</td></tr><tr><td>100000</td><td>PDDM</td><td>128</td><td>100</td><td>1.2</td><td>0.2</td><td>0.2</td><td>723.5</td><td>124.8</td></tr><tr><td>200000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>644.3</td><td>78.9</td></tr><tr><td>200000</td><td>MBOP</td><td>64</td><td>100</td><td>0.5</td><td>1.6</td><td>0.2</td><td>840.7</td><td>7.5</td></tr><tr><td>200000</td><td>MBOP-NOPP</td><td>64</td><td>100</td><td>2.3</td><td>0.2</td><td>0.2</td><td>840.6</td><td>12.4</td></tr><tr><td>200000</td><td>MBOP-NOVF</td><td>128</td><td>100</td><td>1.2</td><td>1.6</td><td>0.2</td><td>767.0</td><td>83.6</td></tr><tr><td>200000</td><td>PDDM</td><td>128</td><td>100</td><td>1.2</td><td>0.2</td><td>0.2</td><td>797.6</td><td>47.1</td></tr><tr><td>500000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>612.0</td><td>63.9</td></tr><tr><td>500000</td><td>MBOP</td><td>64</td><td>100</td><td>1.4</td><td>1.6</td><td>0.2</td><td>845.7</td><td>6.7</td></tr><tr><td>500000</td><td>MBOP-NOPP</td><td>64</td><td>100</td><td>2.3</td><td>0.2</td><td>0.2</td><td>840.6</td><td>13.7</td></tr><tr><td>500000</td><td>MBOP-NOVF</td><td>128</td><td>100</td><td>1.2</td><td>1.6</td><td>0.2</td><td>823.2</td><td>44.2</td></tr><tr><td>500000</td><td>PDDM</td><td>128</td><td>100</td><td>1.2</td><td>0.2</td><td>0.2</td><td>781.9</td><td>96.6</td></tr></table>
+
+Table 3: RLU-Quadruped Performance   
+
+<table><tr><td>#Points</td><td>Policy</td><td>Horizon</td><td>#Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>5000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>796.0</td><td>17.0</td></tr><tr><td>5000</td><td>MBOP</td><td>8</td><td>1000</td><td>3.8</td><td>0.8</td><td>0.2</td><td>974.1</td><td>9.9</td></tr><tr><td>5000</td><td>MBOP-NOPP</td><td>16</td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>5000</td><td>MBOP-NOVF</td><td></td><td>1000 1000</td><td>1.9</td><td>1.6</td><td>0.2</td><td>561.6</td><td>233.2</td></tr><tr><td>5000</td><td>PDDM</td><td>16 32</td><td>1000</td><td>1.9 0.9</td><td>0.8 1.6</td><td>0.2 0.2</td><td>959.5 569.8</td><td>15.1 26.9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>25000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td></td><td>966.5</td><td>10.9</td></tr><tr><td>25000</td><td>MBOP</td><td>8</td><td>1000</td><td>3.8</td><td>0.8</td><td>0.2</td><td>983.8</td><td>3.6</td></tr><tr><td>25000</td><td>MBOP-NOPP</td><td>16</td><td>1000</td><td>1.9</td><td>1.6</td><td>0.2</td><td>866.6</td><td>87.4</td></tr><tr><td>25000 25000</td><td>MBOP-NOVF PDDM</td><td>16 32</td><td>1000 1000</td><td>1.9 0.9</td><td>0.8</td><td>0.2 0.2</td><td>983.0</td><td>1.6</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.6</td><td></td><td>728.1</td><td>120.7</td></tr><tr><td>100000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>966.5</td><td>15.1</td></tr><tr><td>100000 100000</td><td>MBOP</td><td>8</td><td>1000</td><td>3.8</td><td>0.8</td><td>0.2</td><td>989.4</td><td>3.2</td></tr><tr><td></td><td>MBOP-NOPP</td><td>16</td><td>1000</td><td>1.9</td><td>1.6</td><td>0.2</td><td>935.3</td><td>35.2</td></tr><tr><td>100000 100000</td><td>MBOP-NOVF PDDM</td><td>16 32</td><td>1000 1000</td><td>1.9 0.9</td><td>0.8</td><td>0.2 0.2</td><td>983.8</td><td>2.2</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>1.6</td><td></td><td>967.1</td><td>12.5</td></tr><tr><td>200000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>972.9</td><td>8.6</td></tr><tr><td>200000</td><td>MBOP</td><td>8</td><td>1000</td><td>3.8</td><td>0.8</td><td>0.2</td><td>993.3</td><td>1.3</td></tr><tr><td>200000</td><td>MBOP-NOPP</td><td>16</td><td>1000</td><td>1.9</td><td>1.6</td><td>0.2</td><td>984.5</td><td>12.1</td></tr><tr><td>200000 200000</td><td>MBOP-NOVF PDDM</td><td>16</td><td>1000</td><td>1.9</td><td>0.8</td><td>0.2</td><td>986.6</td><td>1.3</td></tr><tr><td></td><td></td><td>32</td><td>1000</td><td>0.9</td><td>1.6</td><td>0.2</td><td>946.4</td><td>29.7</td></tr><tr><td>500000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>973.1</td><td>5.6</td></tr><tr><td>500000</td><td>MBOP</td><td>8</td><td>1000</td><td>3.8</td><td>0.8</td><td>0.2</td><td>994.8</td><td>0.4</td></tr><tr><td>500000</td><td>MBOP-NOPP</td><td>16</td><td>1000</td><td>1.9</td><td>1.6</td><td>0.2</td><td>994.0</td><td>3.5</td></tr><tr><td>500000</td><td>MBOP-NOVF</td><td>16</td><td>1000</td><td>1.9</td><td>0.8</td><td>0.2</td><td>984.2</td><td>2.2</td></tr><tr><td>500000</td><td>PDDM</td><td>32</td><td>1000</td><td>0.9</td><td>1.6</td><td>0.2</td><td>965.0</td><td>12.0</td></tr></table>
+
+Table 4: RLU-Walker Performance   
+
+<table><tr><td># Points</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>10000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>244.5</td><td>284.6</td></tr><tr><td>10000</td><td>MBOP</td><td>8</td><td>100</td><td>3.8</td><td>0.2</td><td>0.2</td><td>251.2</td><td>280.4</td></tr><tr><td>10000</td><td>MBOP-NOPP</td><td>32</td><td>100</td><td>4.7</td><td>1.6</td><td>0.2</td><td>45.7</td><td>16.6</td></tr><tr><td>10000</td><td>MBOP-NOVF</td><td>4</td><td>100</td><td>7.5</td><td>0.1</td><td>0.2</td><td>225.3</td><td>275.8</td></tr><tr><td>10000</td><td>PDDM</td><td>8</td><td>100</td><td>18.8</td><td>0.8</td><td>0.2</td><td>37.0</td><td>16.8</td></tr><tr><td>14000</td><td>CLONING</td><td>-</td><td></td><td>-</td><td>-</td><td>-</td><td>402.4</td><td>263.0</td></tr><tr><td>14000</td><td>MBOP</td><td>4</td><td>100</td><td>37.5</td><td>0.1</td><td>0.2</td><td>489.7</td><td>250.3</td></tr><tr><td>14000</td><td>MBOP-NOPP</td><td>32</td><td>100</td><td>2.8</td><td>1.6</td><td>0.2</td><td>53.1</td><td>24.0</td></tr><tr><td>14000</td><td>MBOP-NOVF</td><td>4</td><td>100</td><td>37.5</td><td>0.1</td><td>0.2</td><td>424.3</td><td>266.2</td></tr><tr><td>14000</td><td>PDDM</td><td>32</td><td>100</td><td>4.7</td><td>1.6</td><td>0.2</td><td>57.4</td><td>23.2</td></tr><tr><td>23000</td><td>CLONING</td><td>-</td><td>=</td><td>-</td><td>=</td><td>-</td><td>616.7</td><td>224.4</td></tr><tr><td>23000</td><td>MBOP</td><td>16</td><td>100</td><td>1.9</td><td>0.2</td><td>0.2</td><td>679.0</td><td>200.2</td></tr><tr><td>23000</td><td>MBOP-NOPP</td><td>8</td><td>100</td><td>18.8</td><td>0.8</td><td>0.2</td><td>103.0</td><td>56.2</td></tr><tr><td>23000</td><td>MBOP-NOVF</td><td>8</td><td>100</td><td>18.8</td><td>0.1</td><td>0.2</td><td>617.7</td><td>220.8</td></tr><tr><td>23000</td><td>PDDM</td><td>32</td><td>100</td><td>4.7</td><td>1.6</td><td>0.2</td><td>77.6</td><td>40.4</td></tr><tr><td>41000</td><td>CLONING</td><td>-</td><td></td><td>-</td><td>-</td><td>-</td><td>638.0</td><td>200.2</td></tr><tr><td>41000</td><td>MBOP</td><td>8</td><td>100</td><td>3.8</td><td>0.2</td><td>0.2</td><td>752.0</td><td>118.0</td></tr><tr><td>41000</td><td>MBOP-NOPP</td><td>8</td><td>100</td><td>11.3</td><td>1.6</td><td>0.2</td><td>160.9</td><td>80.5</td></tr><tr><td>41000</td><td>MBOP-NOVF</td><td>32</td><td>100</td><td>2.8</td><td>0.1</td><td>0.2</td><td>700.6</td><td>97.7</td></tr><tr><td>41000</td><td>PDDM</td><td>32</td><td>100</td><td>4.7</td><td>0.8</td><td>0.2</td><td>79.5</td><td>32.9</td></tr><tr><td>50000</td><td>CLONING</td><td>-</td><td>=</td><td>-</td><td>-</td><td>-</td><td>615.7</td><td>240.6</td></tr><tr><td>50000</td><td>MBOP</td><td>4</td><td>100</td><td>7.5</td><td>0.4</td><td>0.2</td><td>775.0</td><td>87.1</td></tr><tr><td>50000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>22.5</td><td>1.6</td><td>0.2</td><td>87.4</td><td>78.2</td></tr><tr><td>50000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>9.4</td><td>0.2</td><td>0.2</td><td>723.2</td><td>103.1</td></tr><tr><td>50000</td><td>PDDM</td><td>32</td><td>100</td><td>2.8</td><td>1.6</td><td>0.2</td><td>59.4</td><td>33.6</td></tr><tr><td>250000</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>686.8</td><td>205.4</td></tr><tr><td>250000</td><td>MBOP</td><td>4</td><td>100</td><td>7.5</td><td>0.4</td><td>0.2</td><td>844.7</td><td>48.4</td></tr><tr><td>250000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>22.5</td><td>1.6</td><td>0.2</td><td>269.1</td><td>155.9</td></tr><tr><td>250000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>9.4</td><td>0.2</td><td>0.2</td><td>770.4</td><td>115.1</td></tr><tr><td>250000</td><td>PDDM</td><td>32</td><td>100</td><td>2.8</td><td>1.6</td><td>0.2</td><td>231.3</td><td>112.2</td></tr><tr><td>1000000</td><td>CLONING</td><td>-</td><td>/</td><td>-</td><td>-</td><td>-</td><td>701.5</td><td>190.9</td></tr><tr><td>1000000</td><td>MBOP</td><td>4</td><td>100</td><td>7.5</td><td>0.4</td><td>0.2</td><td>797.3</td><td>229.5</td></tr><tr><td>1000000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>22.5</td><td>1.6</td><td>0.2</td><td>411.2</td><td>183.5</td></tr><tr><td>1000000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>9.4</td><td>0.2</td><td>0.2</td><td>814.3</td><td>88.4</td></tr><tr><td>1000000</td><td>PDDM</td><td>32</td><td>100</td><td>2.8</td><td>1.6</td><td>0.2</td><td>308.2</td><td>140.3</td></tr><tr><td>2000000</td><td>CLONING</td><td></td><td></td><td></td><td></td><td></td><td></td><td>85.6</td></tr><tr><td>2000000</td><td>MBOP</td><td>- 4</td><td>100</td><td>- 7.5</td><td>0.4</td><td>- 0.2</td><td>743.6 872.4</td><td>70.2</td></tr><tr><td>2000000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>22.5</td><td>1.6</td><td>0.2</td><td>823.8</td><td>35.5</td></tr><tr><td>2000000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>9.4</td><td>0.2</td><td>0.2</td><td>807.8</td><td>44.2</td></tr><tr><td>2000000</td><td>PDDM</td><td>32</td><td>100</td><td>2.8</td><td>1.6</td><td>0.2</td><td>460.3</td><td>117.6</td></tr><tr><td>5000000</td><td>CLONING</td><td></td><td></td><td></td><td>-</td><td>-</td><td>759.9</td><td>48.2</td></tr><tr><td>5000000</td><td>MBOP</td><td>- 4</td><td>- 100</td><td>- 7.5</td><td>0.4</td><td>0.2</td><td>908.8</td><td>54.3</td></tr><tr><td>5000000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>22.5</td><td>1.6</td><td>0.2</td><td>784.0</td><td>140.8</td></tr><tr><td>5000000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>9.4</td><td>0.2 1.6</td><td>0.2 0.2</td><td>833.5 620.1</td><td>100.7 98.7</td></tr><tr><td>5000000</td><td>PDDM</td><td>32</td><td>100</td><td>2.8</td></table>
+
+Table 5: D4RL Door Performance   
+
+<table><tr><td>#Points</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>400</td><td>CLONING</td><td>-</td><td>-</td><td>=</td><td>-</td><td>-</td><td>352.2</td><td>942.3</td></tr><tr><td>400</td><td>MBOP</td><td>32</td><td>100</td><td>0.03</td><td>0.05</td><td>0</td><td>22.7</td><td>348.5</td></tr><tr><td>400</td><td>MBOP-NOPP</td><td>16</td><td>200</td><td>0.01</td><td>0.05</td><td>0</td><td>-54.6</td><td>1.0</td></tr><tr><td>400</td><td>MBOP-NOVF</td><td>4</td><td>500</td><td>0.01</td><td>0.05</td><td>0</td><td>202.3</td><td>779.7</td></tr><tr><td>400</td><td>PDDM</td><td>4</td><td>500</td><td>0.01</td><td>0.05</td><td>0.2</td><td>-52.9</td><td>0.6</td></tr><tr><td>2000</td><td>CLONING</td><td>-</td><td></td><td></td><td>=</td><td>-</td><td>2889.5</td><td>579.7</td></tr><tr><td>2000</td><td>MBOP</td><td>8</td><td>100</td><td>0.03</td><td>0.05</td><td>0</td><td>2944.8</td><td>398.6</td></tr><tr><td>2000</td><td>MBOP-NOPP</td><td>8</td><td>200</td><td>0.01</td><td>0.05</td><td>0</td><td>-54.1</td><td>0.6</td></tr><tr><td>2000</td><td>MBOP-NOVF</td><td>16</td><td>1000</td><td>0.03</td><td>0.1</td><td>0</td><td>2903.7</td><td>537.2</td></tr><tr><td>2000</td><td>PDDM</td><td>4</td><td>500</td><td>0.01</td><td>0.05</td><td>0.2</td><td>-53.0</td><td>0.6</td></tr><tr><td>4000</td><td>CLONING</td><td>：</td><td></td><td></td><td></td><td>-</td><td>3019.1</td><td>180.4</td></tr><tr><td>4000</td><td>MBOP</td><td>16</td><td>200</td><td>0.01</td><td>0.05</td><td>0</td><td>3043.4</td><td>64.3</td></tr><tr><td>4000</td><td>MBOP-NOPP</td><td>64</td><td>200</td><td>0.03</td><td>0.4</td><td>0</td><td>-61.1</td><td>2.6</td></tr><tr><td>4000</td><td>MBOP-NOVF</td><td>64</td><td>200</td><td>0.03</td><td>0.05</td><td>0</td><td>2991.9</td><td>302.7</td></tr><tr><td>4000</td><td>PDDM</td><td>4</td><td>500</td><td>0.03</td><td>0.05</td><td>0.2</td><td>-52.8</td><td>0.6</td></tr><tr><td>10000</td><td>CLONING</td><td>-</td><td>-</td><td>=</td><td></td><td>-</td><td>2980.3</td><td>335.3</td></tr><tr><td>10000</td><td>MBOP</td><td>4</td><td>100</td><td>0.3</td><td>0.05</td><td>0</td><td>3026.1</td><td>180.7</td></tr><tr><td>10000</td><td>MBOP-NOPP</td><td>8</td><td>500</td><td>0.01</td><td>0.05</td><td>0</td><td>-53.5</td><td>0.6</td></tr><tr><td>10000</td><td>MBOP-NOVF</td><td>16</td><td>100</td><td>0.03</td><td>0.05</td><td>0</td><td>2973.6</td><td>351.5</td></tr><tr><td>10000</td><td>PDDM</td><td>4</td><td>100</td><td>0.01</td><td>0.05</td><td>0.2</td><td>-53.1</td><td>0.7</td></tr><tr><td>50000</td><td>CLONING</td><td>-</td><td>-</td><td></td><td></td><td>-</td><td>2984.5</td><td>313.4</td></tr><tr><td>50000</td><td>MBOP</td><td>4</td><td>1000</td><td>0.03</td><td>0.2</td><td>0</td><td>3028.2</td><td>197.6</td></tr><tr><td>50000</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>0.01</td><td>0.05</td><td>0</td><td>-53.4</td><td>0.9</td></tr><tr><td>50000</td><td>MBOP-NOVF</td><td>64</td><td>100</td><td>0.3</td><td>0.05</td><td>0</td><td>3052.2</td><td>28.2</td></tr><tr><td>50000</td><td>PDDM</td><td>4</td><td>500</td><td>0.01</td><td>0.1</td><td>0.2</td><td>-53.0</td><td>0.8</td></tr><tr><td>200000</td><td>CLONING</td><td>-</td><td></td><td></td><td>-</td><td>-</td><td>3028.0</td><td>26.6</td></tr><tr><td>200000</td><td>MBOP</td><td>8</td><td>- 1000</td><td>- 0.03</td><td>0.2</td><td>0</td><td>2967.0</td><td>355.0</td></tr><tr><td>200000</td><td>MBOP-NOPP</td><td>4</td><td>500</td><td>0.01</td><td>0.05</td><td>0</td><td>-52.9</td><td>0.8</td></tr><tr><td>200000</td><td>MBOP-NOVF</td><td>32</td><td>500</td><td>0.3</td><td>0.1</td><td>0</td><td>3024.2</td><td>198.6</td></tr><tr><td>200000</td><td>PDDM</td><td>64</td><td>500</td><td>0.3</td><td>0.2</td><td>0.2</td><td>-59.7</td><td>2.8</td></tr><tr><td>400000</td><td>CLONING</td><td>-</td><td></td><td>=</td><td>-</td><td>-</td><td>3025.1</td><td>21.0</td></tr><tr><td>400000</td><td>MBOP</td><td>16</td><td>= 100</td><td>0.3</td><td>0.1</td><td>0</td><td>3000.3</td><td>388.4</td></tr><tr><td>400000</td><td>MBOP-NOPP</td><td>64</td><td>100</td><td>0.03</td><td>0.4</td><td>0</td><td>-61.4</td><td>2.1</td></tr><tr><td>400000</td><td>MBOP-NOVF</td><td>16</td><td>200</td><td>0.3</td><td>0.1</td><td>0</td><td>3019.5</td><td>128.9</td></tr><tr><td>400000</td><td>PDDM</td><td>4</td><td>1000</td><td>0.01</td><td>0.1</td><td>0.2</td><td>-52.9</td><td>0.6</td></tr><tr><td>1000000</td><td>CLONING</td><td>-</td><td></td><td>-</td><td>-</td><td>-</td><td>3004.3</td><td>142.3</td></tr><tr><td>1000000</td><td>MBOP</td><td>16</td><td>- 100</td><td>0.1</td><td>0.2</td><td>0</td><td>2910.2</td><td>579.6</td></tr><tr><td>1000000</td><td>MBOP-NOPP</td><td>64</td><td>1000</td><td>0.01</td><td>0.4</td><td>0</td><td>-60.7</td><td>2.0</td></tr><tr><td>1000000</td><td>MBOP-NOVF</td><td>32</td><td>200</td><td>0.3</td><td>0.1</td><td>0</td><td>3015.6</td><td>241.6</td></tr><tr><td>1000000</td><td>PDDM</td><td>16</td><td>100</td><td>0.01</td><td>0.4</td><td>0.2</td><td>-54.6</td><td>1.7</td></tr></table>
+
+Table 6: D4RL HalfCheetah Performance   
+
+<table><tr><td>Dataset</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>med-expert</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>11012.8</td><td>3259.7</td></tr><tr><td>med-expert</td><td>MBOP</td><td>2</td><td>100</td><td>1</td><td>0.2</td><td>0</td><td>12850.7</td><td>2160.7</td></tr><tr><td>med-expert</td><td>MBOP-NOPP</td><td>2</td><td>100</td><td></td><td>0.2</td><td>0</td><td>-334.1</td><td>92.2</td></tr><tr><td></td><td>MBOP-NOVF</td><td>40</td><td></td><td>1</td><td></td><td></td><td></td><td></td></tr><tr><td>med-expert med-expert</td><td>PDDM</td><td>2</td><td>100 100</td><td>1 1</td><td>0.2 0.2</td><td>0 0</td><td>7220.3 -165.2</td><td>3450.9 35.8</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>mixed</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-6.0</td><td>1.6</td></tr><tr><td>mixed</td><td>MBOP</td><td>4</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>5135.1</td><td>107.9</td></tr><tr><td>mixed</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>-415.7</td><td>43.3</td></tr><tr><td>mixed mixed</td><td>MBOP-NOVF PDDM</td><td>20 20</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>4724.6</td><td>542.8</td></tr><tr><td></td><td></td><td></td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>-275.6</td><td>58.9</td></tr><tr><td>medium</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>4242.4</td><td>304.5</td></tr><tr><td>medium</td><td>MBOP</td><td>2</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>5406.5</td><td>96.6</td></tr><tr><td>medium</td><td>MBOP-NOPP</td><td>2</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>-427.0</td><td>79.9</td></tr><tr><td>medium medium</td><td>MBOP-NOVF</td><td>20</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>4959.8</td><td>85.5</td></tr><tr><td></td><td>PDDM</td><td>20</td><td>100</td><td>3</td><td>0.2</td><td>0</td><td>-331.9</td><td>30.1</td></tr><tr><td>random</td><td>CLONING</td><td>-</td><td>=</td><td>-</td><td>-</td><td>-</td><td>-1.0</td><td>1.1</td></tr><tr><td>random</td><td>MBOP</td><td>4</td><td>100</td><td>3</td><td>0.8</td><td>0</td><td>768.4</td><td>491.2</td></tr><tr><td>random</td><td>MBOP-NOPP</td><td>4</td><td>100</td><td>3</td><td>0.8</td><td>0</td><td>254.0</td><td>567.8</td></tr><tr><td>random</td><td>MBOP-NOVF</td><td>40</td><td>100</td><td>3</td><td>0.8</td><td>0</td><td>495.6</td><td>534.7</td></tr><tr><td>random</td><td>PDDM</td><td>40</td><td>100</td><td>3</td><td>0.8</td><td>0</td><td>-156.7</td><td>110.1</td></tr></table>
+
+Table 7: D4RL Hopper Performance   
+
+<table><tr><td>Dataset</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>med-expert</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>486.6</td><td>282.4</td></tr><tr><td>med-expert</td><td>MBOP</td><td>10</td><td>100.0</td><td>3</td><td>0.01</td><td>0.0</td><td>1781.7</td><td>1433.8</td></tr><tr><td>med-expert</td><td>MBOP-NOPP</td><td>10</td><td>100.0</td><td>3</td><td>0.01</td><td>0.0</td><td>151.9</td><td>30.1</td></tr><tr><td>med-expert</td><td>MBOP-NOVF</td><td>80</td><td>100.0</td><td>3</td><td>0.01</td><td>0.0</td><td>1055.7</td><td>1300.4</td></tr><tr><td>med-expert</td><td>PDDM</td><td>80</td><td>100.0</td><td>3</td><td>0.01</td><td>0.0</td><td>123.5</td><td>36.3</td></tr><tr><td>medium</td><td>CLONING</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>medium</td><td>MBOP</td><td>- 4</td><td>- 100.0</td><td>- 0.3</td><td>- 0.01</td><td>- 0.0</td><td>1556.4 1576.7</td><td>846.7 866.1</td></tr><tr><td>medium</td><td>MBOP-NOPP</td><td>4</td><td>100.0</td><td>0.3</td><td>0.01</td><td>0.0</td><td>124.8</td><td>65.2</td></tr><tr><td>medium</td><td>MBOP-NOVF</td><td>40</td><td>100.0</td><td>0.3</td><td>0.01</td><td>0.0</td><td>1479.4</td><td>770.0</td></tr><tr><td>medium</td><td>PDDM</td><td>40</td><td>100.0</td><td>0.3</td><td>0.01</td><td>0.0</td><td>104.7</td><td>7.8</td></tr><tr><td>mixed</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>mixed</td><td>CLONING MBOP</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>308.2</td><td>223.2</td></tr><tr><td>mixed</td><td>MBOP-NOPP</td><td>4 4</td><td>100.0 100.0</td><td>0.3 0.3</td><td>0.02</td><td>0.0 0.0</td><td>400.5 141.1</td><td>189.1</td></tr><tr><td>mixed</td><td>MBOP-NOVF</td><td>150</td><td>100.0</td><td>0.3</td><td>0.02 0.02</td><td>0.0</td><td>347.7</td><td>46.4 163.0</td></tr><tr><td>mixed</td><td>PDDM</td><td>150</td><td>100.0</td><td>0.3</td><td>0.02</td><td>0.0</td><td>101.6</td><td>36.5</td></tr><tr><td>random</td><td>CLONING</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>random</td><td>MBOP</td><td>- 4</td><td>- 100.0</td><td>- 10</td><td>-</td><td>- 0.0</td><td>289.5 350.1</td><td>6.0</td></tr><tr><td>random</td><td>MBOP-NOPP</td><td></td><td>100.0</td><td></td><td>0.4</td><td></td><td></td><td>9.5</td></tr><tr><td>random</td><td>MBOP-NOVF</td><td>4 15</td><td>100.0</td><td>10 10</td><td>0.4</td><td>0.0 0.0</td><td>81.8 334.4</td><td>42.3</td></tr><tr><td>random</td><td>PDDM</td><td>15</td><td>100.0</td><td>10</td><td>0.4 0.4</td><td>0.0</td><td>44.2</td><td>21.1 12.0</td></tr></table>
+
+Table 8: D4RL Walker2d Performance  
+
+<table><tr><td>Dataset</td><td>Policy</td><td>Horizon</td><td># Samples</td><td>Kappa</td><td>Sigma</td><td>Beta</td><td>Mean</td><td>1-STD</td></tr><tr><td>med-expert</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>3006.0</td><td>1844.8</td></tr><tr><td>med-expert</td><td>MBOP</td><td>2</td><td>1000</td><td>1</td><td>0.05</td><td>0</td><td>3222.8</td><td>1660.7</td></tr><tr><td>med-expert</td><td>MBOP-NOPP</td><td>2</td><td>1000</td><td></td><td>0.05</td><td>0</td><td>-6.0</td><td>0.6</td></tr><tr><td>med-expert</td><td>MBOP-NOVF</td><td>15</td><td>1000</td><td>1</td><td></td><td></td><td>2302.7</td><td>1981.2</td></tr><tr><td>med-expert</td><td>PDDM</td><td>15</td><td>1000</td><td>1 1</td><td>0.05 0.05</td><td>0 0.2</td><td>209.4</td><td>113.1</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>mixed</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>528.7</td><td>335.0</td></tr><tr><td>mixed</td><td>MBOP</td><td>8</td><td>1000</td><td>3</td><td>0.02</td><td>0</td><td>447.1</td><td>243.8</td></tr><tr><td>mixed</td><td>MBOP-NOPP</td><td>8</td><td>1000</td><td>3</td><td>0.02</td><td>0</td><td>239.3</td><td>51.5</td></tr><tr><td>mixed mixed</td><td>MBOP-NOVF PDDM</td><td>10 10</td><td>1000 1000</td><td>3 3</td><td>0.02</td><td>0</td><td>530.0</td><td>228.8</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>0.02</td><td>0</td><td>246.0</td><td>5.6</td></tr><tr><td>medium</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>706.8</td><td>1134.5</td></tr><tr><td>medium</td><td>MBOP</td><td>2</td><td>1000</td><td>0.1</td><td>0.2</td><td>0</td><td>1881.9</td><td>1350.7</td></tr><tr><td>medium medium</td><td>MBOP-NOPP</td><td>2</td><td>1000</td><td>0.1</td><td>0.2</td><td>0</td><td>-9.9</td><td>12.8</td></tr><tr><td>medium</td><td>MBOP-NOVF PDDM</td><td>150 150</td><td>1000 1000</td><td>0.1</td><td>0.2</td><td>0</td><td>341.7</td><td>504.6</td></tr><tr><td></td><td></td><td></td><td></td><td>0.1</td><td>0.2</td><td>0</td><td>-2.7</td><td>10.3</td></tr><tr><td>random</td><td>CLONING</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>2.7</td><td>0.6</td></tr><tr><td>random</td><td>MBOP</td><td>8</td><td>1000</td><td>0.3</td><td>0.4</td><td>0</td><td>371.1</td><td>252.3</td></tr><tr><td>random</td><td>MBOP-NOPP</td><td>8</td><td>1000</td><td>0.3</td><td>0.4</td><td>0</td><td>484.5</td><td>268.9</td></tr><tr><td>random</td><td>MBOP-NOVF</td><td>15</td><td>1000</td><td>0.3</td><td>0.4</td><td>0</td><td>220.4</td><td>124.7</td></tr><tr><td>random</td><td>PDDM</td><td>15</td><td>1000</td><td>0.3</td><td>0.4</td><td>0</td><td>498.9</td><td>463.0</td></tr></table>
+
+# 5.3 MBOP ABLATIONS
+
+Full results for the various ablations of MBOP are visualized in Figures 4 and 5.
+
+![](images/b6bfeb2996edb67c17aa8d3bbc2d86a20344bcfdb14496de7480f9833f9f500d.jpg)  
+Figure 4: Ablation results on multi-sized datasets form RLU and D4RL.
+
+![](images/846d03b62eb93c112af687e29857270e37a1cd41e567104a3853b6d0e0af8b2a.jpg)  
+Figure 5: Performance on D4RL tasks from MBOP.
+
+# 5.4 EXECUTION SPEED
+
+<table><tr><td>Policy</td><td>Horizon</td><td>Frequency (Hz)</td></tr><tr><td>BC</td><td>N/A</td><td>362</td></tr><tr><td>MBOP</td><td>4</td><td>106</td></tr><tr><td>MBOP</td><td>8</td><td>71</td></tr><tr><td>MBOP</td><td>16</td><td>40</td></tr></table>
+
+Table 9: MBOP maximum control frequencies (steps/second) including simulator time on an Tesla P100 using a single core of a Xeon $2 2 0 0 \mathrm { M H z }$ equivalent processor.
+
+Execution speeds on the RLU Walker task in represented in Table 9. We see that we can easily achieve control frequencies below $1 0 \mathrm { H z }$ , but cannot currently attain $1 0 0 \mathrm { H z }$ with longer horizons. For lower level control policies for which high-frequency is important, we would suggest distilling the controller into a task-specific policy similar to MoREL (Kidambi et al., 2020) or MOPO (Yu et al., 2020).
+
+# 5.5 MBOP PARAMETERS
+
+All parameters were set as follows except for the D4RL Walker task where we use 15 ensemble networks.
+
+• # FC Layers : 2   
+• Size FC Layers : 500   
+• # Ensemble Networks : 3   
+• Learning Rate : 0.001   
+• Batch Size : 512   
+• # Epochs : 40
+
+# CONTINUED ANALYSIS OF CONSTRAINED TASKS
+
+We can see the height-constrained Walker performance in Figure 6a. MBOP is able to satisfy the height constraint $80 \%$ of the episode while maintaining reasonable performance. Over the various ablations we have found that MBOP is better able to maintain base task performance for similar constraint satisfaction rates.
+
+![](images/fdaef208f1c95aa39a00c2d3b57592cda5bd81cb7526b864ec8621efc686b121.jpg)  
+Figure 6: Effects of constraints on MBOP performance.
+
+(a) This figure describes the performance of MBOP on RLU Walker when constrained to stay below a height threshold. We see that MBOP is able to increase the rate of respect of the constraint compared to the behavior policy while maintaining similar episode returns.
+
+![](images/0dcfe38934f918228169abdf1221c6eb3e3602b6579bc0b23f82e6736211d35a.jpg)
+
+(b) Cartpole task constrained to right or left half of the track. We can see that MBOP is able to respect the constraint while maintaining performance on both tasks.
+
+# HYPERPARAMETER STABILITY
+
+Figure 7 shows the sensitivity of MBOP and associated ablations to the Beta and Horizon parameters. Figure 8 shows the effects of Sigma to MBOP and ablations on the RLU datasets. Figure 6b shows sensitivity to Horizon and Kappa in synchrony.
+
+# 5.6 IMPACT OF FILTERING POOR EPISODES
+
+As mentioned in the above part of the paper, for RLU / Quadruped and RLU / Walker we exclude the episodes with lowest returns before training the behavior cloning and value function models. In this section we report the performances on these environment with various filtering thresholds.
+
+For each of these two environments, and each of the dataset sizes we keep a subset of the initial dataset by filtering on the top episodes. We experiments with filters varying from the top- $1 \%$ to the top- $100 \%$ (i.e. the entire raw dataset).
+
+Table 10: MBOP performance on RLU / Quadruped with various filtering thresholds for top episodes   
+
+<table><tr><td>Initial # datapoints</td><td>Filtered Top Percent</td><td>Mean</td><td>1-STD</td></tr><tr><td>5000</td><td>1</td><td>902</td><td>92</td></tr><tr><td>5000</td><td>5</td><td>908</td><td>64</td></tr><tr><td>5000</td><td>10</td><td>897</td><td>108</td></tr><tr><td>5000</td><td>20</td><td>916</td><td></td></tr><tr><td>5000</td><td>40</td><td>961</td><td>B305394</td></tr><tr><td>5000</td><td>60</td><td>951</td><td></td></tr><tr><td>5000</td><td>80</td><td>955</td><td></td></tr><tr><td>5000</td><td>90</td><td>966</td><td>12</td></tr><tr><td>5000</td><td>100</td><td>960</td><td>43</td></tr><tr><td>25000</td><td>1</td><td>809</td><td>268</td></tr><tr><td>25000</td><td>5</td><td>850</td><td>229</td></tr><tr><td>25000</td><td>10</td><td>973</td><td>49</td></tr><tr><td>25000</td><td>20</td><td>965</td><td>16</td></tr><tr><td>25000</td><td>40</td><td>744</td><td>329</td></tr><tr><td>25000</td><td>60</td><td>365</td><td>289</td></tr><tr><td>25000</td><td>80</td><td>320</td><td>262</td></tr><tr><td>25000</td><td>90</td><td>221</td><td>178</td></tr><tr><td>25000</td><td>100</td><td>115</td><td>69</td></tr><tr><td>100000</td><td>1</td><td>976</td><td>67</td></tr><tr><td>100000</td><td>5</td><td>986</td><td>4</td></tr><tr><td>100000</td><td>10</td><td>987</td><td>4</td></tr><tr><td>100000</td><td>20</td><td>989</td><td>3</td></tr><tr><td>100000</td><td>40</td><td>985</td><td>23</td></tr><tr><td>100000</td><td>60</td><td>876</td><td>230</td></tr><tr><td>100000</td><td>80</td><td>896</td><td>221</td></tr><tr><td>100000</td><td>90</td><td>921</td><td>177</td></tr><tr><td>100000</td><td>100</td><td>547</td><td>353</td></tr><tr><td>200000</td><td>1</td><td>989</td><td>2</td></tr><tr><td>200000</td><td>5</td><td>990</td><td>2</td></tr><tr><td>200000</td><td>10</td><td>993</td><td>2</td></tr><tr><td>200000</td><td>20</td><td>994</td><td>1</td></tr><tr><td>200000</td><td>40</td><td>991</td><td>2</td></tr><tr><td>200000</td><td>60</td><td>990</td><td>4</td></tr><tr><td>200000</td><td>80</td><td>878</td><td>254</td></tr><tr><td>200000</td><td>90</td><td>889</td><td>259</td></tr><tr><td>200000</td><td>100</td><td>876</td><td>252</td></tr><tr><td>500000</td><td>1</td><td>991</td><td>1</td></tr><tr><td>500000</td><td>5</td><td>992</td><td>1</td></tr><tr><td>500000</td><td>10</td><td>995</td><td>1</td></tr><tr><td>500000</td><td>20</td><td>994</td><td>1</td></tr><tr><td>500000</td><td>40</td><td>991</td><td>2</td></tr><tr><td>500000</td><td>60</td><td>992</td><td>2</td></tr><tr><td>500000</td><td>80</td><td>986</td><td>50</td></tr><tr><td>500000</td><td>90</td><td>991</td><td>3</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>500000</td><td>100</td><td>991</td><td>2</td></tr></table>
+
+Table 11: MBOP performance on RLU / Walker with various filtering thresholds for top episodes   
+
+<table><tr><td>Initial # datapoints</td><td>Filtered Top Percent</td><td>Mean</td><td>1-STD</td></tr><tr><td>50000</td><td>1</td><td>49</td><td>63</td></tr><tr><td>50000</td><td>5</td><td>86</td><td>112</td></tr><tr><td>50000</td><td>10</td><td>195</td><td>252</td></tr><tr><td>50000</td><td>20</td><td>243</td><td>293</td></tr><tr><td>50000</td><td>40</td><td>636</td><td>269</td></tr><tr><td>50000</td><td>60</td><td>750</td><td>182</td></tr><tr><td>50000</td><td>80</td><td>772</td><td>119</td></tr><tr><td>50000</td><td>90</td><td>719</td><td>201</td></tr><tr><td>50000</td><td>100</td><td>770</td><td>124</td></tr><tr><td>250000</td><td>1</td><td>111</td><td>113</td></tr><tr><td>250000</td><td>5</td><td>397</td><td>397</td></tr><tr><td>250000</td><td>10</td><td>410</td><td>406</td></tr><tr><td>250000</td><td>20</td><td>810</td><td>171</td></tr><tr><td>250000</td><td>40</td><td>848</td><td>42</td></tr><tr><td>250000</td><td>60</td><td>842</td><td>45</td></tr><tr><td>250000</td><td>80</td><td>836</td><td>46</td></tr><tr><td>250000</td><td>90</td><td>848</td><td>45</td></tr><tr><td>250000</td><td>100</td><td>838</td><td>43</td></tr><tr><td>1000000</td><td>1</td><td>154</td><td>201</td></tr><tr><td>1000000</td><td>5</td><td>670</td><td>348</td></tr><tr><td>1000000</td><td>10</td><td>870</td><td>88</td></tr><tr><td>1000000</td><td>20</td><td>858</td><td>101</td></tr><tr><td>1000000</td><td>40</td><td>858</td><td>63</td></tr><tr><td>1000000</td><td>60</td><td>859</td><td>97</td></tr><tr><td>1000000</td><td>80</td><td>851</td><td>47</td></tr><tr><td>1000000</td><td>90</td><td>847</td><td>53</td></tr><tr><td>1000000</td><td>100</td><td>855</td><td>46</td></tr><tr><td>2000000</td><td>1</td><td>618</td><td>386</td></tr><tr><td>2000000</td><td>5</td><td>741</td><td>348</td></tr><tr><td>2000000</td><td>10</td><td>859</td><td>194</td></tr><tr><td>2000000</td><td>20</td><td>876</td><td>111</td></tr><tr><td>2000000</td><td>40</td><td>867</td><td>62</td></tr><tr><td>2000000</td><td>60</td><td>860</td><td>59</td></tr><tr><td>2000000</td><td>80</td><td>888</td><td>55</td></tr><tr><td>2000000 2000000</td><td>90</td><td>873</td><td>60</td></tr><tr><td></td><td>100</td><td>858</td><td>61</td></tr><tr><td>5000000 5000000</td><td>1</td><td>639</td><td>404</td></tr><tr><td>5000000</td><td>5</td><td>875</td><td>179</td></tr><tr><td>5000000</td><td>10</td><td>909</td><td>37</td></tr><tr><td></td><td>20</td><td>907</td><td>49</td></tr><tr><td>5000000</td><td>40</td><td>892</td><td>60</td></tr><tr><td>5000000</td><td>60</td><td>892</td><td>585468</td></tr><tr><td>5000000</td><td>80</td><td>853</td><td></td></tr><tr><td>5000000</td><td>90</td><td>875</td><td></td></tr><tr><td>5000000</td><td>100</td><td>863</td><td>65</td></tr></table>
+
+![](images/cd8a5a4efbc3b89d2fdcfa3ac54ff24328de73ed193cf86330274166d998e374.jpg)  
+Figure 7: MBOP sensitivity to Beta & Horizon on RLU datasets.
+
+(e) Sensitivity to Horizon parameter on RLU / Walker. (f) Sensitivity to Horizon parameter on RLU / Cartpole.
+
+![](images/69b83d9f3ce3acce8decb1effb76da72de94d1f8964c4ed222e98c0bdddfa2d5.jpg)  
+Figure 8: MBOP sensitivity to Sigma on RLU datasets.
+
+(c) Sensitivity to Sigma parameter on RLU / Cartpole.
+
+![](images/2a8142081e0f7486a01c4972da4b37457301989e413d222686f5db31c7a4e544.jpg)  
+MBOP sensitivity to Horizon x Kappa on RLU - 100%   
+Figure 9: Sensitivity to Horizon x Kappa on RLU environments (full datasets). Legend represents average episode return.